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