Discover plugins installed using Net tools

src/NuGet.Core/NuGet.Protocol/NuGet.Protocol.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
- <TargetFrameworks>$(TargetFrameworksLibraryForSigning)</TargetFrameworks>
+ <TargetFrameworks>$(TargetFrameworksLibraryForSigning);$(NETCoreTargetFramework)</TargetFrameworks>
  <TargetFramework />
  <NoWarn>$(NoWarn);CS1591;CS1573;CS0012;RS0041</NoWarn>
  <PackageTags>nuget protocol</PackageTags>

src/NuGet.Core/NuGet.Protocol/Plugins/PluginDiscoverer.cs

@@ -3,7 +3,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using NuGet.Common;
@@ -21,14 +24,21 @@ public sealed class PluginDiscoverer : IPluginDiscoverer
  private IEnumerable<PluginDiscoveryResult> _results;
  private readonly SemaphoreSlim _semaphore;
  private readonly EmbeddedSignatureVerifier _verifier;
+ private readonly IEnvironmentVariableReader _environmentVariableReader;
+
+ public PluginDiscoverer(string rawPluginPaths, EmbeddedSignatureVerifier verifier)
+ : this(rawPluginPaths, verifier, EnvironmentVariableWrapper.Instance)
+ {
+ }
 
  /// <summary>
  /// Instantiates a new <see cref="PluginDiscoverer" /> class.
  /// </summary>
  /// <param name="rawPluginPaths">The raw semicolon-delimited list of supposed plugin file paths.</param>
  /// <param name="verifier">An embedded signature verifier.</param>
+ /// <param name="environmentVariableReader"> A reader for environmental varibales. </param>
  /// <exception cref="ArgumentNullException">Thrown if <paramref name="verifier" /> is <see langword="null" />.</exception>
