public void ExtractOptions(ICommand command, IEnumerator <string> argsEnumerator)
{
List <string> arguments = new List <string>();
IDictionary <OptionAttribute, PropertyInfo> properties = _commandManager.GetCommandOptions(command);
while (true)
{
string option = GetNextCommandLineItem(argsEnumerator);
if (option == null)
{
break;
}
if (!(option.StartsWith("/", StringComparison.OrdinalIgnoreCase) && _supportSlashAsSwitch) &&
!option.StartsWith("-", StringComparison.OrdinalIgnoreCase))
{
arguments.Add(option);
continue;
}
string optionText = option.Substring(1);
string value = null;
if (optionText.EndsWith("-", StringComparison.OrdinalIgnoreCase))
{
optionText = optionText.TrimEnd('-');
value = "false";
}
var result = GetPartialOptionMatch(properties, prop => prop.Value.Name, prop => prop.Key.AltName, option, optionText);
PropertyInfo propInfo = result.Value;
if (propInfo.PropertyType == typeof(bool))
{
value = value ?? "true";
}
else
{
value = GetNextCommandLineItem(argsEnumerator);
}
if (value == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("MissingOptionValueError"), option);
}
AssignValue(command, propInfo, option, value);
}
CommandLineHelper.AddRange(command.Arguments, arguments);
}
public ICredentials GetCredentials(Uri uri, IWebProxy proxy, CoreV2.NuGet.CredentialType credentialType, bool retrying)
{
// If we are retrying, the stored credentials must be invalid.
if (!retrying && (credentialType == CoreV2.NuGet.CredentialType.RequestCredentials) && TryGetCredentials(uri, out var credentials, out var username))
{
_logger.LogMinimal(
string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString(nameof(NuGetResources.SettingsCredentials_UsingSavedCredentials)),
username));
return(credentials);
}
return(null);
}
internal static string CombinePathWithVerboseError(params string[] paths)
{
try
{
return(Path.Combine(paths));
}
catch (ArgumentException e)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("Error_InvalidCharactersInPathSegment"),
string.Join("', '", paths)),
e);
}
}
private static MsBuildToolset GetToolsetFromUserVersion(
string userVersion,
IEnumerable <MsBuildToolset> installedToolsets)
{
// Version.TryParse only take decimal string like "14.0", "14" need to be converted.
var versionParts = userVersion.Split('.');
var major = versionParts.Length > 0 ? versionParts[0] : "0";
var minor = versionParts.Length > 1 ? versionParts[1] : "0";
var userVersionString = string.Join(".", major, minor);
// First match by string comparison
var selectedToolset = installedToolsets.FirstOrDefault(
t => string.Equals(userVersion, t.Version, StringComparison.OrdinalIgnoreCase));
if (selectedToolset != null)
{
return(selectedToolset);
}
// Then match by Major & Minor version numbers. And we want an actual parsing of t.ToolsVersion,
// without the safe fallback to 0.0 built into t.ParsedToolsVersion.
selectedToolset = installedToolsets.FirstOrDefault(t =>
{
Version parsedUserVersion;
Version parsedToolsVersion;
if (Version.TryParse(userVersionString, out parsedUserVersion) &&
Version.TryParse(t.Version, out parsedToolsVersion))
{
return(parsedToolsVersion.Major == parsedUserVersion.Major &&
parsedToolsVersion.Minor == parsedUserVersion.Minor);
}
return(false);
});
if (selectedToolset == null)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString(
nameof(NuGetResources.Error_CannotFindMsbuild)),
userVersion);
throw new CommandException(message);
}
return(selectedToolset);
}
private void AddNewSource()
{
if (String.IsNullOrEmpty(Name))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNameRequired"));
}
if (String.Equals(Name, LocalizedResourceManager.GetString("ReservedPackageNameAll")))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandAllNameIsReserved"));
}
if (String.IsNullOrEmpty(Source))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandSourceRequired"));
}
// Make sure that the Source given is a valid one.
if (!PathValidator.IsValidSource(Source))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandInvalidSource"));
}
ValidateCredentials();
// Check to see if we already have a registered source with the same name or source
var sourceList = SourceProvider.LoadPackageSources().ToList();
bool hasName = sourceList.Any(ps => String.Equals(Name, ps.Name, StringComparison.OrdinalIgnoreCase));
if (hasName)
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandUniqueName"));
}
bool hasSource = sourceList.Any(ps => String.Equals(Source, ps.Source, StringComparison.OrdinalIgnoreCase));
if (hasSource)
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandUniqueSource"));
}
var newPackageSource = new Configuration.PackageSource(Source, Name);
if (!string.IsNullOrEmpty(UserName))
{
var credentials = Configuration.PackageSourceCredential.FromUserInput(Name, UserName, Password, StorePasswordInClearText);
newPackageSource.Credentials = credentials;
}
sourceList.Add(newPackageSource);
SourceProvider.SavePackageSources(sourceList);
Console.WriteLine(LocalizedResourceManager.GetString("SourcesCommandSourceAddedSuccessfully"), Name);
}
private static void LogHelperMessageForPathTooLongException(Console logger)
{
if (!IsWindows10(logger))
{
logger.WriteWarning(LocalizedResourceManager.GetString(nameof(NuGetResources.Warning_LongPath_UnsupportedOS)));
}
else if (!IsSupportLongPathEnabled(logger))
{
logger.WriteWarning(LocalizedResourceManager.GetString(nameof(NuGetResources.Warning_LongPath_DisabledPolicy)));
}
else if (!IsRuntimeGreaterThanNet462(logger))
{
logger.WriteWarning(LocalizedResourceManager.GetString(nameof(NuGetResources.Warning_LongPath_UnsupportedNetFramework)));
}
}
/// <summary>
/// Outputs the current NuGet version (by default, only when vebosity is detailed).
/// </summary>
private void OutputNuGetVersion()
{
if (ShouldOutputNuGetVersion)
{
var assemblyName = Assembly.GetExecutingAssembly().GetName();
var assemblyLocation = Assembly.GetExecutingAssembly().Location;
var version = System.Diagnostics.FileVersionInfo.GetVersionInfo(assemblyLocation).FileVersion;
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("OutputNuGetVersion"),
assemblyName.Name,
version);
Console.WriteLine(message);
}
}
public override void ExecuteCommand()
{
if (SourceProvider == null)
{
throw new InvalidOperationException(LocalizedResourceManager.GetString("Error_SourceProviderIsNull"));
}
if (Settings == null)
{
throw new InvalidOperationException(LocalizedResourceManager.GetString("Error_SettingsIsNull"));
}
//Frist argument should be the ApiKey
string apiKey = Arguments[0];
bool setSymbolServerKey = false;
//If the user passed a source use it for the gallery location
string source;
if (String.IsNullOrEmpty(Source))
{
source = NuGetConstants.DefaultGalleryServerUrl;
// If no source was specified, set the default symbol server key to be the same
setSymbolServerKey = true;
}
else
{
source = SourceProvider.ResolveAndValidateSource(Source);
}
SettingsUtility.SetEncryptedValue(Settings, ConfigurationConstants.ApiKeys, source, apiKey);
string sourceName = CommandLineUtility.GetSourceDisplayName(source);
// Setup the symbol server key
if (setSymbolServerKey)
{
SettingsUtility.SetEncryptedValue(Settings, ConfigurationConstants.ApiKeys, NuGetConstants.DefaultSymbolServerUrl, apiKey);
Console.WriteLine(LocalizedResourceManager.GetString("SetApiKeyCommandDefaultApiKeysSaved"),
apiKey,
sourceName,
CommandLineUtility.GetSourceDisplayName(NuGetConstants.DefaultSymbolServerUrl));
}
else
{
Console.WriteLine(LocalizedResourceManager.GetString("SetApiKeyCommandApiKeySaved"), apiKey, sourceName);
}
}
/// <summary>
/// Gets the msbuild toolset that matches the given <paramref name="msbuildVersion"/>.
/// </summary>
/// <param name="msbuildVersion">The msbuild version. Can be null.</param>
/// <param name="installedToolsets">List of installed toolsets,
/// ordered by ToolsVersion, from highest to lowest.</param>
/// <returns>The matching toolset.</returns>
/// <remarks>This method is not intended to be called directly. It's marked public so that it
/// can be called by unit tests.</remarks>
public static MsbuildToolSet SelectMsbuildToolset(
Version msbuildVersion,
IEnumerable <MsbuildToolSet> installedToolsets)
{
MsbuildToolSet selectedToolset;
if (msbuildVersion == null)
{
// MSBuild does not exist in PATH. In this case, the highest installed version is used
selectedToolset = installedToolsets.FirstOrDefault();
}
else
{
// Search by major & minor version
selectedToolset = installedToolsets.FirstOrDefault(
toolset =>
{
var v = SafeParseVersion(toolset.ToolsVersion);
return(v.Major == msbuildVersion.Major && v.Minor == v.Minor);
});
if (selectedToolset == null)
{
// no match found. Now search by major only
selectedToolset = installedToolsets.FirstOrDefault(
toolset =>
{
var v = SafeParseVersion(toolset.ToolsVersion);
return(v.Major == msbuildVersion.Major);
});
}
if (selectedToolset == null)
{
// still no match. Use the highest installed version in this case
selectedToolset = installedToolsets.FirstOrDefault();
}
}
if (selectedToolset == null)
{
throw new CommandLineException(
LocalizedResourceManager.GetString(
nameof(NuGetResources.Error_MSBuildNotInstalled)));
}
return(selectedToolset);
}
private void ProcessSolutionFile(string solutionFileFullPath, PackageRestoreInputs restoreInputs)
{
restoreInputs.DirectoryOfSolutionFile = Path.GetDirectoryName(solutionFileFullPath);
restoreInputs.NameOfSolutionFile = Path.GetFileNameWithoutExtension(solutionFileFullPath);
// restore packages for the solution
string solutionLevelPackagesConfig;
try
{
solutionLevelPackagesConfig = Path.Combine(
restoreInputs.DirectoryOfSolutionFile,
NuGetConstants.NuGetSolutionSettingsFolder,
Constants.PackageReferenceFile);
}
catch (ArgumentException e)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("Error_InvalidSolutionDirectory"),
restoreInputs.DirectoryOfSolutionFile),
e);
}
if (File.Exists(solutionLevelPackagesConfig))
{
restoreInputs.PackagesConfigFiles.Add(solutionLevelPackagesConfig);
}
var projectFiles = MsBuildUtility.GetAllProjectFileNames(solutionFileFullPath, MsBuildDirectory.Value.Path);
foreach (var projectFile in projectFiles)
{
if (!File.Exists(projectFile))
{
var message = string.Format(CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandProjectNotFound"),
projectFile);
Console.LogWarning(message);
continue;
}
var normalizedProjectFile = Path.GetFullPath(projectFile);
// Add everything
restoreInputs.ProjectFiles.Add(normalizedProjectFile);
}
}
private void UpdatePackageSource()
{
if (String.IsNullOrEmpty(Name))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNameRequired"));
}
var sourceList = SourceProvider.LoadPackageSources().ToList();
int existingSourceIndex = sourceList.FindIndex(ps => Name.Equals(ps.Name, StringComparison.OrdinalIgnoreCase));
if (existingSourceIndex == -1)
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNoMatchingSourcesFound"), Name);
}
var existingSource = sourceList[existingSourceIndex];
if (!String.IsNullOrEmpty(Source) && !existingSource.Source.Equals(Source, StringComparison.OrdinalIgnoreCase))
{
if (!PathValidator.IsValidSource(Source))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandInvalidSource"));
}
// If the user is updating the source, verify we don't have a duplicate.
bool duplicateSource = sourceList.Any(ps => String.Equals(Source, ps.Source, StringComparison.OrdinalIgnoreCase));
if (duplicateSource)
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandUniqueSource"));
}
existingSource = new Configuration.PackageSource(Source, existingSource.Name);
}
ValidateCredentials();
sourceList.RemoveAt(existingSourceIndex);
if (!string.IsNullOrEmpty(UserName))
{
var credentials = Configuration.PackageSourceCredential.FromUserInput(Name, UserName, Password,
storePasswordInClearText: StorePasswordInClearText);
existingSource.Credentials = credentials;
}
sourceList.Insert(existingSourceIndex, existingSource);
SourceProvider.SavePackageSources(sourceList);
Console.WriteLine(LocalizedResourceManager.GetString("SourcesCommandUpdateSuccessful"), Name);
}
public override async Task ExecuteCommandAsync()
{
string packagePath = Arguments[0];
string apiKeyValue = null;
if (!string.IsNullOrEmpty(ApiKey))
{
apiKeyValue = ApiKey;
}
else if (Arguments.Count > 1 && !string.IsNullOrEmpty(Arguments[1]))
{
apiKeyValue = Arguments[1];
}
try
{
await PushRunner.Run(
Settings,
SourceProvider,
new[] { packagePath },
Source,
apiKeyValue,
SymbolSource,
SymbolApiKey,
Timeout,
DisableBuffering,
NoSymbols,
NoServiceEndpoint,
SkipDuplicate,
Console);
}
catch (TaskCanceledException ex)
{
string timeoutMessage = LocalizedResourceManager.GetString(nameof(NuGetResources.PushCommandTimeoutError));
throw new AggregateException(ex, new Exception(timeoutMessage));
}
catch (Exception ex)
{
if (ex is HttpRequestException && ex.InnerException is WebException)
{
throw ex.InnerException;
}
throw;
}
}
public override void ExecuteCommand()
{
if (SourceProvider == null)
{
throw new InvalidOperationException(LocalizedResourceManager.GetString("Error_SourceProviderIsNull"));
}
// Convert to update
var action = Arguments.FirstOrDefault();
// TODO: Change these in to switches so we don't have to parse them here.
if (string.IsNullOrEmpty(action) || action.Equals("List", StringComparison.OrdinalIgnoreCase))
{
switch (Format)
{
case SourcesListFormat.Short:
PrintRegisteredSourcesShort();
break;
default:
PrintRegisteredSourcesDetailed();
break;
}
}
else if (action.Equals("Add", StringComparison.OrdinalIgnoreCase))
{
AddNewSource();
}
else if (action.Equals("Remove", StringComparison.OrdinalIgnoreCase))
{
RemoveSource();
}
else if (action.Equals("Enable", StringComparison.OrdinalIgnoreCase))
{
EnableOrDisableSource(enabled: true);
}
else if (action.Equals("Disable", StringComparison.OrdinalIgnoreCase))
{
EnableOrDisableSource(enabled: false);
}
else if (action.Equals("Update", StringComparison.OrdinalIgnoreCase))
{
UpdatePackageSource();
}
}
private Task PerformV2Restore(string packagesConfigFilePath, string installPath)
{
var sourceRepositoryProvider = GetSourceRepositoryProvider();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion);
var installedPackageReferences = GetInstalledPackageReferences(
packagesConfigFilePath,
allowDuplicatePackageIds: true);
var packageRestoreData = installedPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { packagesConfigFilePath },
isMissing: true));
var packageSources = GetPackageSources(Settings);
Console.PrintPackageSources(packageSources);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: null,
packageRestoreFailedEvent: null,
sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository),
maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism);
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).Any();
if (!missingPackageReferences)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandNothingToInstall"),
packagesConfigFilePath);
Console.LogMinimal(message);
}
Task <PackageRestoreResult> packageRestoreTask = PackageRestoreManager.RestoreMissingPackagesAsync(packageRestoreContext, new ConsoleProjectContext(Console));
return(packageRestoreTask);
}
private async Task UpdateTrustedSourceAsync(PackageSource packageSource)
{
var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider);
var repositorySignatureResource = await sourceRepositoryProvider.CreateRepository(packageSource).GetResourceAsync <RepositorySignatureResource>() ??
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandSourceNotSupportRepoSign"), packageSource.Name);
var trustedSource = new TrustedSource(packageSource.Name);
foreach (var cert in repositorySignatureResource.RepositoryCertificateInfos)
{
foreach (var fingerprint in cert.Fingerprints)
{
trustedSource.Certificates.Add(new CertificateTrustEntry(fingerprint.Value, cert.Subject, CryptoHashUtility.OidToHashAlgorithmName(fingerprint.Key)));
}
}
packageSource.TrustedSource = trustedSource;
}
private MSBuildProjectSystem GetMSBuildProject(string packageReferenceFilePath, INuGetProjectContext projectContext)
{
// Try to locate the project file associated with this packages.config file
var directory = Path.GetDirectoryName(packageReferenceFilePath);
var projectFiles = ProjectHelper.GetProjectFiles(directory).Take(2).ToArray();
if (projectFiles.Length == 0)
{
throw new CommandLineException(LocalizedResourceManager.GetString("UnableToLocateProjectFile"), packageReferenceFilePath);
}
if (projectFiles.Length > 1)
{
throw new CommandLineException(LocalizedResourceManager.GetString("MultipleProjectFilesFound"), packageReferenceFilePath);
}
return(new MSBuildProjectSystem(_msbuildDirectory, projectFiles[0], projectContext));
}
private void ValidateCredentials()
{
var isUsernameEmpty = string.IsNullOrEmpty(Username);
var isPasswordEmpty = string.IsNullOrEmpty(Password);
var isAuthTypesEmpty = string.IsNullOrEmpty(ValidAuthenticationTypes);
if (isUsernameEmpty ^ isPasswordEmpty)
{
// If only one of them is set, throw.
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandCredentialsRequired"));
}
if (isPasswordEmpty && !isAuthTypesEmpty)
{
// can't specify auth types without credentials
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandCredentialsRequiredWithAuthTypes"));
}
}
public override Task ExecuteCommandAsync()
{
// On mono, parallel builds are broken for some reason. See https://gist.github.com/4201936 for the errors
// That are thrown.
DisableParallelProcessing |= RuntimeEnvironmentHelper.IsMono;
if (DisableParallelProcessing)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
CalculateEffectivePackageSaveMode();
CalculateEffectiveSettings();
var installPath = Path.GetFullPath(ResolveInstallPath());
var configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
var configFileName = Path.GetFileName(configFilePath);
// If the first argument is a packages.xxx.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (CommandLineUtility.IsValidConfigFileName(configFileName))
{
Prerelease = true;
// display opt-out message if needed
if (Console != null && RequireConsent &&
new PackageRestoreConsent(Settings).IsGranted)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
return(PerformV2RestoreAsync(configFilePath, installPath));
}
else
{
var packageId = Arguments[0];
var version = Version != null ? new NuGetVersion(Version) : null;
return(InstallPackageAsync(packageId, version, installPath));
}
}
internal void SelfUpdate(string exePath, bool prerelease, CoreV2.NuGet.SemanticVersion version)
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandCheckingForUpdates"), NuGetConstants.V2FeedUrl);
// Get the nuget command line package from the specified repository
CoreV2.NuGet.IPackageRepository packageRepository = _repositoryFactory.CreateRepository(NuGetConstants.V2FeedUrl);
CoreV2.NuGet.IPackage package = packageRepository.GetUpdates(
new [] { new CoreV2.NuGet.PackageName(NuGetCommandLinePackageId, version) },
includePrerelease: prerelease,
includeAllVersions: false,
targetFrameworks: null,
versionConstraints: null).FirstOrDefault();
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandCurrentlyRunningNuGetExe"), version); // SemanticVersion is the problem
// Check to see if an update is needed
if (package == null || version >= package.Version)
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandNuGetUpToDate"));
}
else
{
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdatingNuGet"), package.Version);
// Get NuGet.exe file from the package
CoreV2.NuGet.IPackageFile file = package.GetFiles().FirstOrDefault(f => Path.GetFileName(f.Path).Equals(NuGetExe, StringComparison.OrdinalIgnoreCase));
// If for some reason this package doesn't have NuGet.exe then we don't want to use it
if (file == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("UpdateCommandUnableToLocateNuGetExe"));
}
// Get the exe path and move it to a temp file (NuGet.exe.old) so we can replace the running exe with the bits we got
// from the package repository
string renamedPath = exePath + ".old";
Move(exePath, renamedPath);
// Update the file
UpdateFile(exePath, file);
Console.WriteLine(LocalizedResourceManager.GetString("UpdateCommandUpdateSuccessful"));
}
}
private void RemoveSource()
{
if (String.IsNullOrEmpty(Name))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNameRequired"));
}
// Check to see if we already have a registered source with the same name or source
var sourceList = SourceProvider.LoadPackageSources().ToList();
var matchingSources = sourceList.Where(ps => String.Equals(Name, ps.Name, StringComparison.OrdinalIgnoreCase)).ToList();
if (!matchingSources.Any())
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNoMatchingSourcesFound"), Name);
}
sourceList.RemoveAll(matchingSources.Contains);
SourceProvider.SavePackageSources(sourceList);
Console.WriteLine(LocalizedResourceManager.GetString("SourcesCommandSourceRemovedSuccessfully"), Name);
}
public override async Task ExecuteCommandAsync()
{
// Arguments[0] or Arguments[1] will not be null at this point.
// Because, this command has MinArgs set to 2.
var source = Arguments[0];
var destination = Arguments[1];
OfflineFeedUtility.ThrowIfInvalidOrNotFound(
source,
isDirectory: true,
resourceString: LocalizedResourceManager.GetString(nameof(NuGetResources.InitCommand_FeedIsNotFound)));
// If the Destination Feed Folder does not exist, it will be created.
OfflineFeedUtility.ThrowIfInvalid(destination);
var packagePaths = GetPackageFilePaths(source, "*" + PackagingCoreConstants.NupkgExtension);
if (packagePaths.Count > 0)
{
foreach (var packagePath in packagePaths)
{
var offlineFeedAddContext = new OfflineFeedAddContext(
packagePath,
destination,
Console, // IConsole is an ILogger
throwIfSourcePackageIsInvalid: false,
throwIfPackageExistsAndInvalid: false,
throwIfPackageExists: false,
expand: Expand);
await OfflineFeedUtility.AddPackageToSource(offlineFeedAddContext, CancellationToken.None);
}
}
else
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString(nameof(NuGetResources.InitCommand_FeedContainsNoPackages)),
source);
Console.LogMinimal(message);
}
}
/// <summary>
/// Discover all restore inputs, this checks for both v2 and v3
/// </summary>
private async Task <PackageRestoreInputs> DetermineRestoreInputsAsync()
{
var packageRestoreInputs = new PackageRestoreInputs();
if (Arguments.Count == 0)
{
// If no arguments were provided use the current directory
GetInputsFromDirectory(Directory.GetCurrentDirectory(), packageRestoreInputs);
}
else
{
// Restore takes multiple arguments, each could be a file or directory
var argument = Arguments.Single();
var fullPath = Path.GetFullPath(argument);
if (Directory.Exists(fullPath))
{
// Dir
GetInputsFromDirectory(fullPath, packageRestoreInputs);
}
else if (File.Exists(fullPath))
{
// File
GetInputsFromFile(fullPath, packageRestoreInputs);
}
else
{
// Not found
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandFileNotFound"),
argument);
throw new InvalidOperationException(message);
}
}
// Run inputs through msbuild to determine the
// correct type and find dependencies as needed.
await DetermineInputsFromMSBuildAsync(packageRestoreInputs);
return(packageRestoreInputs);
}
private void RemoveSource()
{
if (string.IsNullOrEmpty(Name))
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNameRequired"));
}
// Check to see if we already have a registered source with the same name or source
var sourceList = SourceProvider.LoadPackageSources().ToList();
var source = SourceProvider.GetPackageSourceByName(Name);
if (source == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("SourcesCommandNoMatchingSourcesFound"), Name);
}
SourceProvider.RemovePackageSource(Name);
Console.WriteLine(LocalizedResourceManager.GetString("SourcesCommandSourceRemovedSuccessfully"), Name);
}
/// <summary>
/// Constructor. It creates an empty temp file under the temp directory / NuGet, with
/// extension <paramref name="extension"/>.
/// </summary>
/// <param name="extension">The extension of the temp file.</param>
public TempFile(string extension)
{
if (string.IsNullOrEmpty(extension))
{
throw new ArgumentNullException(nameof(extension));
}
var tempDirectory = NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp);
Directory.CreateDirectory(tempDirectory);
var count = 0;
do
{
_filePath = Path.Combine(tempDirectory, Path.GetRandomFileName() + extension);
if (!File.Exists(_filePath))
{
try
{
// create an empty file
using (var filestream = File.Open(_filePath, FileMode.CreateNew))
{
}
// file is created successfully.
return;
}
catch
{
// Ignore and try again
}
}
count++;
}while (count < 3);
throw new InvalidOperationException(
LocalizedResourceManager.GetString(nameof(NuGetResources.Error_FailedToCreateRandomFileForP2P)));
}
/// <summary>
/// Parse the Framework parameter or use Any as the default framework.
/// </summary>
private NuGetFramework GetTargetFramework()
{
var targetFramework = NuGetFramework.AnyFramework;
if (!string.IsNullOrEmpty(Framework))
{
targetFramework = NuGetFramework.Parse(Framework);
}
if (targetFramework.IsUnsupported)
{
// Fail with a helpful message if the user provided an invalid framework.
var message = string.Format(CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("UnsupportedFramework"),
Framework);
throw new ArgumentException(message);
}
return(targetFramework);
}
private static MethodInfo GetAllProjectFileNamesMethod()
{
#pragma warning disable 618
var assembly = typeof(Microsoft.Build.BuildEngine.Engine).Assembly;
#pragma warning restore 618
var solutionParserType = assembly.GetType("Mono.XBuild.CommandLine.SolutionParser");
if (solutionParserType == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("Error_CannotGetXBuildSolutionParser"));
}
var methodInfo = solutionParserType.GetMethod(
"GetAllProjectFileNames",
new Type[] { typeof(string) });
if (methodInfo == null)
{
throw new CommandLineException(LocalizedResourceManager.GetString("Error_CannotGetGetAllProjectFileNamesMethod"));
}
return(methodInfo);
}
public override Task ExecuteCommandAsync()
{
if (DisableParallelProcessing)
{
HttpSourceResourceProvider.Throttle = SemaphoreSlimThrottle.CreateBinarySemaphore();
}
CalculateEffectivePackageSaveMode();
CalculateEffectiveSettings();
string installPath = ResolveInstallPath();
string configFilePath = Path.GetFullPath(Arguments.Count == 0 ? Constants.PackageReferenceFile : Arguments[0]);
string configFileName = Path.GetFileName(configFilePath);
// If the first argument is a packages.xxx.config file, install everything it lists
// Otherwise, treat the first argument as a package Id
if (PackageReferenceFile.IsValidConfigFileName(configFileName))
{
Prerelease = true;
// display opt-out message if needed
if (Console != null && RequireConsent &&
new PackageRestoreConsent(new SettingsToLegacySettings(Settings)).IsGranted)
{
string message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandPackageRestoreOptOutMessage"),
NuGet.Resources.NuGetResources.PackageRestoreConsentCheckBoxText.Replace("&", ""));
Console.WriteLine(message);
}
return(PerformV2Restore(configFilePath, installPath));
}
else
{
var packageId = Arguments[0];
var version = Version != null ? new NuGetVersion(Version) : null;
return(InstallPackage(packageId, version, installPath));
}
}
public static object ChangeType(object value, Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (value == null)
{
if (TypeAllowsNull(type))
{
return(null);
}
return(Convert.ChangeType(value, type, CultureInfo.CurrentCulture));
}
type = RemoveNullableFromType(type);
if (value.GetType() == type)
{
return(value);
}
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertFrom(value.GetType()))
{
return(converter.ConvertFrom(value));
}
TypeConverter otherConverter = TypeDescriptor.GetConverter(value.GetType());
if (otherConverter.CanConvertTo(type))
{
return(otherConverter.ConvertTo(value, type));
}
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("UnableToConvertTypeError"), value.GetType(), type));
}
public override async Task ExecuteCommandAsync()
{
string packagePath = Arguments[0];
string sourcePath = Source;
string apiKeyValue = ApiKey;
int timeoutSeconds = Timeout;
if (string.IsNullOrEmpty(apiKeyValue) && Arguments.Count > 1)
{
apiKeyValue = Arguments[1];
}
try
{
await PushRunner.Run(
Settings,
SourceProvider,
packagePath,
Source,
apiKeyValue,
Timeout,
DisableBuffering,
NoSymbols,
Console);
}
catch (TaskCanceledException ex)
{
string timeoutMessage = LocalizedResourceManager.GetString(nameof(NuGetResources.PushCommandTimeoutError));
throw new AggregateException(ex, new Exception(timeoutMessage));
}
catch (Exception ex)
{
if (ex is HttpRequestException && ex.InnerException is WebException)
{
throw ex.InnerException;
}
throw;
}
}
internal void CalculateEffectivePackageSaveMode()
{
string packageSaveModeValue = PackageSaveMode;
if (string.IsNullOrEmpty(packageSaveModeValue))
{
packageSaveModeValue = SettingsUtility.GetConfigValue(Settings, "PackageSaveMode");
}
if (!string.IsNullOrEmpty(packageSaveModeValue))
{
// The PackageSaveMode flag only determines if nuspec and nupkg are saved at the target location.
// For install \ restore, we always extract files.
EffectivePackageSaveMode = Packaging.PackageSaveMode.Files;
foreach (var v in packageSaveModeValue.Split(';'))
{
if (v.Equals(Packaging.PackageSaveMode.Nupkg.ToString(), StringComparison.OrdinalIgnoreCase))
{
EffectivePackageSaveMode |= Packaging.PackageSaveMode.Nupkg;
}
else if (v.Equals(Packaging.PackageSaveMode.Nuspec.ToString(), StringComparison.OrdinalIgnoreCase))
{
EffectivePackageSaveMode |= Packaging.PackageSaveMode.Nuspec;
}
else
{
string message = String.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("Warning_InvalidPackageSaveMode"),
v);
throw new InvalidOperationException(message);
}
}
}
else
{
EffectivePackageSaveMode = Packaging.PackageSaveMode.None;
}
}
