Пример #1
0
 string GetAliasToPackId(WorkloadResolver.PackInfo packInfo)
 => GetAliasToPackId(packInfo.Path, packInfo.Id, packInfo.Version);
        public async Task <bool> InstallWorkloadPack(string sdkRoot, Manifest.DotNetSdkPack sdkPack, CancellationToken cancelToken)
        {
            WorkloadResolver.PackInfo packInfo;

            if (sdkPack.SkipManifestCheck && NuGetVersion.TryParse(sdkPack.Version, out var packVersion))
            {
                var kind = sdkPack?.PackKind?.ToLowerInvariant() switch
                {
                    "sdk" => WorkloadPackKind.Sdk,
                    "framework" => WorkloadPackKind.Framework,
                    "library" => WorkloadPackKind.Library,
                    "template" => WorkloadPackKind.Template,
                    "tool" => WorkloadPackKind.Tool,
                    _ => WorkloadPackKind.Sdk
                };

                var path = kind == WorkloadPackKind.Template ?
                           Path.Combine(Path.GetTempPath(), $"{sdkPack.Id}.{sdkPack.Version}.nupkg")
                                        : Path.Combine(sdkRoot, "sdk", $"{sdkPack.Id}", sdkPack.Version);

                packInfo = new WorkloadResolver.PackInfo(sdkPack.Id, sdkPack.Version, kind, path);
            }
            else
            {
                packInfo = workloadResolver.TryGetPackInfo(sdkPack.Id);
            }

            if (packInfo != null && NuGetVersion.TryParse(packInfo.Version, out var version))
            {
                if (packInfo.Kind == WorkloadPackKind.Template)
                {
                    var r = await AcquireNuGet(packInfo.Id, version, packInfo.Path, false, cancelToken, false);

                    // Short circuit the installation into the template-packs dir since this one might not
                    // be a part of any workload manifest, so we need to install with dotnet new -i
                    if (sdkPack.SkipManifestCheck)
                    {
                        var dotnetExe = Path.Combine(sdkRoot, DotNetSdk.DotNetExeName);

                        var p  = new ShellProcessRunner(new ShellProcessRunnerOptions(dotnetExe, $"new -i \"{packInfo.Path}\""));
                        var pr = p.WaitForExit();

                        if (pr.GetOutput().Contains("permission denied", StringComparison.InvariantCultureIgnoreCase))
                        {
                            throw new ApplicationException($"Your templates cache folder has some invalid permissions.  Please try to delete the folder and try again: "
                                                           + Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".templateengine", "dotnetcli"));
                        }

                        return(pr?.ExitCode == 0);
                    }

                    return(r);
                }

                var actualPackId = GetAliasToPackId(packInfo);

                if (!string.IsNullOrEmpty(actualPackId))
                {
                    var packsRoot = Path.Combine(SdkRoot, "packs");

                    return(await AcquireNuGet(actualPackId, version, packsRoot, true, cancelToken, true));
                }
            }

            return(false);
        }
 public void InstallWorkloadPack(WorkloadResolver.PackInfo packInfo, SdkFeatureBand sdkFeatureBand, DirectoryPath?offlineCache = null) => throw new NotImplementedException();
 public void RollBackWorkloadPackInstall(WorkloadResolver.PackInfo packInfo, SdkFeatureBand sdkFeatureBand) => throw new NotImplementedException();
 public void DownloadToOfflineCache(WorkloadResolver.PackInfo packInfo, DirectoryPath offlineCache, bool includePreviews) => throw new NotImplementedException();