/// <summary>
/// Build and write standard telemetry items to <see cref="Its.Log" />.
/// </summary>
protected static void WriteStandardTelemetry()
{
/*---------------------------------------------------------------------------*
* Write telemetry: Log telemetry general records *
*---------------------------------------------------------------------------*/
var dateTimeOfSampleInUtc = DateTime.UtcNow;
var machineDetails = DomainFactory.CreateMachineDetails();
var processDetails = DomainFactory.CreateProcessDetails();
var processDirectory = Path.GetDirectoryName(processDetails.FilePath) ?? throw new InvalidOperationException("Could not get directory from process file path: " + processDetails.FilePath);
var processSiblingAssemblies = Directory.GetFiles(processDirectory, "*", SearchOption.AllDirectories)
.Where(_ => _.ToLowerInvariant().EndsWith(".exe") || _.ToLowerInvariant().EndsWith(".dll")).Select(_ =>
{
try
{
return(AssemblyDetails.CreateFromFile(_));
}
catch (Exception)
{
return(new AssemblyDetails(Path.ChangeExtension(Path.GetFileName(_), string.Empty), Version.Parse("1.0.0.0").ToString(), _, "UNKNOWN"));
}
})
.ToList();
var diagnosticsTelemetry = new DiagnosticsTelemetry(dateTimeOfSampleInUtc, machineDetails, processDetails, processSiblingAssemblies);
Its.Log.Instrumentation.Log.Write(() => diagnosticsTelemetry);
}
public static void CreateFromFile_VerifyWillUseAlreadyLoadedIfSpecified()
{
// NOTE: this is just running the scenario in a separate appdomain to prove it does not get polluted with any additional types when working directly from a file.
// arrange
var codeBase = typeof(AssemblyDetails).Assembly.CodeBase;
var assemblyFilePath = new Uri(codeBase).PathAndQuery.Replace('/', Path.DirectorySeparatorChar);
// act
var firstFromCurrentAppDomainLoadedTypes = AssemblyDetails.CreateFromFile(assemblyFilePath);
// assert
firstFromCurrentAppDomainLoadedTypes.Should().NotBeNull();
AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic).SelectMany(
a =>
{
try
{
return(a.GetExportedTypes());
}
catch (Exception)
{
/* no-op */
}
return(Enumerable.Empty <Type>());
}).SingleOrDefault(_ => _.Name == nameof(AssemblyDetails)).Should().NotBeNull();
// act
Action <string> action = localAssemblyFilePath => AssemblyDetails.CreateFromFile(localAssemblyFilePath, false);
// using a dedicated AppDomain so if there are issues it will not pollute the existing AppDomain which is used for serialization et al. in other tests.
using (var domain = AppDomainHelper.CreateDisposableAppDomain())
{
action.ExecuteInAppDomain(assemblyFilePath, domain);
action.ExecuteInAppDomain(assemblyFilePath, domain);
// assert
var loadedAssemblyDetails = domain.AppDomain.GetAssemblies()
.Where(a => !a.IsDynamic)
.SelectMany(
a =>
{
try
{
return(a.GetExportedTypes());
}
catch (Exception)
{
/* no-op */
}
return(Enumerable.Empty <Type>());
})
.Where(_ => _.Name == nameof(AssemblyDetails))
.ToList();
loadedAssemblyDetails.Should().HaveCount(1);
}
}
public void Ctor_StoresPathsProvided()
{
var instance = new AssemblyDetails("one", "two", typeof(TestInstaller));
Assert.That(instance.Path, Is.EqualTo("one"));
Assert.That(instance.BinaryPath, Is.EqualTo("two"));
}
public static void CollectRoslynAssemblies(
string roslynBinariesDirectoryPath,
ref IImmutableDictionary <AssemblyShortName, AssemblyDetails> mainAssemblies,
out IImmutableDictionary <AssemblyShortName, AssemblyDetails> usedRoslynAssemblies,
out IImmutableDictionary <AssemblyShortName, string> roslynAssemblyPaths
)
{
var roslynAssemblyPathsBuilder = ImmutableSortedDictionary.CreateBuilder <AssemblyShortName, string>();
var usedRoslynAssembliesBuilder = ImmutableSortedDictionary.CreateBuilder <AssemblyShortName, AssemblyDetails>();
FluentConsole.White.Line($"Scanning {roslynBinariesDirectoryPath}…");
foreach (var assemblyPath in Directory.EnumerateFiles(roslynBinariesDirectoryPath, "*.dll", SearchOption.AllDirectories))
{
FluentConsole.Gray.Line($" {Path.GetFileName(assemblyPath)}");
var name = Path.GetFileNameWithoutExtension(assemblyPath);
// ReSharper disable once AssignNullToNotNullAttribute
var assemblyFromMain = mainAssemblies.GetValueOrDefault(name);
if (assemblyFromMain != null)
{
FluentConsole.Gray.Line(" [used by main]");
usedRoslynAssembliesBuilder.Add(name, AssemblyDetails.ReadFrom(assemblyPath, readSymbols: true));
mainAssemblies = mainAssemblies.Remove(name);
}
if (roslynAssemblyPathsBuilder.ContainsKey(name))
{
continue;
}
roslynAssemblyPathsBuilder.Add(name, assemblyPath);
}
usedRoslynAssemblies = usedRoslynAssembliesBuilder.ToImmutable();
roslynAssemblyPaths = roslynAssemblyPathsBuilder.ToImmutable();
}
public void AssemblyDetails_created_from_specific_assembly()
{
// Arrange
var targetAssembly = typeof(AssemblyDetails).Assembly;
// Act
var assemblyDetails = new AssemblyDetails(targetAssembly);
// Assert
assemblyDetails.ShouldNotBeNull();
assemblyDetails.AssemblyName.Name.ShouldBe(targetAssembly.GetName().Name);
assemblyDetails.Name.ShouldBe(targetAssembly.GetName().Name);
assemblyDetails.Location.ShouldBe(targetAssembly.Location);
assemblyDetails.FileName.ShouldNotBeNull();
assemblyDetails.FileName.ShouldNotBeEmpty();
assemblyDetails.Title.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyTitleAttribute>().First().Title);
assemblyDetails.Product.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyProductAttribute>().First().Product);
assemblyDetails.Copyright.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyCopyrightAttribute>().First().Copyright);
assemblyDetails.Company.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyCompanyAttribute>().First().Company);
assemblyDetails.Description.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyDescriptionAttribute>().First().Description);
assemblyDetails.Trademark.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyTrademarkAttribute>().FirstOrDefault()?.Trademark);
assemblyDetails.Configuration.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyConfigurationAttribute>().First().Configuration);
assemblyDetails.Version.ShouldBe(targetAssembly.GetName().Version);
assemblyDetails.FileVersion.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyFileVersionAttribute>().First().Version);
assemblyDetails.InformationalVersion.ShouldBe(targetAssembly.GetCustomAttributes <AssemblyInformationalVersionAttribute>().First().InformationalVersion);
assemblyDetails.SimplifiedVersion.ShouldBe(assemblyDetails.Version.Simplify());
}
private static void WriteAssembly(AssemblyDetails assembly, string targetPath, IImmutableDictionary <AssemblyShortName, AssemblyDetails> mainAssemblies)
{
var assemblyName = assembly.Definition.Name;
assemblyName.PublicKey = new byte[0];
assemblyName.PublicKeyToken = new byte[0];
assemblyName.HasPublicKey = false;
var targetDirectoryPath = Path.GetDirectoryName(targetPath);
var resolver = (BaseAssemblyResolver)assembly.Definition.MainModule.AssemblyResolver;
foreach (var defaultPath in resolver.GetSearchDirectories())
{
resolver.RemoveSearchDirectory(defaultPath);
}
resolver.AddSearchDirectory(targetDirectoryPath);
resolver.ResolveFailure += (sender, reference) => {
var mainAssembly = mainAssemblies.GetValueOrDefault(reference.Name);
if (mainAssembly == null)
{
return(null);
}
return(mainAssembly.Definition);
};
assembly.Definition.Write(targetPath);
}
public static void CollectRoslynReferences(
ref IImmutableDictionary <AssemblyShortName, AssemblyDetails> usedRoslynAssemblies,
IImmutableDictionary <AssemblyShortName, string> roslynAssemblyPaths,
ref IImmutableDictionary <AssemblyShortName, AssemblyDetails> mainAssemblies,
IImmutableDictionary <AssemblyShortName, IImmutableSet <PackageInfo> > roslynPackageMap,
out IImmutableDictionary <AssemblyShortName, AssemblyDetails> othersReferencedByRoslyn
)
{
var othersReferencedByRoslynBuilder = ImmutableSortedDictionary.CreateBuilder <AssemblyShortName, AssemblyDetails>();
FluentConsole.White.Line("Analyzing Roslyn references…");
var seen = new HashSet <AssemblyShortName>();
var queue = new Queue <AssemblyDetails>(usedRoslynAssemblies.Values);
while (queue.Count > 0)
{
var assembly = queue.Dequeue();
FluentConsole.Gray.Line($" {assembly.Definition.Name.Name}");
seen.Add(assembly.Definition.Name.Name);
foreach (var reference in assembly.Definition.MainModule.AssemblyReferences)
{
if (!seen.Add(reference.Name))
{
continue;
}
FluentConsole.Gray.Line($" {reference.FullName}");
mainAssemblies = mainAssemblies.Remove(reference.Name);
if (usedRoslynAssemblies.ContainsKey(reference.Name))
{
FluentConsole.Gray.Line(" [roslyn assembly, already used]");
continue;
}
var roslynAssemblyPath = roslynAssemblyPaths.GetValueOrDefault(reference.Name);
if (roslynAssemblyPath != null)
{
FluentConsole.Gray.Line(" [roslyn assembly, queued]");
var roslynAssembly = AssemblyDetails.ReadFrom(roslynAssemblyPath, readSymbols: true);
usedRoslynAssemblies = usedRoslynAssemblies.Add(roslynAssembly.Definition.Name.Name, roslynAssembly);
queue.Enqueue(roslynAssembly);
continue;
}
if (InGlobalAssemblyCache(reference))
{
FluentConsole.Gray.Line(" [gac]");
continue;
}
var referencedAssembly = GetAssemblyDetailsFromNuGetCache(reference.Name, roslynPackageMap);
if (referencedAssembly == null)
{
FluentConsole.Gray.Line(" [system?]");
continue;
}
othersReferencedByRoslynBuilder.Add(reference.Name, referencedAssembly);
queue.Enqueue(referencedAssembly);
}
}
othersReferencedByRoslyn = othersReferencedByRoslynBuilder.ToImmutable();
}
/*** Constructor & Initialization ***/
#region
public UserSettings()
{
// Default Values
AssemblyDetails assemblyInfo = AssemblyInformation.GetAssemblyDetails();
Version = assemblyInfo.Version;
ServerPort = 8080;
Server = "";
MainFormProperties = new WindowSettings();
}
public void Ctor_ModuleDefInput_ParsesFullNameToNameAndVersionProps()
{
var name = "This.Is.A.FullName";
var version = "3.2.0.0";
var fullName = $"{name}, Version={version}, Culture=neutral, PublicKeyToken=50e96378b6e77783";
var cut = new AssemblyDetails(new ModuleDefUser(fullName));
Assert.Equal(name, cut.FullName);
Assert.Equal(version, cut.Version);
}
public void FindFirstAvailableInstaller_AssemblyFound_ReturnsManifest()
{
var foundAssembly = new AssemblyDetails("", "", typeof(TestInstaller));
_discoverer.Setup(x => x.FindAssemblies(It.IsAny <string>())).Returns(new List <AssemblyDetails> {
foundAssembly
});
_loader.Setup(x => x.Load(It.IsAny <string>())).Returns(Assembly.GetAssembly(typeof(PathScannerTests)));
var manifest = _pathScanner.FindFirstAvailableInstaller();
Assert.That(manifest, Is.TypeOf <ConfiguredInstallationManifest>());
}
public void FindFirstAvailableInstaller_MultipleAssembliesFound_ReturnsManifestForFirstOne()
{
var expectedAssembly = new AssemblyDetails("c:\\path", "expect.this.dll", typeof(TestInstaller));
var shouldNotCreate = new AssemblyDetails("c:\\path", "do.not.expect.this.dll", typeof(TestInstaller));
_discoverer.Setup(x => x.FindAssemblies(It.IsAny <string>())).Returns(new List <AssemblyDetails> {
expectedAssembly, shouldNotCreate
});
_loader.Setup(x => x.Load("c:\\path\\expect.this.dll")).Returns(Assembly.GetAssembly(typeof(PathScannerTests)));
var manifest = _pathScanner.FindFirstAvailableInstaller();
Assert.That(manifest.DiscoveredDetails, Is.EqualTo(expectedAssembly));
}
public void Ctor_StoresProvidedArguments()
{
var config = new InstallationConfiguration("path");
var installer = new TestInstaller();
const string path = "path";
var discoveredDetails = new AssemblyDetails(path, "binary.dll", typeof(TestInstaller));
var dto = new ConfiguredInstallationManifest(config, installer, path, discoveredDetails);
Assert.That(dto.InstallationConfiguration, Is.EqualTo(config));
Assert.That(dto.SourceInstaller, Is.EqualTo(installer));
Assert.That(dto.Path, Is.EqualTo(path));
Assert.That(dto.DiscoveredDetails, Is.EqualTo(discoveredDetails));
}
public void FindFirstAvailableInstaller_AssemblyFound_ReturnsConfiguredManifestForAssembly()
{
var foundAssembly = new AssemblyDetails("c:\\path", "binary.dll", typeof(TestInstaller));
_discoverer.Setup(x => x.FindAssemblies(It.IsAny <string>())).Returns(new List <AssemblyDetails> {
foundAssembly
});
_loader.Setup(x => x.Load("c:\\path\\binary.dll")).Returns(Assembly.GetAssembly(typeof(PathScannerTests)));
var manifest = _pathScanner.FindFirstAvailableInstaller();
Assert.That(manifest.InstallationConfiguration, Is.Not.Null);
Assert.That(manifest.Path, Is.EqualTo(_siteScanPath));
Assert.That(manifest.SourceInstaller, Is.InstanceOf <ISiteInstaller>());
}
private static AssemblyDetails GetAssemblyDetailsFromNuGetCache(
AssemblyShortName name,
IImmutableDictionary <AssemblyShortName, IImmutableSet <PackageInfo> > roslynPackageMap
)
{
var packageInfoSet = roslynPackageMap.GetValueOrDefault(name);
if (packageInfoSet == null)
{
throw new Exception($"Could not identify NuGet package for assembly '{name}' (in packages referenced by Roslyn).");
}
if (packageInfoSet.Count > 1)
{
throw new Exception($"Ambiguous match for NuGet package for assembly '{name}':\r\n {string.Join("\r\n ", packageInfoSet)}.");
}
var packageInfo = packageInfoSet.Single();
FluentConsole.Gray.Line($" {packageInfo.PackageId}.{packageInfo.PackageVersion}");
var packageVersionPath = Path.Combine(LocalNuGetCachePath, packageInfo.PackageId, packageInfo.PackageVersion);
var libPath = Path.Combine(packageVersionPath, "lib");
var frameworkPath = new DirectoryInfo(libPath)
.EnumerateDirectories()
.Where(f => SupportedFrameworkNames.ContainsKey(f.Name))
.OrderBy(f => SupportedFrameworkNames[f.Name])
.FirstOrDefault()
?.FullName;
if (frameworkPath == null)
{
throw new DirectoryNotFoundException($"Could not find compatible framework for assembly '{name}' in NuGet cache, under {libPath}.");
}
if (File.Exists(Path.Combine(frameworkPath, "_._")))
{
return(null);
}
var assemblyPath = Path.Combine(frameworkPath, name.Name + ".dll");
if (!File.Exists(assemblyPath))
{
throw new FileNotFoundException($"Could not find assembly '{name}' in NuGet cache, at {assemblyPath}.", assemblyPath);
}
return(AssemblyDetails.ReadFrom(assemblyPath, readSymbolsIfExist: false));
}
/// <summary>
/// Load in the application domain all the required assemblies.
/// </summary>
private void LoadAssemblies()
{
var assemblies = Program.Assemblies.ToList();
var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
var assembliesPath = new List <String>();
assembliesPath.Add("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
assembliesPath.Add("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
assembliesPath.Add("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
assembliesPath.Add("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
assembliesPath.Add("Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
assembliesPath.Add("PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
assembliesPath.Add("PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
assembliesPath.Add("WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
foreach (var path in assembliesPath)
{
if (assemblies.All(a => string.CompareOrdinal(a.ToLocationOrFullName(), path) != 0))
{
assemblies.Add(AssemblyInfoHelper.GetAssemblyDetailsFromNameOrLocation(path));
}
}
AssemblyDetails details = null;
try
{
for (int i = 0; i < assemblies.Count; i++)
{
details = assemblies[i];
_assemblySandbox.LoadAssembly(details, false);
if (Verbose)
{
ChangeState(this, new BaZicInterpreterStateChangeEventArgs(L.BaZic.Runtime.BaZicInterpreter.FormattedAssemblyLoaded(details.ToLocationOrFullName())));
}
}
}
catch (Exception exception)
{
CoreHelper.ReportException(exception);
ChangeState(this, new LoadAssemblyException(L.BaZic.Runtime.BaZicInterpreter.FormattedAssemblyFailedLoad(details.ToLocationOrFullName()), details.ToLocationOrFullName(), exception));
}
}
public static void ToString___Should_be_useful()
{
// Arrange
var name = A.Dummy <string>();
var version = A.Dummy <string>();
var filePath = A.Dummy <string>();
var frameworkVersion = A.Dummy <string>();
var systemUnderTest = new AssemblyDetails(name, version, filePath, frameworkVersion);
// Act
var actualToString = systemUnderTest.ToString();
// Assert
actualToString.Should().Contain(name);
actualToString.Should().Contain(version);
actualToString.Should().Contain(filePath);
actualToString.Should().Contain(frameworkVersion);
}
private static void WriteAssembly(AssemblyDetails assembly, string targetPath)
{
var assemblyName = assembly.Definition.Name;
assemblyName.PublicKey = new byte[0];
assemblyName.PublicKeyToken = new byte[0];
assemblyName.HasPublicKey = false;
var targetDirectoryPath = Path.GetDirectoryName(targetPath);
var resolver = (BaseAssemblyResolver)assembly.Definition.MainModule.AssemblyResolver;
foreach (var defaultPath in resolver.GetSearchDirectories())
{
resolver.RemoveSearchDirectory(defaultPath);
}
resolver.AddSearchDirectory(targetDirectoryPath);
assembly.Definition.Write(targetPath);
}
public static void CollectMainAssemblies(string binariesDirectoryPath, out IImmutableDictionary <AssemblyShortName, AssemblyDetails> mainAssemblies)
{
FluentConsole.White.Line($"Scanning {binariesDirectoryPath}…");
var mainAssembliesBuilder = ImmutableSortedDictionary.CreateBuilder <AssemblyShortName, AssemblyDetails>();
foreach (var assemblyPath in Directory.EnumerateFiles(binariesDirectoryPath, "*.*"))
{
if (!Regex.IsMatch(assemblyPath, @"(?:\.dll|\.exe)$", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
{
continue;
}
FluentConsole.Gray.Line($" {Path.GetFileName(assemblyPath)}");
var name = Path.GetFileNameWithoutExtension(assemblyPath);
// ReSharper disable once AssignNullToNotNullAttribute
mainAssembliesBuilder.Add(name, AssemblyDetails.ReadFrom(assemblyPath, readSymbols: false));
}
mainAssemblies = mainAssembliesBuilder.ToImmutable();
}
// ******************************************************************
private void AddReferencedAssemblyFor(AssemblyDetails assemblyDetailsReferer, AssemblyName assemblyName)
{
var existingReferencedAsm = ReferencedAssemblies.FirstOrDefault(refAsm => refAsm.UniqueName == ReferencedAssembly.GetUniqueNameFromAssemblyName(assemblyName));
if (existingReferencedAsm == null)
{
existingReferencedAsm = new ReferencedAssembly(assemblyName);
object o1 = assemblyName.ProcessorArchitecture;
object o2 = assemblyName.Flags;
//string asmPath = Path.Combine(DirectoryPath, assemblyName.Name + ".dll");
//if (File.Exists(asmPath))
//{
// Assembly asm = Assembly.ReflectionOnlyLoadFrom(asmPath);
//}
this.ReferencedAssemblies.Add(existingReferencedAsm);
}
existingReferencedAsm.Referers.Add(assemblyDetailsReferer);
}
private static AssemblyDetails SafeFetchAssemblyDetails(Assembly assembly)
{
new { assembly }.AsArg().Must().NotBeNull();
// get a default
var assemblyName = assembly.GetName();
var ret = new AssemblyDetails(
assemblyName?.Name ?? "assembly.GetName() returned null",
(assemblyName?.Version ?? new Version(0, 0)).ToString(),
assembly.Location,
assembly.ImageRuntimeVersion);
try
{
ret = AssemblyDetails.CreateFromAssembly(assembly);
}
catch (Exception)
{
/* no-op - swallow this because we will just get what we get... */
}
return(ret);
}
// ******************************************************************
private void AddReferencedAssemblyFor(AssemblyDetails assemblyDetailsReferer, AssemblyName assemblyName)
{
var existingReferencedAsm = ReferencedAssemblies.FirstOrDefault(refAsm => refAsm.UniqueName == ReferencedAssembly.GetUniqueNameFromAssemblyName(assemblyName));
if (existingReferencedAsm == null)
{
existingReferencedAsm = new ReferencedAssembly(assemblyName);
object o1 = assemblyName.ProcessorArchitecture;
object o2= assemblyName.Flags;
//string asmPath = Path.Combine(DirectoryPath, assemblyName.Name + ".dll");
//if (File.Exists(asmPath))
//{
// Assembly asm = Assembly.ReflectionOnlyLoadFrom(asmPath);
//}
this.ReferencedAssemblies.Add(existingReferencedAsm);
}
existingReferencedAsm.Referers.Add(assemblyDetailsReferer);
}
// ******************************************************************
public static AssemblyAnalysis AnalyseFolder(string directoryPath)
{
var assemblyAnalysis = new AssemblyAnalysis(directoryPath);
DirectoryInfo directoryInfo = null;
try
{
directoryInfo = new DirectoryInfo(directoryPath);
}
catch (Exception)
{
}
if (directoryInfo == null)
{
assemblyAnalysis.Result = "Unable to retreive directory information.";
}
else if (!directoryInfo.Exists)
{
assemblyAnalysis.Result = "Directory does not exists.";
}
else
{
var assemblyFiles = directoryInfo.GetFiles("*.dll").Concat(directoryInfo.GetFiles("*.exe"));
if (!assemblyFiles.Any())
{
assemblyAnalysis.Result = "No .dll or .exe files found.";
}
else
{
var sbResult = new StringBuilder();
// var assemblies = new Dictionary<string, IList<ReferencedAssembly>>();
foreach (var fileInfo in assemblyFiles.OrderBy(asm => asm.Name))
{
Assembly assembly = null;
AssemblyDetails assemblyDetails = null;
try
{
if (!fileInfo.IsAssembly())
{
continue;
}
assembly = Assembly.ReflectionOnlyLoadFrom(fileInfo.FullName);
assemblyDetails = new AssemblyDetails(assembly);
assemblyAnalysis.ListOfAssemblyDetails.Add(assemblyDetails);
}
catch (Exception ex)
{
sbResult.Append(string.Format("Failed to load assembly '{0}': {1}", fileInfo.FullName, ex.Message));
sbResult.Append(Environment.NewLine);
continue;
}
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
assemblyAnalysis.AddReferencedAssemblyFor(assemblyDetails, referencedAssembly);
}
}
//if (onlyConflicts)
// Console.WriteLine("Detailing only conflicting assembly references.");
//foreach (var assembly in assemblies)
//{
// if (skipSystem && (assembly.Key.StartsWith("System") || assembly.Key.StartsWith("mscorlib"))) continue;
// if (!onlyConflicts
// || (onlyConflicts && assembly.Value.GroupBy(x => x.VersionReferenced).Count() != 1))
// {
// Console.ForegroundColor = ConsoleColor.White;
// Console.Write("Reference: ");
// Console.ForegroundColor = ConsoleColor.Gray;
// Console.WriteLine("{0}", assembly.Key);
// var referencedAssemblies = new List<Tuple<string, string>>();
// var versionsList = new List<string>();
// var asmList = new List<string>();
// foreach (var referencedAssembly in assembly.Value)
// {
// var s1 = referencedAssembly.VersionReferenced.ToString();
// var s2 = referencedAssembly.ReferencedBy.GetName().Name;
// var tuple = new Tuple<string, string>(s1, s2);
// referencedAssemblies.Add(tuple);
// }
// foreach (var referencedAssembly in referencedAssemblies)
// {
// if (!versionsList.Contains(referencedAssembly.Item1))
// {
// versionsList.Add(referencedAssembly.Item1);
// }
// if (!asmList.Contains(referencedAssembly.Item1))
// {
// asmList.Add(referencedAssembly.Item1);
// }
// }
// foreach (var referencedAssembly in referencedAssemblies)
// {
// var versionColor = ConsoleColors[versionsList.IndexOf(referencedAssembly.Item1)%ConsoleColors.Length];
// Console.ForegroundColor = versionColor;
// Console.Write(" {0}", referencedAssembly.Item1);
// Console.ForegroundColor = ConsoleColor.White;
// Console.Write(" by ");
// Console.ForegroundColor = ConsoleColor.Gray;
// Console.WriteLine("{0}", referencedAssembly.Item2);
// }
// Console.WriteLine();
// }
//}
sbResult.Append("Loading folder assemblies completed!");
assemblyAnalysis.Result = sbResult.ToString();
}
}
return(assemblyAnalysis);
}
public PrimaryAssemblyEnricher(AssemblyDetails value) : base(nameof(PrimaryAssembly).Humanize(), value, true)
{
}
public ApplicationDetails(AssemblyDetails assembly, Uri companyUri, DateTimeOffset?deployment)
{
Assembly = assembly;
CompanyUri = companyUri;
Deployment = deployment;
}
// ******************************************************************
public static AssemblyAnalysis AnalyseFolder(string directoryPath)
{
var assemblyAnalysis = new AssemblyAnalysis(directoryPath);
DirectoryInfo directoryInfo = null;
try
{
directoryInfo = new DirectoryInfo(directoryPath);
}
catch (Exception)
{
}
if (directoryInfo == null)
{
assemblyAnalysis.Result = "Unable to retreive directory information.";
}
else if (!directoryInfo.Exists)
{
assemblyAnalysis.Result = "Directory does not exists.";
}
else
{
var assemblyFiles = directoryInfo.GetFiles("*.dll").Concat(directoryInfo.GetFiles("*.exe"));
if (!assemblyFiles.Any())
{
assemblyAnalysis.Result = "No .dll or .exe files found.";
}
else
{
var sbResult = new StringBuilder();
// var assemblies = new Dictionary<string, IList<ReferencedAssembly>>();
foreach (var fileInfo in assemblyFiles.OrderBy(asm => asm.Name))
{
Assembly assembly = null;
AssemblyDetails assemblyDetails = null;
try
{
if (!fileInfo.IsAssembly())
{
continue;
}
assembly = Assembly.ReflectionOnlyLoadFrom(fileInfo.FullName);
assemblyDetails = new AssemblyDetails(assembly);
assemblyAnalysis.ListOfAssemblyDetails.Add(assemblyDetails);
}
catch (Exception ex)
{
sbResult.Append(string.Format("Failed to load assembly '{0}': {1}", fileInfo.FullName, ex.Message));
sbResult.Append(Environment.NewLine);
continue;
}
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
assemblyAnalysis.AddReferencedAssemblyFor(assemblyDetails, referencedAssembly);
}
}
//if (onlyConflicts)
// Console.WriteLine("Detailing only conflicting assembly references.");
//foreach (var assembly in assemblies)
//{
// if (skipSystem && (assembly.Key.StartsWith("System") || assembly.Key.StartsWith("mscorlib"))) continue;
// if (!onlyConflicts
// || (onlyConflicts && assembly.Value.GroupBy(x => x.VersionReferenced).Count() != 1))
// {
// Console.ForegroundColor = ConsoleColor.White;
// Console.Write("Reference: ");
// Console.ForegroundColor = ConsoleColor.Gray;
// Console.WriteLine("{0}", assembly.Key);
// var referencedAssemblies = new List<Tuple<string, string>>();
// var versionsList = new List<string>();
// var asmList = new List<string>();
// foreach (var referencedAssembly in assembly.Value)
// {
// var s1 = referencedAssembly.VersionReferenced.ToString();
// var s2 = referencedAssembly.ReferencedBy.GetName().Name;
// var tuple = new Tuple<string, string>(s1, s2);
// referencedAssemblies.Add(tuple);
// }
// foreach (var referencedAssembly in referencedAssemblies)
// {
// if (!versionsList.Contains(referencedAssembly.Item1))
// {
// versionsList.Add(referencedAssembly.Item1);
// }
// if (!asmList.Contains(referencedAssembly.Item1))
// {
// asmList.Add(referencedAssembly.Item1);
// }
// }
// foreach (var referencedAssembly in referencedAssemblies)
// {
// var versionColor = ConsoleColors[versionsList.IndexOf(referencedAssembly.Item1)%ConsoleColors.Length];
// Console.ForegroundColor = versionColor;
// Console.Write(" {0}", referencedAssembly.Item1);
// Console.ForegroundColor = ConsoleColor.White;
// Console.Write(" by ");
// Console.ForegroundColor = ConsoleColor.Gray;
// Console.WriteLine("{0}", referencedAssembly.Item2);
// }
// Console.WriteLine();
// }
//}
sbResult.Append("Loading folder assemblies completed!");
assemblyAnalysis.Result = sbResult.ToString();
}
}
return assemblyAnalysis;
}
public DiagnosticsDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new AssemblyDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new OperatingSystemDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new MachineDetails(
A.Dummy <Dictionary <string, string> >(),
A.Dummy <int>(),
A.Dummy <Dictionary <string, decimal> >(),
A.Dummy <bool>(),
A.Dummy <OperatingSystemDetails>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new ProcessDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <bool>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterDescription(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <float>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterSample(
A.Dummy <PerformanceCounterDescription>(),
A.Dummy <float>());
return(result);
});
}
