static void DownloadPackages(SlnxHandler slnx, bool quite, bool autoUpdateDependencies)
{
_logger.Info("Downloading required NuGet packages...");
var frameworks = slnx.Projects.Select(p => NuGetFramework.ParseFolder(p.Framework));
var reducedFrameworks = new FrameworkReducer().ReduceUpwards(frameworks);
if (reducedFrameworks.Count() != 1)
{
throw new Exceptions.MultiFrameworkAppException($"It has not been possible to find a single common framework among the C# project specified in the SlnX file. Mixed .NET Framework and Core projects are not supported");
}
var requestedFramework = reducedFrameworks.First();
slnx.Packages = PerformPackageDownloadProcess(slnx.PackagesInfo, requestedFramework, quite, autoUpdateDependencies, "Loading packages...");
if (slnx.DebugSlnxItems.Count != 0)
{
_logger.Info("Downloading NuGet packages marked as debug...");
_logger.Debug("Need to download the package to properly gather the Libraries list. The dependencies are ignored to avoid package versions issues.");
foreach ((var packageInfo, var debugSlnx) in slnx.DebugSlnxItems)
{
_logger.Debug("Evaluating {0}.", packageInfo);
var installedDebugPackage = PerformPackageDownloadProcess(new[] { packageInfo }, requestedFramework, quite, false, $"Loading debug package {packageInfo} without dependencies...");
var installedNuGetPackages = PerformPackageDownloadProcess(debugSlnx.PackagesInfo, requestedFramework, quite, autoUpdateDependencies, $"Loading debug package {packageInfo} defined NuGet packages...");
debugSlnx.Packages = installedDebugPackage.Concat(installedNuGetPackages);
slnx.DebugPackages.Add(installedDebugPackage.First()); //Keep a reference to the debug package
}
}
}
public static async Task GetDependencies(this PackageInfo packageInfo, ICollection <PackageInfo> collection, string targetFramework)
{
using (var cacheContext = new SourceCacheContext())
{
var repositories = RepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageInfo.Id, NuGetVersion.Parse(packageInfo.Version)),
NuGetFramework.ParseFolder(targetFramework), cacheContext, NullLogger.Instance, repositories, availablePackages);
foreach (var availablePackage in availablePackages)
{
if (availablePackage.Id == packageInfo.Id)
{
continue;
}
var newInfo = GetPackageInfo(availablePackage.Id, availablePackage.Version.ToFullString());
if (newInfo != null && !collection.Contains(newInfo))
{
collection.Add(newInfo);
}
}
}
}
public static FrameworkName ParseFrameworkFolderName(string path, bool strictParsing, out string effectivePath)
{
// The path for a reference might look like this for assembly foo.dll:
// foo.dll
// sub\foo.dll
// {FrameworkName}{Version}\foo.dll
// {FrameworkName}{Version}\sub1\foo.dll
// {FrameworkName}{Version}\sub1\sub2\foo.dll
// Get the target framework string if specified
string targetFrameworkString = Path.GetDirectoryName(path).Split(Path.DirectorySeparatorChar).First();
effectivePath = path;
if (String.IsNullOrEmpty(targetFrameworkString))
{
return(null);
}
var nugetFramework = NuGetFramework.ParseFolder(targetFrameworkString);
if (strictParsing || nugetFramework.IsSpecificFramework)
{
// skip past the framework folder and the character \
effectivePath = path.Substring(targetFrameworkString.Length + 1);
return(new FrameworkName(nugetFramework.DotNetFrameworkName));
}
return(null);
}
//determines all command package dependencies and downloads their .nupkg files to Program Files
public static async Task DownloadCommandDependencyPackages()
{
string programPackagesSource = Folders.GetFolder(FolderType.ProgramFilesPackagesFolder);
List <string> newPackageFilePaths = MovePackagesToProgramFiles();
string nugetSourcePath = "https://api.nuget.org/v3/index.json";
string gallerySourcePath = "https://gallery.openbots.io/v3/command.json";
List <string> packageList = new List <string>();
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var repositories = new List <SourceRepository>();
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(programPackagesSource, "Program Files", true));
var nugetRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(nugetSourcePath, "Nuget", true));
var galleryRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(gallerySourcePath, "Gallery", true));
repositories.Add(sourceRepo);
repositories.Add(nugetRepo);
repositories.Add(galleryRepo);
try
{
foreach (string packagePath in newPackageFilePaths)
{
var matches = Regex.Matches(packagePath, @"(\w+\.\w+\.*\w*)\.(\d+\.\d+\.\d+)");
string packageId = matches[0].Groups[1].Value;
string version = matches[0].Groups[2].Value;
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var dependencyTasks = repositories.Select(repository => GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repository, repositories, availablePackages)).ToList();
await Task.WhenAll(dependencyTasks);
foreach (var package in availablePackages)
{
packageList.Add($"{package.Id}*{package.Version}");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
List <string> filteredPackageList = packageList.Distinct().ToList();
foreach (var package in filteredPackageList)
{
await DownloadPackage(package.Split('*')[0], package.Split('*')[1], programPackagesSource, $"{package.Split('*')[0]}.{package.Split('*')[1]}", repositories);
}
}
/// <summary>
/// Installs Packages on any project that uses the PackageReference method to reference packages.
/// Uses the dotnet Cli
/// </summary>
/// <param name="packageName">The name of the package to install</param>
/// <param name="messageLogger">An instance of <see cref="IMessageLogger"> to use in logging</param>
internal async Task InstallPackagesOnDotNetCoreFrameworks(string packageName, IMessageLogger messageLogger, string projectTargetFramework)
{
ILogger logger = new Logger(this.messageLogger);
CancellationToken cancellationToken = CancellationToken.None;
FindPackageByIdResource resource = await this.SourceRepository.GetResourceAsync <FindPackageByIdResource>();
NuGetFramework nuGetFramework = NuGetFramework.ParseFolder(projectTargetFramework?.Split('=')[1]);
NuGetVersion packageVersion = await GetPackageLatestNugetVersionAsync(packageName, this.SourceRepository, nuGetFramework.DotNetFrameworkName);
using (MemoryStream packageStream = new MemoryStream())
{
await resource.CopyNupkgToStreamAsync(
packageName,
packageVersion,
packageStream,
new SourceCacheContext(),
logger,
cancellationToken);
}
ProjectItem checkIfItemExists = this.project.GetItems("PackageReference").FirstOrDefault(a => a.EvaluatedInclude.Contains(packageName));
if (checkIfItemExists == null)
{
ProjectItem item = this.project.AddItem("PackageReference", packageName).FirstOrDefault();
item.Xml.AddMetadata("Version", packageVersion.OriginalVersion, true);
this.project.Save();
}
}
public NuGetClient()
{
_nuGetFramework = NuGetFramework.ParseFolder("netstandard20");
_settings = Settings.LoadDefaultSettings(root: null);
_packageSourceProvider = new PackageSourceProvider(_settings);
_sourceRepositoryProvider = new SourceRepositoryProvider(_packageSourceProvider, Repository.Provider.GetCoreV3());
}
public static string GetPackageAssemblySearchPath(
LocalPackageInfo packageInfo,
NuGetFramework framework)
{
if (packageInfo == null)
{
return(null);
}
if (framework == null)
{
throw new ArgumentNullException(nameof(framework));
}
var possibleFrameworks = packageInfo.Files
.Select(path => path.Split(new [] { '/', '\\' }))
.Where(parts => string.Equals(parts [0], "lib", StringComparison.OrdinalIgnoreCase))
.Select(parts => NuGetFramework.ParseFolder(parts [1].ToLowerInvariant()))
.Distinct();
var bestFramework = new FrameworkReducer()
.GetNearest(framework, possibleFrameworks);
return(Path.Combine(
packageInfo.ExpandedPath,
"lib",
bestFramework.GetShortFolderName()));
}
public async Task GetDeps(XElement project, List <Package> packages)
{
IEnumerable <NuGetFramework> frameworks =
project.Descendants()
.Where(x => x.Name.LocalName == "TargetFramework" || x.Name.LocalName == "TargetFrameworks")
.SingleOrDefault()
.Value.Split(';')
.Select(f => NuGetFramework.ParseFolder(f));
AuditEnvironment.Info("{0}", frameworks.First().Framework);
var nugetPackages = packages.Select(p => new PackageIdentity(p.Name, NuGetVersion.Parse(p.Version)));
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var logger = NullLogger.Instance;
using (var cacheContext = new SourceCacheContext())
{
foreach (var np in nugetPackages)
{
foreach (var sourceRepository in sourceRepositoryProvider.GetRepositories())
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
np, frameworks.First(), cacheContext, logger, CancellationToken.None);
if (dependencyInfo != null)
{
AuditEnvironment.Info("Dependency info: {0}.", dependencyInfo);
}
}
}
}
}
private static bool TryGetTargetFrameworkFromPath(string assemblyPath, out NuGetFramework framework)
{
var dirPath = Path.GetDirectoryName(assemblyPath);
var dir = Path.GetFileName(dirPath);
framework = NuGetFramework.ParseFolder(dir);
return(!NuGetFramework.UnsupportedFramework.Equals(framework));
}
/// <summary>
/// This method looks for the requestedPackage and downloads it.
/// If requested, it also installs the dependencies associated with the requestedPackage
/// </summary>
/// <param name="requestedPackage"></param>
/// <param name="autoInstallDependencis"></param>
/// <returns></returns>
static async Task PerformPackageActionAsync(NugetPackage requestedPackage, bool autoInstallDependencis, List <NugetPackage> installedPackages, Func <NugetPackage, SourcePackageDependencyInfo, ISettings, SourceCacheContext, List <NugetPackage>, Task> action)
{
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var packageId = requestedPackage.Id;
var packageVersion = requestedPackage.VersionRange.MinVersion;
var nuGetFramework = NuGetFramework.ParseFolder(requestedPackage.TargetFramework);
var settings = Settings.LoadDefaultSettings(root: requestedPackage.RootPath);
var providers = Repository.Provider.GetCoreV3();
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers);
var repositories = new List <SourceRepository>();
if (requestedPackage.Source != null)
{
repositories.Add(Repository.CreateSource(providers, new PackageSource(requestedPackage.Source.ToString())));
}
foreach (var depSource in requestedPackage.DependencySources)
{
repositories.Add(Repository.CreateSource(providers, new PackageSource(depSource.ToString())));
}
repositories.AddRange(sourceRepositoryProvider.GetRepositories());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
var dependencyWalkLevel = autoInstallDependencis? -1 : 0;
await GetPackageDependencyInfo(dependencyWalkLevel,
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, _logger, repositories, availablePackages, installedPackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
repositories.Select(s => s.PackageSource),
_logger);
IEnumerable <SourcePackageDependencyInfo> packagesToInstall = null;
if (autoInstallDependencis)
{
packagesToInstall = availablePackages;
}
else
{
packagesToInstall = availablePackages.Take(1);
}
foreach (var packageToInstall in packagesToInstall)
{
await action(requestedPackage, packageToInstall, settings, cacheContext, installedPackages);
}
}
}
protected NuGetPackageBase(string directory)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
if (!Directory.Exists(directory))
{
throw new DirectoryNotFoundException($"{directory} does not exist");
}
var packageZip = Directory.EnumerateFiles(directory, "*.nupkg").First();
XDocument document;
using (var file = File.OpenRead(packageZip))
using (var archive = new ZipArchive(file, ZipArchiveMode.Read, false))
{
var entry = archive.Entries.First(e => System.IO.Path.GetExtension(e.FullName) == ".nuspec");
using (var nuspec = entry.Open())
document = XDocument.Load(nuspec);
}
if (document == null)
{
throw new Exception($"No nuspec found in {packageZip}");
}
var ns = document.Root.Name.Namespace;
var metadata = document.Root.Element(ns + "metadata");
if (metadata == null)
{
throw new Exception($"No metadata found in nuspec document in {packageZip}");
}
Id = metadata.Element(ns + "id").Value.Trim();
Version = metadata.Element(ns + "version").Value.Trim();
Path = directory;
var libFolder = System.IO.Path.Combine(Path, "lib");
var toolsFolder = System.IO.Path.Combine(Path, "tools");
IEnumerable <string> EnumDirs(string dir)
{
if (!Directory.Exists(dir))
{
return(Enumerable.Empty <string>());
}
return(Directory.EnumerateDirectories(dir));
}
FrameworkVersions =
EnumDirs(libFolder).Concat(EnumDirs(toolsFolder))
.Select(d => NuGetFramework.ParseFolder(System.IO.Path.GetFileName(d)))
.ToList();
}
static BaseInfo ResolveFramework(string shortname)
{
var fullref = NuGetFramework.ParseFolder(shortname);
if (fullref.IsSpecificFramework)
{
return(new FrameworkInfo(shortname, fullref));
}
return(null);
}
internal string GetFolderName(string filePath)
{
var hi = NuGetFramework.ParseFolder(filePath.Split('/')[1]).GetShortFolderName();
if (hi == "unsupported")
{
return(filePath.Split('/')[0] + '/');
}
return(filePath.Split('/')[0] + '/' + hi + '/');
}
public void i_can_build_package_with_library_content()
{
var packer = NewNugetPacker();
DefaultSpecification.Files.Add(
new LibraryFiles(NuGetFramework.ParseFolder("net40"))
{
Source = Path.Combine(@"regular\output\net40".GetTestPath(), "*.*")
});
packer.Pack("test_pack".GetTestFileInfo());
}
internal StrideVersionViewModel(LauncherViewModel launcher, NugetStore store, NugetLocalPackage localPackage, string packageId, int major, int minor)
: base(launcher, store, localPackage)
{
PackageSimpleName = packageId.Replace(".GameStudio", string.Empty);
Major = major;
Minor = minor;
SetAsActiveCommand = new AnonymousCommand(ServiceProvider, () => launcher.ActiveVersion = this);
// Update status if the user changes whether to display beta versions.
launcher.PropertyChanged += (s, e) => { if (e.PropertyName == nameof(LauncherViewModel.ShowBetaVersions))
{
UpdateStatus();
}
};
if (LocalPackage != null && InstallPath != null)
{
var libDirectory = Path.Combine(InstallPath, "lib");
var frameworks = Directory.EnumerateDirectories(libDirectory);
foreach (var frameworkPath in frameworks)
{
var frameworkFolder = new DirectoryInfo(frameworkPath).Name;
if (File.Exists(Path.Combine(frameworkPath, "Stride.GameStudio.exe")) ||
File.Exists(Path.Combine(frameworkPath, "Xenko.GameStudio.exe")))
{
Frameworks.Add(frameworkFolder);
}
}
if (Frameworks.Count > 0)
{
try
{
// If preferred framework exists in our list, select it
var preferredFramework = LauncherSettings.PreferredFramework;
if (Frameworks.Contains(preferredFramework))
{
SelectedFramework = preferredFramework;
}
else
{
// Otherwise, try to find a framework of the same kind (.NET Core or .NET Framework)
var nugetFramework = NuGetFramework.ParseFolder(preferredFramework);
SelectedFramework =
Frameworks.FirstOrDefault(x => NuGetFramework.ParseFolder(preferredFramework).Framework == nugetFramework.Framework)
?? Frameworks.First(); // otherwise fallback to first choice
}
}
catch
{
SelectedFramework = Frameworks.First();
}
}
}
}
internal static NuGetFramework GetNuGetFramework(
NetPortableProfileTable table,
IFrameworkNameProvider provider,
FrameworkName framework)
{
// Use the short folder name as the common format between FrameworkName and
// NuGetFramework. With portable frameworks, there are differences in
// FrameworkName and NuGetFramework.DotNetFrameworkName.
var folderName = GetShortFrameworkName(table, framework);
return(NuGetFramework.ParseFolder(folderName, provider));
}
public async Task Install2(string name, string version, string source,
CancellationToken cancellationToken = default)
{
try
{
var logger = NullLogger.Instance;
var package = new PackageIdentity(name, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(root: _context.WorkingDirectory);
var provider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var framework = NuGetFramework.ParseFolder(Framework);
using (var cacheContext = new SourceCacheContext())
{
foreach (var sourceRepository in provider.GetRepositories())
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>(cancellationToken);
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo != null)
{
Console.WriteLine(dependencyInfo);
return;
}
}
}
var cache = new SourceCacheContext();
// var packageSource = new PackageSource(source);
var repository = Repository.Factory.GetCoreV3(source);
var resource = await repository.GetResourceAsync <FindPackageByIdResource>(cancellationToken);
var versions = await resource.GetAllVersionsAsync(
name,
cache,
logger,
cancellationToken);
foreach (var v in versions)
{
_logger.LogDebug($"Found version {v}");
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
await Task.CompletedTask;
}
public void i_can_build_package_with_package_dependencies([Values("net35", "net40", "net403", "net45", "net451", "net452", "net461", "net462")] string targetFramework)
{
var packer = NewNugetPacker();
DefaultSpecification.Dependencies = new Specification.PackageDependencyGroupCollection()
{
new PackageDependencyGroup(NuGetFramework.ParseFolder(targetFramework), new[]
{
new PackageDependency("another_package", VersionRange.Parse("1.2.0"))
})
};
packer.Pack($"test_pack.{targetFramework}".GetTestFileInfo());
}
public void PackageReader_EmptyLibFolder()
{
var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
var emptyGroup = groups.Where(g => g.TargetFramework == NuGetFramework.ParseFolder("net45")).Single();
Assert.Equal(0, emptyGroup.Items.Count());
}
}
public void i_can_add_framework_assembly()
{
var packer = NewNugetPacker();
DefaultSpecification.FrameworkAssemblies.Add(
new FrameworkAssemblyReference("System.Xml",
new[]
{
NuGetFramework.ParseFolder("net40"),
NuGetFramework.ParseFolder("net45")
}));
packer.Pack("test_pack".GetTestFileInfo());
}
public static string GetRuntimeIdUsingOutputStructure(FileSystemPath executePath)
{
var tfmKey = executePath.Parent.Parent.Name;
var runtimeIdentifier = executePath.Directory.Name;
var nuGetFramework = NuGetFramework.ParseFolder(tfmKey, DefaultFrameworkNameProvider.Instance);
if (nuGetFramework == null)
{
return(null);
}
var runtimeId = $"{nuGetFramework.DotNetFrameworkName}/{runtimeIdentifier}";
return(runtimeId);
}
public NugetPackageInstaller(FileIO io)
{
var nugetSettings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(nugetSettings), Repository.Provider.GetCoreV3());
this.io = io;
this.nugetFramework = NuGetFramework.ParseFolder("netstandard2.0");
this.repositories = sourceRepositoryProvider.GetRepositories().ToList();
this.nugetCache = new SourceCacheContext();
this.packagePathResolver = new PackagePathResolver(io.GetFullFileSystemPath("packages"));
this.globalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(nugetSettings);
this.frameworkReducer = new FrameworkReducer();
this.clientPolicy = ClientPolicyContext.GetClientPolicy(nugetSettings, NuGet.Common.NullLogger.Instance);
}
private static IEnumerable <FrameworkEnumeratorData> ExpandByRoundTrippingShortFolderName(
HashSet <FrameworkEnumeratorData> existing,
FrameworkEnumeratorData data)
{
var shortFolderName = data.Framework.NuGetFramework.GetShortFolderName();
var roundTrip = GetFrameworkEnumeratorData(NuGetFramework.ParseFolder(shortFolderName));
var added = AddFramework(existing, roundTrip);
if (added != null)
{
yield return(added);
}
}
public static async Task InstallWithDependencies(string packageId, string version, string frameworkVersion, ILogger logger)
{
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var settings = Settings.LoadDefaultSettings(root: null);
var feed = new Uri("https://api.nuget.org/v3/index.json");
var repositoryList = new List <SourceRepository>();
repositoryList.Add(Repository.Factory.GetCoreV3(feed.AbsoluteUri, FeedType.HttpV3));
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositoryList, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
logger);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, logger),
logger);
//new PackageSignatureVerifier(
// signatureVerification.GetSignatureVerificationProviders()),
//SignedPackageVerifierSettings.GetDefault());
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
InstallPackages(packagePathResolver, packageToInstall, cacheContext, packageExtractionContext,
frameworkReducer, nuGetFramework, settings, logger);
}
}
}
public async Task Dependency_OmitDevelopmentDependencies()
{
var package = await Scenario.RestoreAndBuildSinglePackageAsync();
// We verify that one package dependency is present that should be transitive,
// and that a DevelopmentDependency=true package (StyleCop.Analyzers) is NOT present.
var dependencySet = new[] {
new PackageDependencyGroup(NuGetFramework.ParseFolder("net452"), new[]
{
new PackageDependency("Microsoft.Tpl.Dataflow", new VersionRange(new NuGetVersion(4, 5, 24)))
}),
};
Assert.Equal(dependencySet, package.DependencySets);
}
public void TestDetectingNewestFramework()
{
var autoDetectedFW = NuGetUtility.TryAutoDetectThisProcessFramework();
var specifiedFW = NuGetFramework.ParseFolder(Environment.GetEnvironmentVariable("THIS_TFM"));
//XDocument csProj;
//using ( var fs = File.Open( Path.GetFullPath( Path.Combine( Environment.GetEnvironmentVariable( "GIT_DIR" ), "Source", "Tests", "Tests.NuGetUtils.Lib.Common", "Tests.NuGetUtils.Lib.Common.csproj" ) ), FileMode.Open, FileAccess.Read, FileShare.Read ) )
//{
// csProj = await XDocument.LoadAsync( fs, LoadOptions.None, default );
//}
//var csProjFW = NuGetFramework.ParseFolder( csProj.XPathSelectElement( "/Project/PropertyGroup/TargetFramework" ).Value );
Assert.AreEqual(specifiedFW, autoDetectedFW, "CSProj and process frameworks must match.");
}
private void InitNuGet()
{
_nugetSettings = Settings.LoadDefaultSettings(root: null);
_nugetSourceRepositoryProvider = new SourceRepositoryProvider(_nugetSettings, Repository.Provider.GetCoreV3());
_nuGetFramework = NuGetFramework.ParseFolder("netstandard2.0");
_packagesDirectory = _fileSystemManager.BuildFilePath(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_fileSystemManager.CreateDirectory(Path.Combine(_neonConfig.Plugins.Directory, "packages"));
_packagePathResolver = new PackagePathResolver(_packagesDirectory);
_packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, NullLogger.Instance), NullLogger.Instance);
}
public void It_does_not_generate_version_and_sku_for_non_supported(string targetframework)
{
var targetFrameworkParsed = NuGetFramework.Parse(targetframework);
var doc =
new XDocument(
new XDeclaration("1.0", "utf-8", "true"),
new XElement("configuration"));
var parsedFramework = NuGetFramework.ParseFolder(targetframework);
WriteAppConfigWithSupportedRuntime.AddSupportedRuntimeToAppconfig(doc, parsedFramework.Framework, parsedFramework.Version.ToString());
doc.Element("configuration")
.Elements("startup").Should().BeNullOrEmpty();
}
public async Task Dependency_MultipleFrameworks_AreResolved()
{
var package = await Scenario.RestoreAndBuildSinglePackageAsync(packageId : "Dependent.nuget");
var dependencySet = new [] {
new PackageDependencyGroup(NuGetFramework.ParseFolder("net40"), new[]
{
new PackageDependency("Dependency.nuget", new VersionRange(new NuGetVersion(1, 0, 0)))
}),
new PackageDependencyGroup(NuGetFramework.ParseFolder("net45"), new[]
{
new PackageDependency("Dependency.nuget", new VersionRange(new NuGetVersion(1, 0, 0)))
}),
};
Assert.Equal(dependencySet, package.DependencySets);
}
protected void UpdateFrameworks()
{
Frameworks.Clear();
if (LocalPackage != null && InstallPath != null)
{
foreach (var toplevelFolder in new[] { "tools", "lib" })
{
var libDirectory = Path.Combine(InstallPath, toplevelFolder);
var frameworks = Directory.EnumerateDirectories(libDirectory);
foreach (var frameworkPath in frameworks)
{
var frameworkFolder = new DirectoryInfo(frameworkPath).Name;
if (File.Exists(Path.Combine(frameworkPath, "Stride.GameStudio.exe")) ||
File.Exists(Path.Combine(frameworkPath, "Xenko.GameStudio.exe")))
{
Frameworks.Add(frameworkFolder);
}
}
}
if (Frameworks.Count > 0)
{
try
{
// If preferred framework exists in our list, select it
var preferredFramework = LauncherSettings.PreferredFramework;
if (Frameworks.Contains(preferredFramework))
{
SelectedFramework = preferredFramework;
}
else
{
// Otherwise, try to find a framework of the same kind (.NET Core or .NET Framework)
var nugetFramework = NuGetFramework.ParseFolder(preferredFramework);
SelectedFramework =
Frameworks.FirstOrDefault(x => NuGetFramework.ParseFolder(preferredFramework).Framework == nugetFramework.Framework)
?? Frameworks.First(); // otherwise fallback to first choice
}
}
catch
{
SelectedFramework = Frameworks.First();
}
}
}
}
