/// <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); }); }