/// <summary>
/// Load the user specific settings
/// </summary>
/// <param name="root"></param>
/// <param name="configFileName"></param>
/// <param name="useTestingGlobalPath"></param>
/// <param name="settingsLoadingContext"></param>
/// <returns></returns>
internal static IEnumerable <SettingsFile> LoadUserSpecificSettings(
string root,
string configFileName,
bool useTestingGlobalPath,
SettingsLoadingContext settingsLoadingContext = null)
{
// Path.Combine is performed with root so it should not be null
// However, it is legal for it be empty in this method
var rootDirectory = root ?? string.Empty;
if (configFileName == null)
{
string userSettingsDir = GetUserSettingsDirectory(rootDirectory, useTestingGlobalPath);
if (userSettingsDir == null)
{
yield break;
}
var defaultSettingsFilePath = Path.Combine(userSettingsDir, DefaultSettingsFileName);
// ReadSettings will try to create the default config file if it doesn't exist
SettingsFile userSpecificSettings = ReadSettings(rootDirectory, defaultSettingsFilePath, settingsLoadingContext: settingsLoadingContext);
yield return(userSpecificSettings);
// For backwards compatibility, we first return default user specific the non-default configs and then the additional files from the nested `config` directory
var additionalConfigurationPath = GetAdditionalUserWideConfigurationDirectory(userSettingsDir);
foreach (var file in FileSystemUtility
.GetFilesRelativeToRoot(root: additionalConfigurationPath, filters: SupportedMachineWideConfigExtension, searchOption: SearchOption.TopDirectoryOnly)
.OrderBy(e => e, PathUtility.GetStringComparerBasedOnOS()))
{
if (!PathUtility.GetStringComparerBasedOnOS().Equals(DefaultSettingsFileName, file))
{
var settings = ReadSettings(additionalConfigurationPath, file, isMachineWideSettings: false, isAdditionalUserWideConfig: true);
if (settings != null)
{
yield return(settings);
}
}
}
}
else
{
if (!FileSystemUtility.DoesFileExistIn(rootDirectory, configFileName))
{
var message = string.Format(CultureInfo.CurrentCulture,
Resources.FileDoesNotExist,
Path.Combine(rootDirectory, configFileName));
throw new InvalidOperationException(message);
}
yield return(ReadSettings(rootDirectory, configFileName, settingsLoadingContext: settingsLoadingContext));
}
}
private static void LoadUserSpecificSettings(
List <Settings> validSettingFiles,
string root,
string configFileName)
{
if (root == null)
{
// Path.Combine is performed with root so it should not be null
// However, it is legal for it be empty in this method
root = String.Empty;
}
// for the default location, allow case where file does not exist, in which case it'll end
// up being created if needed
Settings appDataSettings = null;
if (configFileName == null)
{
// load %AppData%\NuGet\NuGet.config
#if !DNXCORE50
string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
#else
string appDataPath = Environment.GetEnvironmentVariable("AppData");
#endif
if (!String.IsNullOrEmpty(appDataPath))
{
var defaultSettingsFilePath = Path.Combine(
appDataPath, "NuGet", DefaultSettingsFileName);
// Since defaultSettingsFilePath is a full path, so it doesn't matter what value is
// used as root for the PhysicalFileSystem.
appDataSettings = ReadSettings(
root,
defaultSettingsFilePath);
}
}
else
{
if (!FileSystemUtility.DoesFileExistIn(root, configFileName))
{
string message = String.Format(CultureInfo.CurrentCulture,
Resources.FileDoesNotExist,
Path.Combine(root, configFileName));
throw new InvalidOperationException(message);
}
appDataSettings = ReadSettings(root, configFileName);
}
if (appDataSettings != null)
{
validSettingFiles.Add(appDataSettings);
}
}
/// <remarks>
/// Order is most significant (e.g. applied last) to least significant (applied first)
/// ex:
/// c:\someLocation\nuget.config
/// c:\nuget.config
/// </remarks>
private static IEnumerable <string> GetSettingsFileNames(string root)
{
// for dirs obtained by walking up the tree, only consider setting files that already exist.
// otherwise we'd end up creating them.
foreach (var dir in GetSettingsFilePaths(root))
{
string fileName = Path.Combine(dir, DefaultSettingsFileName);
if (FileSystemUtility.DoesFileExistIn(root, fileName))
{
yield return(fileName);
}
}
}
/// <summary>
/// Load the user specific settings
/// </summary>
/// <param name="root"></param>
/// <param name="configFileName"></param>
/// <param name="useTestingGlobalPath"></param>
/// <param name="settingsLoadingContext"></param>
/// <returns></returns>
internal static IEnumerable <SettingsFile> LoadUserSpecificSettings(
string root,
string configFileName,
bool useTestingGlobalPath,
SettingsLoadingContext settingsLoadingContext = null)
{
// Path.Combine is performed with root so it should not be null
// However, it is legal for it be empty in this method
var rootDirectory = root ?? string.Empty;
if (configFileName == null)
{
string userSettingsDir = GetUserSettingsDirectory(rootDirectory, useTestingGlobalPath);
if (userSettingsDir == null)
{
yield break;
}
// If the default user config NuGet.Config does not exist, we need to create it.
var defaultSettingsFilePath = Path.Combine(userSettingsDir, DefaultSettingsFileName);
SettingsFile userSpecificSettings = ReadSettings(rootDirectory, defaultSettingsFilePath, settingsLoadingContext: settingsLoadingContext);
if (File.Exists(defaultSettingsFilePath) && userSpecificSettings.IsEmpty())
{
var trackFilePath = Path.Combine(Path.GetDirectoryName(defaultSettingsFilePath), NuGetConstants.AddV3TrackFile);
if (!File.Exists(trackFilePath))
{
File.Create(trackFilePath).Dispose();
var defaultSource = new SourceItem(NuGetConstants.FeedName, NuGetConstants.V3FeedUrl, protocolVersion: "3");
userSpecificSettings.AddOrUpdate(ConfigurationConstants.PackageSources, defaultSource);
userSpecificSettings.SaveToDisk();
}
}
yield return(userSpecificSettings);
// For backwards compatibility, we first return default user specific the non-default configs and then the additional files from the nested `config` directory
var additionalConfigurationPath = GetAdditionalUserWideConfigurationDirectory(userSettingsDir);
foreach (var file in FileSystemUtility
.GetFilesRelativeToRoot(root: additionalConfigurationPath, filters: SupportedMachineWideConfigExtension, searchOption: SearchOption.TopDirectoryOnly)
.OrderBy(e => e, PathUtility.GetStringComparerBasedOnOS()))
{
if (!PathUtility.GetStringComparerBasedOnOS().Equals(DefaultSettingsFileName, file))
{
var settings = ReadSettings(additionalConfigurationPath, file, isMachineWideSettings: false, isAdditionalUserWideConfig: true);
if (settings != null)
{
yield return(settings);
}
}
}
}
else
{
if (!FileSystemUtility.DoesFileExistIn(rootDirectory, configFileName))
{
var message = string.Format(CultureInfo.CurrentCulture,
Resources.FileDoesNotExist,
Path.Combine(rootDirectory, configFileName));
throw new InvalidOperationException(message);
}
yield return(ReadSettings(rootDirectory, configFileName, settingsLoadingContext: settingsLoadingContext));
}
}
private static SettingsFile LoadUserSpecificSettings(
string root,
string configFileName,
bool useTestingGlobalPath)
{
// Path.Combine is performed with root so it should not be null
// However, it is legal for it be empty in this method
var rootDirectory = root ?? string.Empty;
// for the default location, allow case where file does not exist, in which case it'll end
// up being created if needed
SettingsFile userSpecificSettings = null;
if (configFileName == null)
{
var defaultSettingsFilePath = string.Empty;
if (useTestingGlobalPath)
{
defaultSettingsFilePath = Path.Combine(rootDirectory, "TestingGlobalPath", DefaultSettingsFileName);
}
else
{
var userSettingsDir = NuGetEnvironment.GetFolderPath(NuGetFolderPath.UserSettingsDirectory);
// If there is no user settings directory, return no settings
if (userSettingsDir == null)
{
return(null);
}
defaultSettingsFilePath = Path.Combine(userSettingsDir, DefaultSettingsFileName);
}
userSpecificSettings = ReadSettings(rootDirectory, defaultSettingsFilePath);
if (File.Exists(defaultSettingsFilePath) && userSpecificSettings.IsEmpty())
{
var trackFilePath = Path.Combine(Path.GetDirectoryName(defaultSettingsFilePath), NuGetConstants.AddV3TrackFile);
if (!File.Exists(trackFilePath))
{
File.Create(trackFilePath).Dispose();
var defaultSource = new SourceItem(NuGetConstants.FeedName, NuGetConstants.V3FeedUrl, protocolVersion: "3");
userSpecificSettings.AddOrUpdate(ConfigurationConstants.PackageSources, defaultSource);
userSpecificSettings.SaveToDisk();
}
}
}
else
{
if (!FileSystemUtility.DoesFileExistIn(rootDirectory, configFileName))
{
var message = string.Format(CultureInfo.CurrentCulture,
Resources.FileDoesNotExist,
Path.Combine(rootDirectory, configFileName));
throw new InvalidOperationException(message);
}
userSpecificSettings = ReadSettings(rootDirectory, configFileName);
}
return(userSpecificSettings);
}
private static void LoadUserSpecificSettings(
List <Settings> validSettingFiles,
string root,
string configFileName,
IMachineWideSettings machineWideSettings,
bool useTestingGlobalPath
)
{
if (root == null)
{
// Path.Combine is performed with root so it should not be null
// However, it is legal for it be empty in this method
root = String.Empty;
}
// for the default location, allow case where file does not exist, in which case it'll end
// up being created if needed
Settings appDataSettings = null;
if (configFileName == null)
{
var defaultSettingsFilePath = String.Empty;
if (useTestingGlobalPath)
{
defaultSettingsFilePath = Path.Combine(root, "TestingGlobalPath", DefaultSettingsFileName);
}
else
{
var userSettingsDir = NuGetEnvironment.GetFolderPath(NuGetFolderPath.UserSettingsDirectory);
// If there is no user settings directory, return no appdata settings
if (userSettingsDir == null)
{
return;
}
defaultSettingsFilePath = Path.Combine(userSettingsDir, DefaultSettingsFileName);
}
if (!File.Exists(defaultSettingsFilePath) && machineWideSettings != null)
{
// Since defaultSettingsFilePath is a full path, so it doesn't matter what value is
// used as root for the PhysicalFileSystem.
appDataSettings = ReadSettings(
root,
defaultSettingsFilePath);
// Disable machinewide sources to improve perf
var disabledSources = new List <SettingValue>();
foreach (var setting in machineWideSettings.Settings)
{
var values = setting.GetSettingValues(ConfigurationConstants.PackageSources, isPath: true);
foreach (var value in values)
{
var packageSource = new PackageSource(value.Value);
// if the machine wide package source is http source, disable it by default
if (packageSource.IsHttp)
{
disabledSources.Add(new SettingValue(value.Key, "true", origin: setting, isMachineWide: true, priority: 0));
}
}
}
appDataSettings.UpdateSections(ConfigurationConstants.DisabledPackageSources, disabledSources);
}
else
{
appDataSettings = ReadSettings(root, defaultSettingsFilePath);
bool IsEmptyConfig = !appDataSettings.GetSettingValues(ConfigurationConstants.PackageSources).Any();
if (IsEmptyConfig)
{
var trackFilePath = Path.Combine(Path.GetDirectoryName(defaultSettingsFilePath), NuGetConstants.AddV3TrackFile);
if (!File.Exists(trackFilePath))
{
File.Create(trackFilePath).Dispose();
var defaultPackageSource = new SettingValue(NuGetConstants.FeedName, NuGetConstants.V3FeedUrl, isMachineWide: false);
defaultPackageSource.AdditionalData.Add(ConfigurationConstants.ProtocolVersionAttribute, "3");
appDataSettings.UpdateSections(ConfigurationConstants.PackageSources, new List <SettingValue> {
defaultPackageSource
});
}
}
}
}
else
{
if (!FileSystemUtility.DoesFileExistIn(root, configFileName))
{
var message = String.Format(CultureInfo.CurrentCulture,
Resources.FileDoesNotExist,
Path.Combine(root, configFileName));
throw new InvalidOperationException(message);
}
appDataSettings = ReadSettings(root, configFileName);
}
if (appDataSettings != null)
{
validSettingFiles.Add(appDataSettings);
}
}