// When isPath is true, then the setting value is checked to see if it can be interpreted // as relative path. If it can, the returned value will be the full path of the relative path. // If it cannot be interpreted as relative path, the value is returned as-is. private SettingValue ReadSettingsValue(XElement element, bool isPath) { var keyAttribute = element.Attribute("key"); var valueAttribute = element.Attribute("value"); if (keyAttribute == null || String.IsNullOrEmpty(keyAttribute.Value) || valueAttribute == null) { throw new InvalidDataException(String.Format(CultureInfo.CurrentCulture, NuGetResources.UserSettings_UnableToParseConfigFile, ConfigFilePath)); } var value = valueAttribute.Value; Uri uri; if (isPath && Uri.TryCreate(value, UriKind.Relative, out uri)) { string configDirectory = Path.GetDirectoryName(ConfigFilePath); value = _fileSystem.GetFullPath(Path.Combine(configDirectory, value)); } var settingValue = new SettingValue(keyAttribute.Value, value, IsMachineWideSettings, _priority); foreach (var attribute in element.Attributes()) { // Add all attributes other than ConfigurationContants.KeyAttribute and ConfigurationContants.ValueAttribute to AdditionalValues if (!string.Equals(attribute.Name.LocalName, "key", StringComparison.Ordinal) && !string.Equals(attribute.Name.LocalName, "value", StringComparison.Ordinal)) { settingValue.AdditionalData[attribute.Name.LocalName] = attribute.Value; } } return(settingValue); }
private static int ReadProtocolVersion(SettingValue setting) { string protocolVersionString; int protocolVersion; if (setting.AdditionalData.TryGetValue(ProtocolVersionAttribute, out protocolVersionString) && int.TryParse(protocolVersionString, out protocolVersion)) { return(protocolVersion); } return(PackageSource.DefaultProtocolVersion); }
private PackageSource ReadPackageSource(SettingValue setting, bool isEnabled) { var name = setting.Key; var packageSource = new PackageSource(setting.Value, name, isEnabled) { IsMachineWide = setting.IsMachineWide }; var credentials = ReadCredential(name); if (credentials != null) { packageSource.UserName = credentials.Username; packageSource.Password = credentials.Password; packageSource.IsPasswordClearText = credentials.IsPasswordClearText; } packageSource.ProtocolVersion = ReadProtocolVersion(setting); return(packageSource); }
public void SetFakeActivePackageSource(PackageSource packageSource) { ActivePackageSourceSettings.Clear(); var setting = new SettingValue(packageSource.Name, packageSource.Source, false); ActivePackageSourceSettings.Add(setting); }
public void AddFakePackageSource(PackageSource packageSource) { var setting = new SettingValue (packageSource.Name, packageSource.Source, false); PackageSources.Add(setting); }
static PackageSource CreatePackageSourceFromSetting(SettingValue savedPackageSource) { string source = savedPackageSource.Value; string name = savedPackageSource.Key; return new PackageSource(source, name); }
public void AddFakePackageSource (PackageSource packageSource) { var valuePair = new SettingValue (packageSource.Name, packageSource.Source, false); PackageSources.Add (valuePair); }
public override bool Equals(object obj) { SettingValue value2 = obj as SettingValue; return((value2 != null) ? ((value2.Key == this.Key) && ((value2.Value == this.Value) && (value2.IsMachineWide == value2.IsMachineWide))) : false); }
public void ActivePackageSource_SourceChanged_ActivePackageSourceUpdatedInSettings () { CreateOptions (); var packageSource = new PackageSource ("http://sharpdevelop.com", "Test"); options.ActivePackageSource = packageSource; var expectedSetting = new SettingValue ("Test", "http://sharpdevelop.com", false); SettingValue actualSetting = fakeSettings.GetValuePassedToSetValueForActivePackageSourceSection (); Assert.AreEqual (expectedSetting, actualSetting); }
public void SavePackageSources(IEnumerable <PackageSource> sources) { // clear the old values // and write the new ones var sourcesToWrite = sources.Where(s => !s.IsMachineWide); var existingSettings = (_settingsManager.GetValues(PackageSourcesSectionName, isPath: true) ?? Enumerable.Empty <SettingValue>()).Where(setting => !setting.IsMachineWide).ToList(); var existingSettingsLookup = existingSettings.ToLookup(setting => setting.Key, StringComparer.OrdinalIgnoreCase); var existingDisabledSources = _settingsManager.GetValues(DisabledPackageSourcesSectionName, isPath: false) ?? Enumerable.Empty <SettingValue>(); var existingDisabledSourcesLookup = existingDisabledSources.ToLookup(setting => setting.Key, StringComparer.OrdinalIgnoreCase); var sourceSettings = new List <SettingValue>(); var sourcesToDisable = new List <SettingValue>(); foreach (var source in sourcesToWrite) { var foundSettingWithSourcePriority = false; var settingPriority = 0; var existingSettingForSource = existingSettingsLookup[source.Name]; // Preserve packageSource entries from low priority settings. foreach (var existingSetting in existingSettingForSource) { settingPriority = Math.Max(settingPriority, existingSetting.Priority); // Write all settings other than the currently written one to the current NuGet.config. if (ReadProtocolVersion(existingSetting) == source.ProtocolVersion) { // Update the source value of all settings with the same protocol version. existingSetting.Value = source.Source; foundSettingWithSourcePriority = true; } sourceSettings.Add(existingSetting); } if (!foundSettingWithSourcePriority) { // This is a new source, add it to the Setting with the lowest priority. var settingValue = new SettingValue(source.Name, source.Source, isMachineWide: false); if (source.ProtocolVersion != PackageSource.DefaultProtocolVersion) { settingValue.AdditionalData[ProtocolVersionAttribute] = source.ProtocolVersion.ToString(CultureInfo.InvariantCulture); } sourceSettings.Add(settingValue); } // settingValue contains the setting with the highest priority. var existingDisabledSettings = existingDisabledSourcesLookup[source.Name]; // Preserve disabledPackageSource entries from low priority settings. foreach (var setting in existingDisabledSettings.Where(s => s.Priority < settingPriority)) { sourcesToDisable.Add(setting); } if (!source.IsEnabled) { // Add an entry to the disabledPackageSource in the file that contains sourcesToDisable.Add(new SettingValue(source.Name, "true", isMachineWide: false, priority: settingPriority)); } } // Re-add all settings with a higher protocol version that weren't listed. Skip any settings where the source is // already being written and any setting with any source with a protocol version < 2 (the max supported version). // The latter indicates a deleted source. var sourcesWithHigherProtocolVersion = existingSettingsLookup .Where(item => !sourcesToWrite.Any(s => string.Equals(s.Name, item.Key, StringComparison.OrdinalIgnoreCase)) && !item.Any(s => ReadProtocolVersion(s) <= MaxSupportedProtocolVersion)) .SelectMany(s => s); sourceSettings.AddRange(sourcesWithHigherProtocolVersion); // Add disabled machine wide sources foreach (var source in sources.Where(s => s.IsMachineWide && !s.IsEnabled)) { sourcesToDisable.Add(new SettingValue(source.Name, "true", isMachineWide: false)); } // Write the updates to the nearest settings file. _settingsManager.UpdateSections(PackageSourcesSectionName, sourceSettings); // overwrite new values for the <disabledPackageSources> section _settingsManager.UpdateSections(DisabledPackageSourcesSectionName, sourcesToDisable); // Overwrite the <packageSourceCredentials> section _settingsManager.DeleteSection(CredentialsSectionName); var sourceWithCredentials = sources.Where(s => !String.IsNullOrEmpty(s.UserName) && !String.IsNullOrEmpty(s.Password)); foreach (var source in sourceWithCredentials) { _settingsManager.SetNestedValues(CredentialsSectionName, source.Name, new[] { new KeyValuePair <string, string>(UsernameToken, source.UserName), ReadPasswordValues(source) }); } }