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