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)
{
}