private List <PackageIdentity> GetPackages()
{
var packages = new List <PackageIdentity>();
// Include all package references that aren't ourselves.
foreach (var packageReference in PackageReferences)
{
var include = packageReference.GetMetadata("PackageName");
if (ExclusionPackageReferenceSet.Contains(include))
{
continue;
}
if (!VersionRange.TryParse(packageReference.GetMetadata("Version"), out var nuGetVersion))
{
this.Log().Error($"Package {include} does not have a valid Version.");
continue;
}
var libraryRange = new LibraryRange(include, nuGetVersion, LibraryDependencyTarget.Package);
var packageIdentity = NuGetPackageHelper.GetBestMatch(libraryRange).GetAwaiter().GetResult();
packages.Add(packageIdentity);
}
return(packages);
}
/// <inheritdoc />
public async override Task Extract()
{
var packageUnzipPath = await NuGetPackageHelper.InstallPackages(_packageNames, Platform).ConfigureAwait(false);
Log.Debug($"Package unzip path is {packageUnzipPath}");
var xamarinForms =
Directory.GetFiles(
packageUnzipPath,
"Xamarin.Essentials.dll",
SearchOption.AllDirectories);
var latestVersion = xamarinForms.First(x => x.Contains("netstandard1.0", StringComparison.InvariantCulture));
Assemblies.Add(latestVersion);
if (PlatformHelper.IsRunningOnMono())
{
CecilSearchDirectories.Add(
@"/Library/Frameworks/Mono.framework/Versions/Current/lib/mono/xbuild-frameworks/.NETPortable/v4.5/Profile/Profile111");
}
else
{
CecilSearchDirectories.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.5\Profile\Profile111");
}
}
/// <inheritdoc />
public async override Task Extract()
{
var packageUnzipPath = await NuGetPackageHelper.InstallPackages(_packageNames, Platform).ConfigureAwait(false);
Log.Debug($"Package unzip path is {packageUnzipPath}");
var xamarinForms =
Directory.GetFiles(
packageUnzipPath,
"Xamarin.Forms.Core.dll",
SearchOption.AllDirectories);
var latestVersion = xamarinForms.Last();
Assemblies.Add(latestVersion);
if (PlatformHelper.IsRunningOnMono())
{
CecilSearchDirectories.Add(
@"/Library/Frameworks/Mono.framework/Versions/Current/lib/mono/xbuild-frameworks/.NETPortable/v4.5/Profile/Profile111");
CecilSearchDirectories.Add(@"/Library/Frameworks/Mono.framework/External/xbuild-frameworks/MonoAndroid/v1.0/Facades");
}
else
{
CecilSearchDirectories.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.2\Facades");
}
}
/// <inheritdoc />
/// <exception cref="NotSupportedException">Building events for WPF on Mac is not implemented.</exception>
public override async Task Extract(string referenceAssembliesLocation)
{
var results = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { ReferenceNuGet }, new[] { ReferenceFramework }, packageOutputDirectory : _filePath).ConfigureAwait(false);
Input.SupportGroup = results.SupportGroup;
SetFiles(results);
}
public async Task MultipleDirectoryCase()
{
// NetCore contains multiple directories that match.
var package = new[] { new PackageIdentity("Microsoft.NETCore.App", new NuGetVersion("2.0.0")) };
var frameworks = new[] { FrameworkConstants.CommonFrameworks.NetCoreApp20 };
var result = (await NuGetPackageHelper
.DownloadPackageFilesAndFolder(package, frameworks, packageOutputDirectory: _packageDirectory)
.ConfigureAwait(false));
}
private async Task PopulatePackages()
{
var packageNames = NugetPackages[Name];
foreach (var packageName in packageNames)
{
var searchCriteria = new PackageSearchCriteria
{
IntegrationName = Name,
NugetPackageSearchName = packageName,
MinVersion = "0.0.1",
MaxVersionExclusive = "255.255.255"
};
var packages = await NuGetPackageHelper.GetPackageMetadatas(searchCriteria);
var potentiallySupportedPackages = packages
.Where(p => p.Identity.HasVersion)
.OrderByDescending(p => p.Identity.Version)
.ToList();
// TODO: Download and check referenced assemblies for assembly versions
//foreach (var potentiallySupportedPackage in potentiallySupportedPackages)
//{
// potentiallySupportedPackage.
//}
var latestPackage = potentiallySupportedPackages.First();
var latestVersion = new Version(latestPackage.Identity.Version.ToNormalizedString());
var latestSupportedPackage = potentiallySupportedPackages
.FirstOrDefault(x => x.Identity.Version.Version <= MaximumAssemblyVersion);
if (latestSupportedPackage is null)
{
Logger.Warn($"No version of {packageName} below maximum package version {MaximumAssemblyVersion}." +
$"Using latest instead");
}
var latestSupportedVersion = latestSupportedPackage is null
? latestVersion
: new Version(latestSupportedPackage.Identity.Version.ToNormalizedString());
Packages.Add(new IntegrationPackage
{
NugetName = latestPackage.Identity.Id,
LatestNuget = latestVersion,
LatestSupportedNuget = latestSupportedVersion,
});
}
}
/// <inheritdoc />
public override async Task Extract()
{
var packageUnzipPath = await NuGetPackageHelper.InstallPackages(_packageNames, Platform, FrameworkConstants.CommonFrameworks.Tizen4).ConfigureAwait(false);
Log.Debug($"Package unzip path is {packageUnzipPath}");
Assemblies.AddRange(Directory.GetFiles(packageUnzipPath, "ElmSharp*.dll", SearchOption.AllDirectories));
Assemblies.AddRange(Directory.GetFiles(packageUnzipPath, "Tizen*.dll", SearchOption.AllDirectories));
foreach (var directory in Directory.GetDirectories(packageUnzipPath, "*.*", SearchOption.AllDirectories))
{
CecilSearchDirectories.Add(directory);
}
}
public async Task CanGetNetCoreApp20()
{
var package = new[] { new PackageIdentity("Microsoft.NETCore.App", new NuGetVersion("2.0.0")) };
var frameworks = new[] { FrameworkConstants.CommonFrameworks.NetCoreApp20 };
var result = await NuGetPackageHelper
.DownloadPackageFilesAndFolder(package, frameworks, packageOutputDirectory : TestUtilities.GetPackageDirectory())
.ConfigureAwait(false);
var includeFiles = result.IncludeGroup.GetAllFileNames().ToList();
includeFiles.ShouldNotBeEmpty();
includeFiles.Where(x => x.EndsWith(".dll")).ShouldNotBeEmpty();
}
private static string GetWindowsInstallationDirectory(bool includePreRelease)
{
return(_windowsInstallationDirectory.GetOrAdd(
includePreRelease,
incPreRelease =>
{
return Task.Run(
async() =>
{
var results = await NuGetPackageHelper.DownloadPackageFilesAndFolder(
new[] { VSWherePackageIdentity },
new[] { new NuGetFramework("Any") },
packageFolders: new[] { PackagingConstants.Folders.Tools },
getDependencies: false).ConfigureAwait(false);
var fileName = results.IncludeGroup.GetAllFileNames().FirstOrDefault(x => x.EndsWith("vswhere.exe", StringComparison.InvariantCultureIgnoreCase));
if (fileName == null)
{
throw new ReferenceLocationNotFoundException("Cannot find visual studio installation, due to vswhere not being installed correctly.");
}
var parameters = new StringBuilder("-latest -nologo -property installationPath -format value");
if (incPreRelease)
{
parameters.Append(" -prerelease");
}
using (var process = new Process())
{
process.StartInfo.FileName = fileName;
process.StartInfo.Arguments = parameters.ToString();
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.Start();
// To avoid deadlocks, always read the output stream first and then wait.
var output = process.StandardOutput.ReadToEnd().Replace(Environment.NewLine, string.Empty);
process.WaitForExit();
return output;
}
}).ConfigureAwait(false).GetAwaiter().GetResult();
}));
}
public static async Task CheckResultsAgainstTemplate(LibraryRange[] package, IReadOnlyList <NuGetFramework> frameworks, [CallerFilePath] string filePath = null, [CallerMemberName] string memberName = null)
{
var sourceRepository = new SourceRepository(new PackageSource(NuGetPackageHelper.DefaultNuGetSource), NuGetPackageHelper.Providers);
var findResource = await sourceRepository.GetResourceAsync <FindPackageByIdResource>().ConfigureAwait(false);
var bestPackageIdentity = await NuGetPackageHelper.GetBestMatch(package[0], findResource, CancellationToken.None).ConfigureAwait(false);
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false);
}
CheckPackageIdentityContents(memoryStream, bestPackageIdentity, frameworks[0], filePath);
}
}
/// <inheritdoc />
public override async Task Extract()
{
var packageUnzipPath = await NuGetPackageHelper.InstallPackages(_packageNames, Platform).ConfigureAwait(false);
Log.Debug($"Package unzip path is {packageUnzipPath}");
var xamarinForms =
Directory.GetFiles(
packageUnzipPath,
"Xamarin.Essentials.dll",
SearchOption.AllDirectories);
var latestVersion = xamarinForms.First(x => x.Contains("netstandard2.0", StringComparison.InvariantCulture));
Assemblies.Add(latestVersion);
foreach (var directory in Directory.GetDirectories(packageUnzipPath, "*.*", SearchOption.AllDirectories))
{
CecilSearchDirectories.Add(directory);
}
}
public async Task IntegrationTestAssemblyTest()
{
using (var memoryStream = new MemoryStream())
{
var input = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { new PackageIdentity("NETStandard.Library", new NuGetVersion("2.0.0")) }).ConfigureAwait(false);
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true))
{
await ObservablesForEventGenerator.ExtractEventsFromAssemblies(streamWriter, input, FrameworkConstants.CommonFrameworks.NetStandard20).ConfigureAwait(false);
}
memoryStream.Flush();
memoryStream.Position = 0;
using (var sr = new StreamReader(memoryStream))
{
var contents = sr.ReadToEnd();
contents.ShouldNotBeEmpty();
}
}
}
private static async Task GetAndCheckTizenPackage()
{
var package = new[] { new PackageIdentity("Tizen.NET.API4", new NuGetVersion("4.0.1.14152")) };
var frameworks = new[] { FrameworkConstants.CommonFrameworks.NetStandard20 };
var testPackageLocation = TestUtilities.GetPackageDirectory();
var result = await NuGetPackageHelper
.DownloadPackageFilesAndFolder(package, frameworks, packageOutputDirectory : testPackageLocation)
.ConfigureAwait(false);
var includeFiles = result.IncludeGroup.GetAllFileNames().ToList();
var actualFiles = includeFiles.Where(x => x.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase)).ToList();
includeFiles.ShouldNotBeEmpty();
actualFiles.ShouldNotBeEmpty();
Assert.True(actualFiles.All(File.Exists));
var actualFileNames = actualFiles.Select(Path.GetFileName).ToList();
ExpectedTizenFiles.ShouldHaveSameContents(actualFileNames);
}
/// <summary>
/// Extracts the data using the specified target framework.
/// </summary>
/// <param name="targetFrameworks">The target framework to extract in order of priority.</param>
/// <param name="packages">The packages to extract the information from.</param>
/// <param name="packageOutputDirectory">Directory for the packages, if null a random path in the temp folder will be used.</param>
/// <returns>A task to monitor the progress.</returns>
public async Task Extract(IReadOnlyCollection <NuGetFramework> targetFrameworks, IReadOnlyCollection <LibraryRange> packages, string?packageOutputDirectory)
{
Input = await NuGetPackageHelper.DownloadPackageFilesAndFolder(packages, targetFrameworks, packageOutputDirectory : packageOutputDirectory).ConfigureAwait(false);
}
