Skip to content

Commit c0cf2dd

Browse files
MpdreamzMpdreamz
authored
fix elastic#3019, converter should not nullify know keys in the base dictionary (elastic#3038)
1 parent bb57b58 commit c0cf2dd

File tree

2 files changed

+106
-96
lines changed

2 files changed

+106
-96
lines changed

‎src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs‎

Lines changed: 97 additions & 91 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
using System.Linq;
55
using Newtonsoft.Json;
66
using Newtonsoft.Json.Linq;
7+
using static Nest.UpdatableIndexSettings;
78

89
namespace Nest
910
{
@@ -20,76 +21,81 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
2021
if (ds == null) return;
2122
IDictionary<string,object> d = ds;
2223

23-
d[UpdatableIndexSettings.NumberOfReplicas] = ds.NumberOfReplicas;
24-
d[UpdatableIndexSettings.AutoExpandReplicas] = ds.AutoExpandReplicas;
25-
d[UpdatableIndexSettings.RefreshInterval] = ds.RefreshInterval;
26-
d[UpdatableIndexSettings.BlocksReadOnly] = ds.BlocksReadOnly;
27-
d[UpdatableIndexSettings.BlocksRead] = ds.BlocksRead;
28-
d[UpdatableIndexSettings.BlocksWrite] = ds.BlocksWrite;
29-
d[UpdatableIndexSettings.BlocksMetadata] = ds.BlocksMetadata;
30-
d[UpdatableIndexSettings.Priority] = ds.Priority;
31-
d[UpdatableIndexSettings.RecoveryInitialShards] = ds.RecoveryInitialShards;
32-
d[UpdatableIndexSettings.RequestsCacheEnable] = ds.RequestsCacheEnabled;
33-
d[UpdatableIndexSettings.RoutingAllocationTotalShardsPerNode] = ds.RoutingAllocationTotalShardsPerNode;
34-
d[UpdatableIndexSettings.UnassignedNodeLeftDelayedTimeout] = ds.UnassignedNodeLeftDelayedTimeout;
24+
void Set(string knownKey, object newValue)
25+
{
26+
if (newValue != null) d[knownKey] = newValue;
27+
}
28+
29+
Set(NumberOfReplicas, ds.NumberOfReplicas);
30+
Set(RefreshInterval, ds.RefreshInterval);
31+
Set(BlocksReadOnly, ds.BlocksReadOnly);
32+
Set(BlocksRead, ds.BlocksRead);
33+
Set(BlocksWrite, ds.BlocksWrite);
34+
Set(BlocksMetadata, ds.BlocksMetadata);
35+
Set(Priority, ds.Priority);
36+
Set(UpdatableIndexSettings.AutoExpandReplicas, ds.AutoExpandReplicas);
37+
Set(UpdatableIndexSettings.RecoveryInitialShards, ds.RecoveryInitialShards);
38+
Set(RequestsCacheEnable, ds.RequestsCacheEnabled);
39+
Set(RoutingAllocationTotalShardsPerNode, ds.RoutingAllocationTotalShardsPerNode);
40+
Set(UnassignedNodeLeftDelayedTimeout, ds.UnassignedNodeLeftDelayedTimeout);
3541

3642
var translog = ds.Translog;
37-
d[UpdatableIndexSettings.TranslogSyncInterval] = translog?.SyncInterval;
38-
d[UpdatableIndexSettings.TranslogDurability] = translog?.Durability;
43+
Set(TranslogSyncInterval, translog?.SyncInterval);
44+
Set(UpdatableIndexSettings.TranslogDurability, translog?.Durability);
3945

4046
var flush = ds.Translog?.Flush;
41-
d[UpdatableIndexSettings.TranslogFlushThresholdSize] = flush?.ThresholdSize;
42-
d[UpdatableIndexSettings.TranslogFlushThresholdPeriod] = flush?.ThresholdPeriod;
47+
Set(TranslogFlushThresholdSize, flush?.ThresholdSize);
48+
Set(TranslogFlushThresholdPeriod, flush?.ThresholdPeriod);
4349

44-
d[UpdatableIndexSettings.MergePolicyExpungeDeletesAllowed] = ds.Merge?.Policy?.ExpungeDeletesAllowed;
45-
d[UpdatableIndexSettings.MergePolicyFloorSegment] = ds.Merge?.Policy?.FloorSegment;
46-
d[UpdatableIndexSettings.MergePolicyMaxMergeAtOnce] = ds.Merge?.Policy?.MaxMergeAtOnce;
47-
d[UpdatableIndexSettings.MergePolicyMaxMergeAtOnceExplicit] = ds.Merge?.Policy?.MaxMergeAtOnceExplicit;
48-
d[UpdatableIndexSettings.MergePolicyMaxMergedSegment] = ds.Merge?.Policy?.MaxMergedSegment;
49-
d[UpdatableIndexSettings.MergePolicySegmentsPerTier] = ds.Merge?.Policy?.SegmentsPerTier;
50-
d[UpdatableIndexSettings.MergePolicyReclaimDeletesWeight] = ds.Merge?.Policy?.ReclaimDeletesWeight;
50+
Set(MergePolicyExpungeDeletesAllowed, ds.Merge?.Policy?.ExpungeDeletesAllowed);
51+
Set(MergePolicyFloorSegment, ds.Merge?.Policy?.FloorSegment);
52+
Set(MergePolicyMaxMergeAtOnce, ds.Merge?.Policy?.MaxMergeAtOnce);
53+
Set(MergePolicyMaxMergeAtOnceExplicit, ds.Merge?.Policy?.MaxMergeAtOnceExplicit);
54+
Set(MergePolicyMaxMergedSegment, ds.Merge?.Policy?.MaxMergedSegment);
55+
Set(MergePolicySegmentsPerTier, ds.Merge?.Policy?.SegmentsPerTier);
56+
Set(MergePolicyReclaimDeletesWeight, ds.Merge?.Policy?.ReclaimDeletesWeight);
5157

52-
d[UpdatableIndexSettings.MergeSchedulerMaxThreadCount] = ds.Merge?.Scheduler?.MaxThreadCount;
53-
d[UpdatableIndexSettings.MergeSchedulerAutoThrottle] = ds.Merge?.Scheduler?.AutoThrottle;
58+
Set(MergeSchedulerMaxThreadCount, ds.Merge?.Scheduler?.MaxThreadCount);
59+
Set(MergeSchedulerAutoThrottle, ds.Merge?.Scheduler?.AutoThrottle);
5460

5561
var log = ds.SlowLog;
5662
var search = log?.Search;
5763
var indexing = log?.Indexing;
5864

59-
d[UpdatableIndexSettings.SlowlogSearchThresholdQueryWarn] = search?.Query?.ThresholdWarn;
60-
d[UpdatableIndexSettings.SlowlogSearchThresholdQueryInfo] = search?.Query?.ThresholdInfo;
61-
d[UpdatableIndexSettings.SlowlogSearchThresholdQueryDebug] = search?.Query?.ThresholdDebug;
62-
d[UpdatableIndexSettings.SlowlogSearchThresholdQueryTrace] = search?.Query?.ThresholdTrace;
65+
Set(SlowlogSearchThresholdQueryWarn, search?.Query?.ThresholdWarn);
66+
Set(SlowlogSearchThresholdQueryInfo, search?.Query?.ThresholdInfo);
67+
Set(SlowlogSearchThresholdQueryDebug, search?.Query?.ThresholdDebug);
68+
Set(SlowlogSearchThresholdQueryTrace, search?.Query?.ThresholdTrace);
6369

64-
d[UpdatableIndexSettings.SlowlogSearchThresholdFetchWarn] = search?.Fetch?.ThresholdWarn;
65-
d[UpdatableIndexSettings.SlowlogSearchThresholdFetchInfo] = search?.Fetch?.ThresholdInfo;
66-
d[UpdatableIndexSettings.SlowlogSearchThresholdFetchDebug] = search?.Fetch?.ThresholdDebug;
67-
d[UpdatableIndexSettings.SlowlogSearchThresholdFetchTrace] = search?.Fetch?.ThresholdTrace;
68-
d[UpdatableIndexSettings.SlowlogSearchLevel] = search?.LogLevel;
70+
Set(SlowlogSearchThresholdFetchWarn, search?.Fetch?.ThresholdWarn);
71+
Set(SlowlogSearchThresholdFetchInfo, search?.Fetch?.ThresholdInfo);
72+
Set(SlowlogSearchThresholdFetchDebug, search?.Fetch?.ThresholdDebug);
73+
Set(SlowlogSearchThresholdFetchTrace, search?.Fetch?.ThresholdTrace);
74+
Set(SlowlogSearchLevel, search?.LogLevel);
6975

70-
d[UpdatableIndexSettings.SlowlogIndexingThresholdFetchWarn] = indexing?.ThresholdWarn;
71-
d[UpdatableIndexSettings.SlowlogIndexingThresholdFetchInfo] = indexing?.ThresholdInfo;
72-
d[UpdatableIndexSettings.SlowlogIndexingThresholdFetchDebug] = indexing?.ThresholdDebug;
73-
d[UpdatableIndexSettings.SlowlogIndexingThresholdFetchTrace] = indexing?.ThresholdTrace;
74-
d[UpdatableIndexSettings.SlowlogIndexingLevel] = indexing?.LogLevel;
75-
d[UpdatableIndexSettings.SlowlogIndexingSource] = indexing?.Source;
76+
Set(SlowlogIndexingThresholdFetchWarn, indexing?.ThresholdWarn);
77+
Set(SlowlogIndexingThresholdFetchInfo, indexing?.ThresholdInfo);
78+
Set(SlowlogIndexingThresholdFetchDebug, indexing?.ThresholdDebug);
79+
Set(SlowlogIndexingThresholdFetchTrace, indexing?.ThresholdTrace);
80+
Set(SlowlogIndexingLevel, indexing?.LogLevel);
81+
Set(SlowlogIndexingSource, indexing?.Source);
7682

77-
d[UpdatableIndexSettings.Analysis] = ds.Analysis;
78-
d[UpdatableIndexSettings.Similarity] = ds.Similarity;
83+
Set(UpdatableIndexSettings.Analysis, ds.Analysis);
84+
Set(Similarity, ds.Similarity);
7985

8086
var indexSettings = value as IIndexSettings;
8187

82-
d[FixedIndexSettings.NumberOfShards] = indexSettings?.NumberOfShards;
83-
d[FixedIndexSettings.RoutingPartitionSize] = indexSettings?.RoutingPartitionSize;
84-
d[UpdatableIndexSettings.StoreType] = indexSettings?.FileSystemStorageImplementation;
85-
d[UpdatableIndexSettings.QueriesCacheEnabled] = indexSettings?.Queries?.Cache?.Enabled;
88+
Set(StoreType, indexSettings?.FileSystemStorageImplementation);
89+
Set(QueriesCacheEnabled, indexSettings?.Queries?.Cache?.Enabled);
90+
Set(FixedIndexSettings.NumberOfShards, indexSettings?.NumberOfShards);
91+
Set(FixedIndexSettings.RoutingPartitionSize, indexSettings?.RoutingPartitionSize);
8692

8793
if (indexSettings?.Sorting != null)
8894
{
89-
d[IndexSortSettings.Fields] = AsArrayOrSingleItem(indexSettings.Sorting.Fields);
90-
d[IndexSortSettings.Order] = AsArrayOrSingleItem(indexSettings.Sorting.Order);
91-
d[IndexSortSettings.Mode] = AsArrayOrSingleItem(indexSettings.Sorting.Mode);
92-
d[IndexSortSettings.Missing] = AsArrayOrSingleItem(indexSettings.Sorting.Missing);
95+
Set(IndexSortSettings.Fields, AsArrayOrSingleItem(indexSettings.Sorting.Fields));
96+
Set(IndexSortSettings.Order, AsArrayOrSingleItem(indexSettings.Sorting.Order));
97+
Set(IndexSortSettings.Mode, AsArrayOrSingleItem(indexSettings.Sorting.Mode));
98+
Set(IndexSortSettings.Missing, AsArrayOrSingleItem(indexSettings.Sorting.Missing));
9399
}
94100

95101
base.WriteJson(writer, d, serializer);
@@ -123,7 +129,7 @@ private static JObject Flatten(JObject original, string prefix = "", JObject new
123129
{
124130
if (property.Value is JObject &&
125131
property.Name != UpdatableIndexSettings.Analysis &&
126-
property.Name != UpdatableIndexSettings.Similarity)
132+
property.Name != Similarity)
127133
Flatten(property.Value.Value<JObject>(), prefix + property.Name + ".", newObject);
128134
else newObject.Add(prefix + property.Name, property.Value);
129135
}
@@ -134,77 +140,77 @@ private static void SetKnownIndexSettings(JsonReader reader, JsonSerializer seri
134140
{
135141
var settings = Flatten(JObject.Load(reader)).Properties().ToDictionary(kv => kv.Name);
136142

137-
Set<int?>(s, settings, UpdatableIndexSettings.NumberOfReplicas, v => s.NumberOfReplicas = v);
143+
Set<int?>(s, settings, NumberOfReplicas, v => s.NumberOfReplicas = v);
138144
Set<AutoExpandReplicas>(s, settings, UpdatableIndexSettings.AutoExpandReplicas, v => s.AutoExpandReplicas = v);
139-
Set<Time>(s, settings, UpdatableIndexSettings.RefreshInterval, v => s.RefreshInterval = v);
140-
Set<bool?>(s, settings, UpdatableIndexSettings.BlocksReadOnly, v => s.BlocksReadOnly = v);
141-
Set<bool?>(s, settings, UpdatableIndexSettings.BlocksRead, v => s.BlocksRead = v);
142-
Set<bool?>(s, settings, UpdatableIndexSettings.BlocksWrite, v => s.BlocksWrite = v);
143-
Set<bool?>(s, settings, UpdatableIndexSettings.BlocksMetadata, v => s.BlocksMetadata = v);
144-
Set<int?>(s, settings, UpdatableIndexSettings.Priority, v => s.Priority = v);
145+
Set<Time>(s, settings, RefreshInterval, v => s.RefreshInterval = v);
146+
Set<bool?>(s, settings, BlocksReadOnly, v => s.BlocksReadOnly = v);
147+
Set<bool?>(s, settings, BlocksRead, v => s.BlocksRead = v);
148+
Set<bool?>(s, settings, BlocksWrite, v => s.BlocksWrite = v);
149+
Set<bool?>(s, settings, BlocksMetadata, v => s.BlocksMetadata = v);
150+
Set<int?>(s, settings, Priority, v => s.Priority = v);
145151
Set<Union<int, RecoveryInitialShards>>(s, settings, UpdatableIndexSettings.RecoveryInitialShards,
146152
v => s.RecoveryInitialShards = v, serializer);
147-
Set<bool?>(s, settings, UpdatableIndexSettings.RequestsCacheEnable, v => s.RequestsCacheEnabled = v);
148-
Set<int?>(s, settings, UpdatableIndexSettings.RoutingAllocationTotalShardsPerNode,
153+
Set<bool?>(s, settings, RequestsCacheEnable, v => s.RequestsCacheEnabled = v);
154+
Set<int?>(s, settings, RoutingAllocationTotalShardsPerNode,
149155
v => s.RoutingAllocationTotalShardsPerNode = v);
150-
Set<Time>(s, settings, UpdatableIndexSettings.UnassignedNodeLeftDelayedTimeout,
156+
Set<Time>(s, settings, UnassignedNodeLeftDelayedTimeout,
151157
v => s.UnassignedNodeLeftDelayedTimeout = v);
152158

153159
var t = s.Translog = new TranslogSettings();
154-
Set<Time>(s, settings, UpdatableIndexSettings.TranslogSyncInterval, v => t.SyncInterval = v);
160+
Set<Time>(s, settings, TranslogSyncInterval, v => t.SyncInterval = v);
155161
Set<TranslogDurability?>(s, settings, UpdatableIndexSettings.TranslogDurability, v => t.Durability = v);
156162

157163
var tf = s.Translog.Flush = new TranslogFlushSettings();
158-
Set<string>(s, settings, UpdatableIndexSettings.TranslogFlushThresholdSize, v => tf.ThresholdSize = v);
159-
Set<Time>(s, settings, UpdatableIndexSettings.TranslogFlushThresholdPeriod, v => tf.ThresholdPeriod = v);
164+
Set<string>(s, settings, TranslogFlushThresholdSize, v => tf.ThresholdSize = v);
165+
Set<Time>(s, settings, TranslogFlushThresholdPeriod, v => tf.ThresholdPeriod = v);
160166

161167
s.Merge = new MergeSettings();
162168
var p = s.Merge.Policy = new MergePolicySettings();
163-
Set<int?>(s, settings, UpdatableIndexSettings.MergePolicyExpungeDeletesAllowed, v => p.ExpungeDeletesAllowed = v);
164-
Set<string>(s, settings, UpdatableIndexSettings.MergePolicyFloorSegment, v => p.FloorSegment = v);
165-
Set<int?>(s, settings, UpdatableIndexSettings.MergePolicyMaxMergeAtOnce, v => p.MaxMergeAtOnce = v);
166-
Set<int?>(s, settings, UpdatableIndexSettings.MergePolicyMaxMergeAtOnceExplicit, v => p.MaxMergeAtOnceExplicit = v);
167-
Set<string>(s, settings, UpdatableIndexSettings.MergePolicyMaxMergedSegment, v => p.MaxMergedSegment = v);
168-
Set<int?>(s, settings, UpdatableIndexSettings.MergePolicySegmentsPerTier, v => p.SegmentsPerTier = v);
169-
Set<double?>(s, settings, UpdatableIndexSettings.MergePolicyReclaimDeletesWeight, v => p.ReclaimDeletesWeight = v);
169+
Set<int?>(s, settings, MergePolicyExpungeDeletesAllowed, v => p.ExpungeDeletesAllowed = v);
170+
Set<string>(s, settings, MergePolicyFloorSegment, v => p.FloorSegment = v);
171+
Set<int?>(s, settings, MergePolicyMaxMergeAtOnce, v => p.MaxMergeAtOnce = v);
172+
Set<int?>(s, settings, MergePolicyMaxMergeAtOnceExplicit, v => p.MaxMergeAtOnceExplicit = v);
173+
Set<string>(s, settings, MergePolicyMaxMergedSegment, v => p.MaxMergedSegment = v);
174+
Set<int?>(s, settings, MergePolicySegmentsPerTier, v => p.SegmentsPerTier = v);
175+
Set<double?>(s, settings, MergePolicyReclaimDeletesWeight, v => p.ReclaimDeletesWeight = v);
170176

171177
var ms = s.Merge.Scheduler = new MergeSchedulerSettings();
172-
Set<int?>(s, settings, UpdatableIndexSettings.MergeSchedulerMaxThreadCount, v => ms.MaxThreadCount = v);
173-
Set<bool?>(s, settings, UpdatableIndexSettings.MergeSchedulerAutoThrottle, v => ms.AutoThrottle = v);
178+
Set<int?>(s, settings, MergeSchedulerMaxThreadCount, v => ms.MaxThreadCount = v);
179+
Set<bool?>(s, settings, MergeSchedulerAutoThrottle, v => ms.AutoThrottle = v);
174180

175181
var slowlog = s.SlowLog = new SlowLog();
176182
var search = s.SlowLog.Search = new SlowLogSearch();
177-
Set<LogLevel?>(s, settings, UpdatableIndexSettings.SlowlogSearchLevel, v => search.LogLevel = v);
183+
Set<LogLevel?>(s, settings, SlowlogSearchLevel, v => search.LogLevel = v);
178184
var query = s.SlowLog.Search.Query = new SlowLogSearchQuery();
179-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdQueryWarn, v => query.ThresholdWarn = v);
180-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdQueryInfo, v => query.ThresholdInfo = v);
181-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdQueryDebug,
185+
Set<Time>(s, settings, SlowlogSearchThresholdQueryWarn, v => query.ThresholdWarn = v);
186+
Set<Time>(s, settings, SlowlogSearchThresholdQueryInfo, v => query.ThresholdInfo = v);
187+
Set<Time>(s, settings, SlowlogSearchThresholdQueryDebug,
182188
v => query.ThresholdDebug = v);
183-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdQueryTrace,
189+
Set<Time>(s, settings, SlowlogSearchThresholdQueryTrace,
184190
v => query.ThresholdTrace = v);
185191

186192
var fetch = s.SlowLog.Search.Fetch = new SlowLogSearchFetch();
187-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdFetchWarn, v => fetch.ThresholdWarn = v);
188-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdFetchInfo, v => fetch.ThresholdInfo = v);
189-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdFetchDebug,
193+
Set<Time>(s, settings, SlowlogSearchThresholdFetchWarn, v => fetch.ThresholdWarn = v);
194+
Set<Time>(s, settings, SlowlogSearchThresholdFetchInfo, v => fetch.ThresholdInfo = v);
195+
Set<Time>(s, settings, SlowlogSearchThresholdFetchDebug,
190196
v => fetch.ThresholdDebug = v);
191-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogSearchThresholdFetchTrace,
197+
Set<Time>(s, settings, SlowlogSearchThresholdFetchTrace,
192198
v => fetch.ThresholdTrace = v);
193199

194200
var indexing = s.SlowLog.Indexing = new SlowLogIndexing();
195-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogIndexingThresholdFetchWarn,
201+
Set<Time>(s, settings, SlowlogIndexingThresholdFetchWarn,
196202
v => indexing.ThresholdWarn = v);
197-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogIndexingThresholdFetchInfo,
203+
Set<Time>(s, settings, SlowlogIndexingThresholdFetchInfo,
198204
v => indexing.ThresholdInfo = v);
199-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogIndexingThresholdFetchDebug,
205+
Set<Time>(s, settings, SlowlogIndexingThresholdFetchDebug,
200206
v => indexing.ThresholdDebug = v);
201-
Set<Time>(s, settings, UpdatableIndexSettings.SlowlogIndexingThresholdFetchTrace,
207+
Set<Time>(s, settings, SlowlogIndexingThresholdFetchTrace,
202208
v => indexing.ThresholdTrace = v);
203-
Set<LogLevel?>(s, settings, UpdatableIndexSettings.SlowlogIndexingLevel, v => indexing.LogLevel = v);
204-
Set<int?>(s, settings, UpdatableIndexSettings.SlowlogIndexingSource, v => indexing.Source = v);
209+
Set<LogLevel?>(s, settings, SlowlogIndexingLevel, v => indexing.LogLevel = v);
210+
Set<int?>(s, settings, SlowlogIndexingSource, v => indexing.Source = v);
205211
Set<int?>(s, settings, FixedIndexSettings.NumberOfShards, v => s.NumberOfShards = v);
206212
Set<int?>(s, settings, FixedIndexSettings.RoutingPartitionSize, v => s.RoutingPartitionSize = v);
207-
Set<FileSystemStorageImplementation?>(s, settings, UpdatableIndexSettings.StoreType, v => s.FileSystemStorageImplementation = v, serializer);
213+
Set<FileSystemStorageImplementation?>(s, settings, StoreType, v => s.FileSystemStorageImplementation = v, serializer);
208214

209215
var sorting = s.Sorting = new SortingSettings();
210216
SetArray<string[], string>(s, settings, IndexSortSettings.Fields, v => sorting.Fields = v, v => sorting.Fields = new [] { v });
@@ -214,15 +220,15 @@ private static void SetKnownIndexSettings(JsonReader reader, JsonSerializer seri
214220

215221
var queries = s.Queries = new QueriesSettings();
216222
var queriesCache = s.Queries.Cache = new QueriesCacheSettings();
217-
Set<bool?>(s, settings, UpdatableIndexSettings.QueriesCacheEnabled, v => queriesCache.Enabled = v);
223+
Set<bool?>(s, settings, QueriesCacheEnabled, v => queriesCache.Enabled = v);
218224

219225
IDictionary<string,object> dict = s;
220226
foreach (var kv in settings)
221227
{
222228
var setting = kv.Value;
223229
if (kv.Key == UpdatableIndexSettings.Analysis || kv.Key == "index.analysis")
224230
s.Analysis = setting.Value.Value<JObject>().ToObject<Analysis>(serializer);
225-
if (kv.Key == UpdatableIndexSettings.Similarity || kv.Key == "index.similarity")
231+
if (kv.Key == Similarity || kv.Key == "index.similarity")
226232
s.Similarity = setting.Value.Value<JObject>().ToObject<Similarities>(serializer);
227233
else
228234
{

‎src/Tests/Indices/IndexSettings/UpdateIndicesSettings/UpdateIndexSettingsApiTests.cs‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,6 @@
55
using Tests.Framework;
66
using Tests.Framework.Integration;
77
using Tests.Framework.ManagedElasticsearch.Clusters;
8-
using Xunit;
9-
using static Nest.Infer;
108

119
namespace Tests.Indices.IndexSettings.UpdateIndicesSettings
1210
{
@@ -41,22 +39,28 @@ protected override LazyResponses ClientUsage() => Calls(
4139
protected override object ExpectJson { get; } = new Dictionary<string, object>
4240
{
4341
{ "index.blocks.write", false },
44-
{ "index.number_of_replicas", 2 }
42+
{ "index.number_of_replicas", 2 },
43+
{ "index.priority", 2 }
4544
};
4645

4746
protected override Func<UpdateIndexSettingsDescriptor, IUpdateIndexSettingsRequest> Fluent => d => d
4847
.Index(CallIsolatedValue)
4948
.IndexSettings(i => i
5049
.BlocksWrite(false)
5150
.NumberOfReplicas(2)
51+
.Priority(2)
5252
);
5353

5454
protected override UpdateIndexSettingsRequest Initializer => new UpdateIndexSettingsRequest(CallIsolatedValue)
5555
{
56-
IndexSettings = new Nest.IndexSettings
56+
IndexSettings = new Nest.IndexSettings(new Dictionary<string, object>
57+
{
58+
{ "index.number_of_replicas", 3 },
59+
{ "index.priority", 2 }
60+
})
5761
{
5862
BlocksWrite = false,
59-
NumberOfReplicas = 2
63+
NumberOfReplicas = 2, //this should win from the value provided in the base dictionary
6064
}
6165
};
6266
}

0 commit comments

Comments
 (0)