- public PluginDiscoverer(string rawPluginPaths, EmbeddedSignatureVerifier verifier)
+ internal PluginDiscoverer(string rawPluginPaths, EmbeddedSignatureVerifier verifier, IEnvironmentVariableReader environmentVariableReader)
  {
  if (verifier == null)
  {
@@ -38,6 +48,7 @@ public PluginDiscoverer(string rawPluginPaths, EmbeddedSignatureVerifier verifie
  _rawPluginPaths = rawPluginPaths;
  _verifier = verifier;
  _semaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
+ _environmentVariableReader = environmentVariableReader;
  }
 
  /// <summary>
@@ -85,6 +96,13 @@ public async Task<IEnumerable<PluginDiscoveryResult>> DiscoverAsync(Cancellation
  }
 
  _pluginFiles = GetPluginFiles(cancellationToken);
+
+ if (string.IsNullOrEmpty(_rawPluginPaths))
+ {
+ // Nuget plugin configuration environmental variables were not used to discover the configuration files
+ _pluginFiles.AddRange(GetNetToolsPluginFiles());
+ }
+
  var results = new List<PluginDiscoveryResult>();
 
  for (var i = 0; i < _pluginFiles.Count; ++i)
@@ -140,6 +158,118 @@ private List<PluginFile> GetPluginFiles(CancellationToken cancellationToken)
  return files;
  }
 
+ /// <summary>
+ /// Gets auth plugins installed using dotnet tools. This is done by iterating through each file in directories found int eh
+ /// `PATH` environment variable.
+ /// The files are also expected to have a name that starts with `nuget-plugin-`
+ /// </summary>
+ /// <returns></returns>
+ private List<PluginFile> GetNetToolsPluginFiles()
+ {
+ var pluginFiles = new List<PluginFile>();
+ string[] paths = Array.Empty<string>();
+
+ // The path to the plugins installed using dotnet tools, should be specified in the NUGET_PLUGIN_PATHS environment variable.
+ paths = _environmentVariableReader.GetEnvironmentVariable(EnvironmentVariableConstants.PluginPaths)?.Split(Path.PathSeparator) ?? Array.Empty<string>();
+
+ if (paths.Length == 0)
+ {
+ // If NUGET_PLUGIN_PATHS is not specified, read all the paths in PATH
+ paths = _environmentVariableReader.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator) ?? Array.Empty<string>();
+ }
+
+ foreach (var path in paths)
+ {
+ if (Directory.Exists(path))
+ {
+ var directoryInfo = new DirectoryInfo(path);
+ var files = directoryInfo.GetFiles("nuget-plugin-*");
+
+ foreach (var file in files)
+ {
+ if (IsValidPluginFile(file))
+ {
+ var state = new Lazy<PluginFileState>(() => _verifier.IsValid(file.FullName) ? PluginFileState.Valid : PluginFileState.InvalidEmbeddedSignature);
+ PluginFile pluginFile = new PluginFile(file.FullName, state, isDotnetToolsPlugin: true);
+ pluginFiles.Add(pluginFile);
+ }
+ }
+ }
+ }
+
+ return pluginFiles;
+ }
+
+ /// <summary>
+ /// Checks whether a file is a valid plugin file for windows/Unix.
+ /// Windows: It should be either .bat or .exe
+ /// Unix: It should be executable
+ /// </summary>
+ /// <param name="fileInfo"></param>
+ /// <returns></returns>
+ private static bool IsValidPluginFile(FileInfo fileInfo)
+ {
+ if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+ {
+ return fileInfo.Extension.Equals(".exe", StringComparison.OrdinalIgnoreCase) ||
+ fileInfo.Extension.Equals(".bat", StringComparison.OrdinalIgnoreCase);
+ }
+ else
+ {
+#if NET8_0_OR_GREATER
+ var fileMode = File.GetUnixFileMode(fileInfo.FullName);
+
+ return fileInfo.Exists &&
+ ((fileMode & UnixFileMode.UserExecute) != 0 ||
+ (fileMode & UnixFileMode.GroupExecute) != 0 ||
+ (fileMode & UnixFileMode.OtherExecute) != 0);
+#else
+ return fileInfo.Exists && (fileInfo.Attributes & FileAttributes.ReparsePoint) == 0 && IsExecutable(fileInfo);
+#endif
+ }
+ }
+
+#if !NET8_0_OR_GREATER
+ /// <summary>
+ /// Checks whether a file is executable or not in Unix.
+ /// This is done by running bash code: `if [ -x {fileInfo.FullName} ]; then echo yes; else echo no; fi`
+ /// </summary>
+ /// <param name="fileInfo"></param>
+ /// <returns></returns>
+ private static bool IsExecutable(FileInfo fileInfo)
+ {
+#pragma warning disable CA1031 // Do not catch general exception types
+ try
+ {
+ string output;
+ using (var process = new Process())
+ {
+ // Use a shell command to check if the file is executable
+ process.StartInfo.FileName = "/bin/bash";
+ process.StartInfo.Arguments = $"if [ -x {fileInfo.FullName} ]; then echo yes; else echo no; fi";
+ process.StartInfo.UseShellExecute = false;
+ process.StartInfo.RedirectStandardOutput = true;
+
+ process.Start();
+ if (!process.WaitForExit(1000) || process.ExitCode != 0)
+ {
+ return false;
+ }
+
+ output = process.StandardOutput.ReadToEnd().Trim();
+ }
+
+ // Check if the output is "yes"
+ return output.Equals("yes", StringComparison.OrdinalIgnoreCase);
+ }
+ catch
+ {
+ return false;
+ }
+#pragma warning restore CA1031 // Do not catch general exception types
+ }
+#endif
+
  private IEnumerable<string> GetPluginFilePaths()
  {
  if (string.IsNullOrEmpty(_rawPluginPaths))

src/NuGet.Core/NuGet.Protocol/Plugins/PluginFile.cs

@@ -20,6 +20,22 @@ public sealed class PluginFile
  /// </summary>
  public Lazy<PluginFileState> State { get; }
 
+ /// <summary>
+ /// Is the plugin file, a dotnet tools plugin file?
+ /// </summary>
+ public bool IsDotnetToolsPlugin { get; }
+
+ /// <summary>
+ /// Instantiates a new <see cref="PluginFile" /> class.
+ /// </summary>
+ /// <param name="filePath">The plugin's file path.</param>
+ /// <param name="state">A lazy that evaluates the plugin file state.</param>
+ /// <param name="isDotnetToolsPlugin">Is the plugin file, a dotnet tools plugin file?</param>
+ public PluginFile(string filePath, Lazy<PluginFileState> state, bool isDotnetToolsPlugin) : this(filePath, state)
+ {
+ IsDotnetToolsPlugin = isDotnetToolsPlugin;
+ }
+
  /// <summary>
  /// Instantiates a new <see cref="PluginFile" /> class.
  /// </summary>

src/NuGet.Core/NuGet.Protocol/Plugins/PluginManager.cs

@@ -317,11 +317,6 @@ private void Initialize(IEnvironmentVariableReader reader,
 #else
  _rawPluginPaths = reader.GetEnvironmentVariable(EnvironmentVariableConstants.CorePluginPaths);
 #endif
- if (string.IsNullOrEmpty(_rawPluginPaths))
- {
- _rawPluginPaths = reader.GetEnvironmentVariable(EnvironmentVariableConstants.PluginPaths);
- }
-
  _connectionOptions = ConnectionOptions.CreateDefault(reader);
 
  var idleTimeoutInSeconds = EnvironmentVariableReader.GetEnvironmentVariable(EnvironmentVariableConstants.IdleTimeout);

src/NuGet.Core/NuGet.Protocol/PublicAPI/net472/PublicAPI.Unshipped.txt

@@ -1 +1,3 @@
 #nullable enable
+NuGet.Protocol.Plugins.PluginFile.IsDotnetToolsPlugin.get -> bool
+~NuGet.Protocol.Plugins.PluginFile.PluginFile(string filePath, System.Lazy<NuGet.Protocol.Plugins.PluginFileState> state, bool isDotnetToolsPlugin) -> void