internal ClearItem(XElement element, SettingsFile origin) : base(element, origin) { }
internal ParsedSettingSection(XElement element, SettingsFile origin) : base(element, origin) { }
/// <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); }
internal SettingBase(XNode node, SettingsFile origin) { Node = node ?? throw new ArgumentNullException(nameof(node)); Origin = origin ?? throw new ArgumentNullException(nameof(origin)); }
internal FileClientCertItem(string packageSource, string filePath, string password, bool storePasswordInClearText, SettingsFile origin) : base(packageSource) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentException(Resources.Argument_Cannot_Be_Null_Or_Empty, nameof(filePath)); } Update(filePath, password, storePasswordInClearText); SetOrigin(origin); }
private void ValidateAttributes(XElement element, SettingsFile origin) { if (AllowedAttributes != null) { if (!AllowedAttributes.Any() && element.HasAttributes) { throw new NuGetConfigurationException(string.Format(CultureInfo.CurrentCulture, Resources.UserSettings_UnableToParseConfigFile, string.Format(CultureInfo.CurrentCulture, Resources.NoAttributesAllowed, element.Name.LocalName, element.Attributes().Count()), origin.ConfigFilePath)); } foreach (var attribute in element.Attributes()) { if (!AllowedAttributes.Contains(attribute.Name.LocalName)) { throw new NuGetConfigurationException(string.Format(CultureInfo.CurrentCulture, Resources.UserSettings_UnableToParseConfigFile, string.Format(CultureInfo.CurrentCulture, Resources.AttributeNotAllowed, attribute.Name.LocalName, element.Name.LocalName), origin.ConfigFilePath)); } } } if (RequiredAttributes != null) { foreach (var requireAttribute in RequiredAttributes) { var attribute = element.Attribute(requireAttribute); if (attribute == null) { throw new NuGetConfigurationException(string.Format(CultureInfo.CurrentCulture, Resources.UserSettings_UnableToParseConfigFile, string.Format(CultureInfo.CurrentCulture, Resources.MissingRequiredAttribute, requireAttribute, element.Name.LocalName), origin.ConfigFilePath)); } } } if (AllowedValues != null) { foreach (var attributeValues in AllowedValues) { var attribute = element.Attribute(attributeValues.Key); if (attribute != null && !attributeValues.Value.Contains(attribute.Value.Trim())) { throw new NuGetConfigurationException(string.Format(CultureInfo.CurrentCulture, Resources.UserSettings_UnableToParseConfigFile, string.Format(CultureInfo.CurrentCulture, Resources.AttributeValueNotAllowed, attribute.Name.LocalName, attribute.Value.Trim(), element.Name.LocalName), origin.ConfigFilePath)); } } } if (DisallowedValues != null) { foreach (var attributeValues in DisallowedValues) { var attribute = element.Attribute(attributeValues.Key); if (attribute != null && attributeValues.Value.Contains(attribute.Value.Trim())) { throw new NuGetConfigurationException(string.Format(CultureInfo.CurrentCulture, Resources.UserSettings_UnableToParseConfigFile, string.Format(CultureInfo.CurrentCulture, Resources.AttributeValueNotAllowed, attribute.Name.LocalName, attribute.Value.Trim(), element.Name.LocalName), origin.ConfigFilePath)); } } } }
internal PackagePatternItem(XElement element, SettingsFile origin) : base(element, origin) { }
internal void SetNextFile(SettingsFile settingsFile) { Next = settingsFile; Priority = settingsFile.Priority - 1; }
internal static SettingBase Parse(XNode node, SettingsFile origin) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (node is XText textNode) { return(new SettingText(textNode, origin)); } if (node is XElement element) { var elementType = SettingElementType.Unknown; Enum.TryParse(element.Name.LocalName, ignoreCase: true, result: out elementType); var parentType = SettingElementType.Unknown; if (element.Parent != null) { Enum.TryParse(element.Parent?.Name.LocalName, ignoreCase: true, result: out parentType); } switch (parentType) { case SettingElementType.Configuration: return(new ParsedSettingSection(element, origin)); case SettingElementType.PackageSourceCredentials: return(new CredentialsItem(element, origin)); case SettingElementType.PackageSources: if (elementType == SettingElementType.Add) { return(new SourceItem(element, origin)); } break; } switch (elementType) { case SettingElementType.Add: return(new AddItem(element, origin)); case SettingElementType.Author: return(new AuthorItem(element, origin)); case SettingElementType.Certificate: return(new CertificateItem(element, origin)); case SettingElementType.Clear: return(new ClearItem(element, origin)); case SettingElementType.Owners: return(new OwnersItem(element, origin)); case SettingElementType.Repository: return(new RepositoryItem(element, origin)); } return(new UnknownItem(element, origin)); } return(null); }
internal NamespaceItem(XElement element, SettingsFile origin) : base(element, origin) { }
internal ClientCertItem(XElement element, SettingsFile origin) : base(element, origin) { }