/// <summary>
/// Gets the assemblies that have been loaded into the execution context of application domain from the supplied type.
/// </summary>
/// <param name="type"></param>
/// <returns>An array of assemblies in the application domain from the supplied type.</returns>
public Assembly[] GetAssemblies(Type type)
{
List <Assembly> assemblies = new List <Assembly>();
var dependencyModel = DependencyContext.Load(type.GetTypeInfo().Assembly);
foreach (var assemblyName in dependencyModel.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier()))
{
try
{
try
{
var assembly = Assembly.Load(assemblyName);
// just load all types and skip this assembly if one or more types cannot be resolved
assembly.DefinedTypes.ToArray();
assemblies.Add(assembly);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
}
}
catch (Exception ex)
{
Debug.Write(ex.Message);
}
}
return(assemblies.OrderBy(a => a.FullName).ToArray());
}
public static string GetCurrentRuntimeId()
{
if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
{
return(RuntimeEnvironment.GetRuntimeIdentifier());
}
var arch = RuntimeEnvironment.RuntimeArchitecture.ToLowerInvariant();
if (RuntimeEnvironment.OperatingSystemVersion.StartsWith("6.1", StringComparison.Ordinal))
{
return("win7-" + arch);
}
if (RuntimeEnvironment.OperatingSystemVersion.StartsWith("6.2", StringComparison.Ordinal))
{
return("win8-" + arch);
}
if (RuntimeEnvironment.OperatingSystemVersion.StartsWith("6.3", StringComparison.Ordinal))
{
return("win81-" + arch);
}
if (RuntimeEnvironment.OperatingSystemVersion.StartsWith("10.0", StringComparison.Ordinal))
{
return("win10-" + arch);
}
throw new InvalidOperationException("Runtime not supported");
}
static GivenThatWeWantToStoreAProjectWithDependencies()
{
var rid = RuntimeEnvironment.GetRuntimeIdentifier();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_runtimeOs = "win7";
_runtimeLibOs = "win";
_testArch = rid.Substring(rid.LastIndexOf("-") + 1);
_runtimeRid = "win7-" + _testArch;
}
else
{
_runtimeOs = "unix";
_runtimeLibOs = "unix";
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
// microsoft.netcore.coredistools only has assets for osx.10.10
_runtimeRid = "osx.10.10-x64";
}
else if (rid.Contains("ubuntu"))
{
// microsoft.netcore.coredistools only has assets for ubuntu.14.04-x64
_runtimeRid = "ubuntu.14.04-x64";
}
else
{
_runtimeRid = rid;
}
}
}
public override bool Execute()
{
Rid = RuntimeEnvironment.GetRuntimeIdentifier();
OSName = GetOSShortName();
return(true);
}
static GivenThatWeWantToCacheAProjectWithDependencies()
{
var rid = RuntimeEnvironment.GetRuntimeIdentifier();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_runtimeOs = "win7";
_runtimeLibOs = "win";
_testArch = rid.Substring(rid.LastIndexOf("-") + 1);
_runtimeRid = "win7-" + _testArch;
}
else
{
_runtimeOs = "unix";
_runtimeLibOs = "unix";
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
// microsoft.netcore.dotnetapphost has assets only for osx.10.10
_runtimeRid = "osx.10.10-x64";
}
else
{
_runtimeRid = rid;
}
}
}
public static BuildTargetResult Init(BuildTargetContext c)
{
var configEnv = Environment.GetEnvironmentVariable("CONFIGURATION");
string platformEnv = Environment.GetEnvironmentVariable("TARGETPLATFORM") ?? RuntimeEnvironment.RuntimeArchitecture.ToString();
string targetRID = Environment.GetEnvironmentVariable("TARGETRID");
if (targetRID == null)
{
targetRID = RuntimeEnvironment.GetRuntimeIdentifier();
if (targetRID.StartsWith("win") && (targetRID.EndsWith("x86") || targetRID.EndsWith("x64")))
{
targetRID = $"win7-{RuntimeEnvironment.RuntimeArchitecture}";
}
}
string targetFramework = Environment.GetEnvironmentVariable("TARGETFRAMEWORK") ?? "netcoreapp1.0";
if (string.IsNullOrEmpty(configEnv))
{
configEnv = "Debug";
}
c.BuildContext["Configuration"] = configEnv;
c.BuildContext["Channel"] = Environment.GetEnvironmentVariable("CHANNEL");
c.BuildContext["Platform"] = platformEnv;
c.BuildContext["TargetRID"] = targetRID;
c.BuildContext["TargetFramework"] = targetFramework;
c.Info($"Building {c.BuildContext["Configuration"]} to: {Dirs.Output}");
c.Info("Build Environment:");
c.Info($" Operating System: {RuntimeEnvironment.OperatingSystem} {RuntimeEnvironment.OperatingSystemVersion}");
c.Info($" Platform: " + platformEnv);
return(c.Success());
}
private static IEnumerable <PlatformDependency> GetPlatformDependencies(DependencyContext pluginDependencyContext, IEnumerable <string> platformExtensions)
{
var dependencies = new List <PlatformDependency>();
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var dependencyGraph = DependencyContext.Default.RuntimeGraph.FirstOrDefault(g => g.Runtime == runtimeId);
// List of supported runtimes, includes the default runtime and the fallbacks for this dependency context
var runtimes = new List <string> {
dependencyGraph?.Runtime
}.AddRangeToList <string>(dependencyGraph?.Fallbacks);
foreach (var runtimeLibrary in pluginDependencyContext.RuntimeLibraries)
{
var assets = runtimeLibrary.NativeLibraryGroups.GetDefaultAssets();
foreach (var runtime in runtimes)
{
var runtimeSpecificGroup = runtimeLibrary.NativeLibraryGroups.FirstOrDefault(g => g.Runtime == runtime);
if (runtimeSpecificGroup != null)
{
assets = runtimeSpecificGroup.AssetPaths;
break;
}
}
foreach (var asset in assets.Where(a => platformExtensions.Contains(Path.GetExtension(a)))) // Only load assemblies and not debug files
{
dependencies.Add(new PlatformDependency
{
DependencyNameWithoutExtension = Path.GetFileNameWithoutExtension(asset),
Version = runtimeLibrary.Version,
DependencyPath = asset
});
}
}
return(dependencies);
}
/// <summary>
/// Attempts to locate a native asset with the given name in the default NuGet package cache folder.
/// </summary>
private Boolean TryLocateNativeAssetFromDeps(String name, out String depsResolvedPath)
{
depsResolvedPath = null;
var defaultContext = DependencyContext.Default;
if (defaultContext == null)
{
return(false);
}
var userHomeDirectory = UltravioletPlatformInfo.CurrentPlatform == UltravioletPlatform.Windows ?
Environment.GetEnvironmentVariable("USERPROFILE") : Environment.GetEnvironmentVariable("HOME");
var nugetPackagesRootDir = Path.Combine(userHomeDirectory, ".nuget", "packages");
var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
foreach (var runtimeLib in defaultContext.RuntimeLibraries)
{
foreach (var nativeAsset in runtimeLib.GetRuntimeNativeAssets(defaultContext, runtimeIdentifier))
{
if (Path.GetFileName(nativeAsset) == name || Path.GetFileNameWithoutExtension(nativeAsset) == name)
{
var fullPath = Path.Combine(nugetPackagesRootDir, runtimeLib.Name.ToLowerInvariant(), runtimeLib.Version, nativeAsset);
fullPath = Path.GetFullPath(fullPath);
depsResolvedPath = fullPath;
return(true);
}
}
}
return(false);
}
private void InitializeTelemetry()
{
try
{
_client = new TelemetryClient();
_client.InstrumentationKey = InstrumentationKey;
_client.Context.Session.Id = Guid.NewGuid().ToString();
_client.Context.Device.OperatingSystem = RuntimeEnvironment.OperatingSystem;
_commonProperties = new Dictionary <string, string>();
_commonProperties.Add(OSVersion, RuntimeEnvironment.OperatingSystemVersion);
_commonProperties.Add(OSPlatform, RuntimeEnvironment.OperatingSystemPlatform.ToString());
_commonProperties.Add(RuntimeId, RuntimeEnvironment.GetRuntimeIdentifier());
_commonProperties.Add(ProductVersion, Product.Version);
_commonProperties.Add(TelemetryProfile, Environment.GetEnvironmentVariable(TelemetryProfileEnvironmentVariable));
_commonMeasurements = new Dictionary <string, double>();
}
catch (Exception)
{
_client = null;
// we dont want to fail the tool if telemetry fails.
Debug.Fail("Exception during telemetry initialization");
}
}
public override bool Execute()
{
Rid = RuntimeEnvironment.GetRuntimeIdentifier();
switch (RuntimeEnvironment.OperatingSystemPlatform)
{
case Platform.Windows:
OSName = "Windows_NT";
break;
case Platform.Linux:
OSName = "Linux";
break;
case Platform.Darwin:
OSName = "OSX";
break;
default:
Log.LogError("Could not determine display name for platform.");
return(false);
}
return(true);
}
public static IEnumerable <AssemblyName> GetAssemblies()
{
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var assemblies = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId);
return(assemblies);
}
static void Main(string[] args)
{
Console.WriteLine("Installed .Net versions are:");
string clipath = Path.GetDirectoryName(new Microsoft.DotNet.Cli.Utils.Muxer().MuxerPath);
DirectoryInfo di = new DirectoryInfo(Path.Combine(clipath, "sdk"));
Console.WriteLine("Active version: " + Microsoft.DotNet.Cli.Utils.Product.Version);
Console.WriteLine();
foreach (var item in di.GetDirectories())
{
string versionfile = Path.Combine(item.FullName, ".version");
if (IsVersionFilePresent(versionfile))
{
string version = item.Name;
string hash = GetHash(versionfile);
string template = $@"Product Information:
Version: {version}
Commit SHA-1 hash: {hash}
";
Console.WriteLine(template);
}
}
Console.WriteLine($@"Runtime Environment:
OS Name: {RuntimeEnvironment.OperatingSystem}
OS Version: {RuntimeEnvironment.OperatingSystemVersion}
OS Platform: {RuntimeEnvironment.OperatingSystemPlatform}
RID: {RuntimeEnvironment.GetRuntimeIdentifier()}");
}
private void Restore(string pathToProjectFile)
{
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
_commandRunner.Execute("dotnet", $"restore {pathToProjectFile} -r {runtimeId}");
//_commandRunner.Execute("DotNet", $"restore {pathToProjectFile}");
}
private string GetCoreCLRRid()
{
string rid = null;
if (CurrentPlatform.IsWindows)
{
var arch = RuntimeEnvironment.RuntimeArchitecture;
rid = $"win7-{arch}";
}
else if (CurrentPlatform.IsOSX)
{
rid = "osx.10.10-x64";
}
else if (CurrentPlatform.IsCentOS || CurrentPlatform.IsRHEL)
{
// CentOS runtime is in the runtime.rhel.7-x64... package as are all
// versions of RHEL
rid = "rhel.7-x64";
}
else if (CurrentPlatform.IsLinux)
{
rid = RuntimeEnvironment.GetRuntimeIdentifier();
}
return(rid);
}
public static List <Assembly> GetRuntimeAssemblies()
{
var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
var assemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId);
return(assemblyNames.Select(Assembly.Load).ToList());
}
public static string GetBadgeMoniker()
{
string rid = Environment.GetEnvironmentVariable("TARGETRID") ?? RuntimeEnvironment.GetRuntimeIdentifier();
if (rid.StartsWith("linux-"))
{
return($"Linux_{Environment.GetEnvironmentVariable("TARGETPLATFORM") ?? CurrentArchitecture.Current.ToString()}");
}
switch (RuntimeEnvironment.GetRuntimeIdentifier())
{
case "ubuntu.16.04-x64":
return("Ubuntu_16_04_x64");
case "ubuntu.16.10-x64":
return("Ubuntu_16_10_x64");
case "fedora.23-x64":
return("Fedora_23_x64");
case "fedora.24-x64":
return("Fedora_24_x64");
case "opensuse.13.2-x64":
return("openSUSE_13_2_x64");
case "opensuse.42.1-x64":
return("openSUSE_42_1_x64");
}
return($"{CurrentPlatform.Current}_{Environment.GetEnvironmentVariable("TARGETPLATFORM") ?? CurrentArchitecture.Current.ToString()}");
}
public void It_does_not_fail_publishing_a_self_twice()
{
var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset(TestProjectName)
.WithSource();
var msbuildArgs = new string[] { "/p:SelfContained=true",
$"/p:TargetFramework={TargetFramework}",
$"/p:RuntimeIdentifier={runtimeIdentifier}" };
var restoreCommand = new RestoreCommand(Log, testAsset.TestRoot);
restoreCommand.Execute(msbuildArgs);
var publishCommand = new PublishCommand(Log, testAsset.TestRoot);
publishCommand
.Execute(msbuildArgs)
.Should().Pass();
publishCommand
.Execute(msbuildArgs)
.Should().Pass().And.NotHaveStdOutContaining("HelloWorld.exe' already exists");
}
protected virtual void Init()
{
// By default we include the assemblies containing the
// principles a part of the built-ins and every other
// assembly in context a part of the search scope
AddBuiltIns(typeof(TProv).GetTypeInfo().Assembly, typeof(TProd).GetTypeInfo().Assembly);
// Get a list of all assemblies used at runtime
string runtimeId = RuntimeEnvironment.GetRuntimeIdentifier();
IEnumerable <AssemblyName> assemblies = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId);
List <AssemblyName> asms = new List <AssemblyName>();
foreach (AssemblyName assembly in assemblies)
{
// Check if the assembly has already been processed
// If it has already been processed it will be skipped
if (asms.Contains(assembly))
{
continue;
}
// Add assemblies to the temporary list
// This prevents duplicate addition load
asms.Add(assembly);
// The assembly has not been added before
// Add it to the assemblies to load
AddSearchAssemblies(Assembly.Load(assembly));
}
}
public Assembly[] GetAssemblies()
{
var rid = RuntimeEnvironment.GetRuntimeIdentifier();
var ass = DependencyContext.Default.GetRuntimeAssemblyNames(rid);
return(ass.Select(xan => Assembly.Load(xan)).ToArray());
}
/// <summary>
/// This is the context from which tests will be run in the
/// linker repo. The local directory that contains the
/// linker integration packages (hard-coded here) is
/// searched for the tasks package. This assumes that only
/// one version of the package is present, and uses it to
/// unambiguously determine which pacakge to use in the tests.
/// </summary>
public static TestContext CreateDefaultContext()
{
var packageName = "ILLink.Tasks";
// test is run from corebuild/testbin/<config>/<tfm>
var corebuild = "../../../";
var testBin = Path.Combine(corebuild, "testbin");
var packageSource = Path.Combine(corebuild, "integration", "bin", "nupkgs");
var tasksPackages = Directory.GetFiles(packageSource)
.Where(p => Path.GetExtension(p) == ".nupkg")
.Select(p => Path.GetFileNameWithoutExtension(p))
.Where(p => p.StartsWith(packageName));
var nPackages = tasksPackages.Count();
if (nPackages > 1)
{
throw new Exception($"duplicate {packageName} packages in {packageSource}");
}
else if (nPackages == 0)
{
throw new Exception($"{packageName} package not found in {packageSource}");
}
var tasksPackage = tasksPackages.Single();
var version = tasksPackage.Remove(0, packageName.Length + 1);
var dotnetDir = Path.Combine(corebuild, "Tools", "dotnetcli");
var dotnetToolNames = Directory.GetFiles(dotnetDir)
.Select(p => Path.GetFileName(p))
.Where(p => p.Contains("dotnet"));
var nTools = dotnetToolNames.Count();
if (nTools > 1)
{
throw new Exception($"multiple dotnet tools in {dotnetDir}");
}
else if (nTools == 0)
{
throw new Exception($"no dotnet tool found in {dotnetDir}");
}
var dotnetToolName = dotnetToolNames.Single();
var dotnetToolPath = Path.Combine(dotnetDir, dotnetToolName);
var context = new TestContext();
context.PackageSource = packageSource;
context.TasksPackageName = packageName;
context.TasksPackageVersion = version;
context.DotnetToolPath = dotnetToolPath;
// This sets the RID to the RID of the currently-executing system.
context.RuntimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
// workaround: the osx.10.13-x64 RID doesn't exist yet.
// see https://github.com/dotnet/core-setup/issues/3301
if (context.RuntimeIdentifier == "osx.10.13-x64")
{
context.RuntimeIdentifier = "osx.10.12-x64";
}
// We want to build and link integration projects in the
// release configuration.
context.Configuration = "Release";
context.TestBin = testBin;
return(context);
}
public void ItPublishesARunnableSelfContainedApp()
{
var testAppName = "MSBuildTestApp";
var testInstance = TestAssetsManager
.CreateTestInstance(testAppName);
var testProjectDirectory = testInstance.TestRoot;
var rid = RuntimeEnvironment.GetRuntimeIdentifier();
new Publish3Command()
.WithFramework("netcoreapp1.0")
.WithRuntime(rid)
.WithWorkingDirectory(testProjectDirectory)
.Execute()
.Should()
.Pass();
var configuration = Environment.GetEnvironmentVariable("CONFIGURATION") ?? "Debug";
var outputProgram = Path.Combine(testProjectDirectory, "bin", configuration, "netcoreapp1.0", rid, "publish", $"{testAppName}{Constants.ExeSuffix}");
new TestCommand(outputProgram)
.ExecuteWithCapturedOutput()
.Should()
.Pass()
.And
.HaveStdOutContaining("Hello World");
}
private void PublishAppWithLibraryAndRid(bool selfContained, out DirectoryInfo publishDirectory, out string runtimeIdentifier)
{
runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", $"PublishAppWithLibraryAndRid{selfContained}")
.WithSource();
var projectPath = Path.Combine(testAsset.TestRoot, "App");
var msbuildArgs = new[]
{
$"/p:RuntimeIdentifier={runtimeIdentifier}",
$"/p:TestRuntimeIdentifier={runtimeIdentifier}",
$"/p:SelfContained={selfContained}"
};
var restoreCommand = new RestoreCommand(Log, projectPath, "App.csproj");
restoreCommand
.Execute(msbuildArgs)
.Should()
.Pass();
var publishCommand = new PublishCommand(Log, projectPath);
publishCommand
.Execute(msbuildArgs)
.Should().Pass();
publishDirectory = publishCommand.GetOutputDirectory("netcoreapp1.1", runtimeIdentifier: runtimeIdentifier);
}
public void It_builds_a_framework_dependent_RID_specific_runnable_output()
{
var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
var testAsset = _testAssetsManager
.CopyTestAsset("AppWithLibraryAndRid", "BuildFrameworkDependentRIDSpecific")
.WithSource();
if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX))
{
// .NET Core 2.1.0 packages don't support latest versions of OS X, so roll forward to the
// latest patch which does
testAsset = testAsset.WithProjectChanges(project =>
{
var ns = project.Root.Name.Namespace;
var propertyGroup = project.Root.Elements(ns + "PropertyGroup").First();
propertyGroup.Add(new XElement("TargetLatestRuntimePatch", true));
});
}
var projectPath = Path.Combine(testAsset.TestRoot, "App");
var restoreCommand = new RestoreCommand(Log, projectPath, "App.csproj");
restoreCommand
.Execute($"/p:TestRuntimeIdentifier={runtimeIdentifier}")
.Should()
.Pass();
var buildCommand = new BuildCommand(Log, projectPath);
buildCommand
.Execute($"/p:RuntimeIdentifier={runtimeIdentifier}", $"/p:TestRuntimeIdentifier={runtimeIdentifier}", "/p:SelfContained=false")
.Should().Pass();
var outputDirectory = buildCommand.GetOutputDirectory("netcoreapp2.1", runtimeIdentifier: runtimeIdentifier);
outputDirectory.Should().NotHaveSubDirectories();
outputDirectory.Should().OnlyHaveFiles(new[] {
$"App{Constants.ExeSuffix}",
"App.dll",
"App.pdb",
"App.deps.json",
"App.runtimeconfig.json",
"App.runtimeconfig.dev.json",
"LibraryWithoutRid.dll",
"LibraryWithoutRid.pdb",
"LibraryWithRid.dll",
"LibraryWithRid.pdb",
"LibraryWithRids.dll",
"LibraryWithRids.pdb",
});
Command.Create(TestContext.Current.ToolsetUnderTest.DotNetHostPath, new[] { Path.Combine(outputDirectory.FullName, "App.dll") })
.CaptureStdOut()
.Execute()
.Should().Pass()
.And.HaveStdOutContaining($"3.13.0 '{runtimeIdentifier}' 3.13.0 '{runtimeIdentifier}' Hello World");
}
/// <summary>
/// Reads the version file and adds runtime specific information
/// </summary>
public static string ReadAndInterpretVersionFile()
{
var content = File.ReadAllText(DotnetFiles.VersionFile);
content += Environment.NewLine;
content += RuntimeEnvironment.GetRuntimeIdentifier();
return(content);
}
private static string GetOptimizationRootPath(string version)
{
var rid = RuntimeEnvironment.GetRuntimeIdentifier();
return(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
? $@"Microsoft\dotnet\optimizationdata\{version}\{rid}"
: $@".dotnet/optimizationdata/{version}/{rid}");
}
public override bool Execute()
{
Rid = RuntimeEnvironment.GetRuntimeIdentifier();
Architecture = RuntimeEnvironment.RuntimeArchitecture;
OSName = Monikers.GetOSShortName();
return(true);
}
public override bool Execute()
{
Rid = RuntimeEnvironment.GetRuntimeIdentifier();
OSName = GetOSShortName();
OSPlatform = RuntimeEnvironment.OperatingSystemPlatform.ToString().ToLower();
return(true);
}
public override bool Execute()
{
Rid = string.IsNullOrEmpty(OverrideRid) ? RuntimeEnvironment.GetRuntimeIdentifier() : OverrideRid;
Architecture = RuntimeEnvironment.RuntimeArchitecture;
OSName = Monikers.GetOSShortName();
return(true);
}
void DisplayRuntimeEnvironment()
{
ColorConsole.WriteLine(ColorStyle.SectionHeader, "Runtime Environment");
ColorConsole.WriteLabelLine(" OS Platform: ", RuntimeEnvironment.OperatingSystemPlatform);
ColorConsole.WriteLabelLine(" OS Version: ", RuntimeEnvironment.OperatingSystemVersion);
ColorConsole.WriteLabelLine(" Runtime: ", RuntimeEnvironment.GetRuntimeIdentifier());
ColorConsole.WriteLine();
}
public DefaultAssemblyProvider()
{
var entryAssembly = Assembly.GetEntryAssembly();
var dependencyModel = DependencyContext.Load(entryAssembly);
var assemblyNames = dependencyModel.GetRuntimeAssemblyNames(RuntimeEnvironment.GetRuntimeIdentifier());
AvailableAssemblies = assemblyNames.Select(asm => new AssemblyInfo(asm.Name, string.Empty));
}