Skip to content

Set command side-effect category for WithRetry #540

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mgravell merged 3 commits into from
Jul 31, 2026
Merged

Set command side-effect category for WithRetry #540

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
452106e
Declare a side-effect category for every command, for SE.Redis WithRetry
mgravell Jul 31, 2026
0e5ad77
handle complex command-category on TS.ADD
mgravell Jul 31, 2026
cc8dbe9
reclassify some of the ops
mgravell Jul 31, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 12 additions & 11 deletions src/NRedisStack/Auxiliary.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -61,35 +61,33 @@ internal static void SetInfoInPipeline(this IDatabase db)
}
}

#if DEBUG
private const CommandFlags Flags = CommandFlags.NoRedirect; // disable redirect, so we spot -MOVED in tests
#else
private const CommandFlags Flags = CommandFlags.None;
#endif
public static RedisResult Execute(this IDatabase db, SerializedCommand command)
{
db.SetInfoInPipeline();
return db.Execute(command.Command, command.Args, flags: Flags);
return db.Execute(command.Command, command.Args, flags: command.EffectiveFlags);
}

internal static RedisResult Execute(this IServer server, int? db, SerializedCommand command)
{
return server.Execute(db, command.Command, command.Args, flags: Flags);
return server.Execute(db, command.Command, command.Args, flags: command.EffectiveFlags);
}

public static async Task<RedisResult> ExecuteAsync(this IDatabaseAsync db, SerializedCommand command)
{
((IDatabase)db).SetInfoInPipeline();
return await db.ExecuteAsync(command.Command, command.Args, flags: Flags);
return await db.ExecuteAsync(command.Command, command.Args, flags: command.EffectiveFlags);
}

internal static async Task<RedisResult> ExecuteAsync(this IServer server, int? db, SerializedCommand command)
{
return await server.ExecuteAsync(db, command.Command, command.Args, flags: Flags);
return await server.ExecuteAsync(db, command.Command, command.Args, flags: command.EffectiveFlags);
}

public static List<RedisResult> ExecuteBroadcast(this IDatabase db, string command)
=> db.ExecuteBroadcast(new SerializedCommand(command));
=> db.ExecuteBroadcast(SerializedCommand.Uncategorized(command));

public static List<RedisResult> ExecuteBroadcast(this IDatabase db, CommandFlags category, string command)
=> db.ExecuteBroadcast(new SerializedCommand(category, command));

public static List<RedisResult> ExecuteBroadcast(this IDatabase db, SerializedCommand command)
{
Expand All @@ -113,7 +111,10 @@ public static List<RedisResult> ExecuteBroadcast(this IDatabase db, SerializedCo
}

public static async Task<List<RedisResult>> ExecuteBroadcastAsync(this IDatabaseAsync db, string command)
=> await db.ExecuteBroadcastAsync(new SerializedCommand(command));
=> await db.ExecuteBroadcastAsync(SerializedCommand.Uncategorized(command));

public static async Task<List<RedisResult>> ExecuteBroadcastAsync(this IDatabaseAsync db, CommandFlags category, string command)
=> await db.ExecuteBroadcastAsync(new SerializedCommand(category, command));

private static async Task<List<RedisResult>> ExecuteBroadcastAsync(this IDatabaseAsync db, SerializedCommand command)
{
Expand Down
20 changes: 10 additions & 10 deletions src/NRedisStack/Bloom/BloomCommandBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,22 +7,22 @@ public static class BloomCommandBuilder
{
public static SerializedCommand Add(RedisKey key, RedisValue item)
{
return new(BF.ADD, key, item);
return new(CommandCategories.WriteChecked, BF.ADD, key, item);
}

public static SerializedCommand Card(RedisKey key)
{
return new(BF.CARD, key);
return new(CommandCategories.ReadOnly, BF.CARD, key);
}

public static SerializedCommand Exists(RedisKey key, RedisValue item)
{
return new(BF.EXISTS, key, item);
return new(CommandCategories.ReadOnly, BF.EXISTS, key, item);
}

public static SerializedCommand Info(RedisKey key)
{
return new(BF.INFO, key);
return new(CommandCategories.ReadOnly, BF.INFO, key);
}

public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? capacity = null,
Expand All @@ -34,12 +34,12 @@ public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? ca

var args = BloomAux.BuildInsertArgs(key, items, capacity, error, expansion, nocreate, nonscaling);

return new(BF.INSERT, args);
return new(CommandCategories.WriteChecked, BF.INSERT, args);
}

public static SerializedCommand LoadChunk(RedisKey key, long iterator, Byte[] data)
{
return new(BF.LOADCHUNK, key, iterator, data);
return new(CommandCategories.WriteAccumulating, BF.LOADCHUNK, key, iterator, data);
}

public static SerializedCommand MAdd(RedisKey key, params RedisValue[] items)
Expand All @@ -50,7 +50,7 @@ public static SerializedCommand MAdd(RedisKey key, params RedisValue[] items)
List<object> args = [key];
args.AddRange(items.Cast<object>());

return new(BF.MADD, args);
return new(CommandCategories.WriteChecked, BF.MADD, args);
}

public static SerializedCommand MExists(RedisKey key, RedisValue[] items)
Expand All @@ -61,7 +61,7 @@ public static SerializedCommand MExists(RedisKey key, RedisValue[] items)
List<object> args = [key];
args.AddRange(items.Cast<object>());

return new(BF.MEXISTS, args);
return new(CommandCategories.ReadOnly, BF.MEXISTS, args);

}

Expand All @@ -80,11 +80,11 @@ public static SerializedCommand Reserve(RedisKey key, double errorRate, long cap
args.Add(BloomArgs.NONSCALING);
}

return new(BF.RESERVE, args);
return new(CommandCategories.WriteAccumulating, BF.RESERVE, args);
}

public static SerializedCommand ScanDump(RedisKey key, long iterator)
{
return new(BF.SCANDUMP, key, iterator);
return new(CommandCategories.ReadOnly | CommandCategories.ServerSpecific, BF.SCANDUMP, key, iterator);
}
}
18 changes: 10 additions & 8 deletions src/NRedisStack/CoreCommands/CoreCommandBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,8 @@ public static SerializedCommand ClientSetInfo(SetInfoAttr attr, string value)
_ => throw new ArgumentOutOfRangeException(nameof(attr)),
};

return new(RedisCoreCommands.CLIENT, RedisCoreCommands.SETINFO, attrValue, value);
// as SE.Redis categorizes CLIENT: connection-scoped, and scoped to *this* connection's server
return new(CommandCategories.Connection | CommandCategories.ServerSpecific, RedisCoreCommands.CLIENT, RedisCoreCommands.SETINFO, attrValue, value);
}

public static SerializedCommand BZMPop(double timeout, RedisKey[] keys, MinMaxModifier minMaxModifier, long? count)
Expand All @@ -43,7 +44,7 @@ public static SerializedCommand BZMPop(double timeout, RedisKey[] keys, MinMaxMo
args.Add(count);
}

return new(RedisCoreCommands.BZMPOP, args);
return new(CommandCategories.WriteAccumulating, RedisCoreCommands.BZMPOP, args);
}

public static SerializedCommand BZPopMin(RedisKey[] keys, double timeout)
Expand Down Expand Up @@ -78,7 +79,7 @@ public static SerializedCommand BLMPop(double timeout, RedisKey[] keys, ListSide
args.Add(count);
}

return new(RedisCoreCommands.BLMPOP, args);
return new(CommandCategories.WriteAccumulating, RedisCoreCommands.BLMPOP, args);
}

public static SerializedCommand BLPop(RedisKey[] keys, double timeout)
Expand All @@ -102,7 +103,7 @@ public static SerializedCommand BLMove(RedisKey source, RedisKey destination, Li
timeout
];

return new(RedisCoreCommands.BLMOVE, args);
return new(CommandCategories.WriteAccumulating, RedisCoreCommands.BLMOVE, args);
}

public static SerializedCommand BRPopLPush(RedisKey source, RedisKey destination, double timeout)
Expand All @@ -114,7 +115,7 @@ public static SerializedCommand BRPopLPush(RedisKey source, RedisKey destination
timeout
];

return new(RedisCoreCommands.BRPOPLPUSH, args);
return new(CommandCategories.WriteAccumulating, RedisCoreCommands.BRPOPLPUSH, args);
}

public static SerializedCommand XRead(RedisKey[] keys, RedisValue[] positions, int? count, int? timeoutMilliseconds)
Expand Down Expand Up @@ -147,7 +148,7 @@ public static SerializedCommand XRead(RedisKey[] keys, RedisValue[] positions, i
args.AddRange(keys.Cast<object>());
args.AddRange(positions.Cast<object>());

return new(RedisCoreCommands.XREAD, args);
return new(CommandCategories.ReadOnly, RedisCoreCommands.XREAD, args);
}

public static SerializedCommand XReadGroup(RedisValue groupName, RedisValue consumerName, RedisKey[] keys, RedisValue[] positions, int? count, int? timeoutMilliseconds, bool? noAcknowledge)
Expand Down Expand Up @@ -190,7 +191,7 @@ public static SerializedCommand XReadGroup(RedisValue groupName, RedisValue cons
args.AddRange(keys.Cast<object>());
args.AddRange(positions.Cast<object>());

return new(RedisCoreCommands.XREADGROUP, args);
return new(CommandCategories.WriteAccumulating, RedisCoreCommands.XREADGROUP, args);
}

private static SerializedCommand BlockingCommandWithKeysAndTimeout(String command, RedisKey[] keys, double timeout)
Expand All @@ -204,6 +205,7 @@ private static SerializedCommand BlockingCommandWithKeysAndTimeout(String comman
args.AddRange(keys.Cast<object>());
args.Add(timeout);

return new(command, args);
// destructive reads: a replay pops a further element, and the popped one is already lost
return new(CommandCategories.WriteAccumulating, command, args);
}
}
14 changes: 7 additions & 7 deletions src/NRedisStack/CountMinSketch/CmsCommandBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@ public static class CmsCommandBuilder
{
public static SerializedCommand IncrBy(RedisKey key, RedisValue item, long increment)
{
return new(CMS.INCRBY, key, item, increment);
return new(CommandCategories.WriteAccumulating, CMS.INCRBY, key, item, increment);
}

public static SerializedCommand IncrBy(RedisKey key, Tuple<RedisValue, long>[] itemIncrements)
Expand All @@ -23,23 +23,23 @@ public static SerializedCommand IncrBy(RedisKey key, Tuple<RedisValue, long>[] i
args.Add(pair.Item2);
}

return new(CMS.INCRBY, args);
return new(CommandCategories.WriteAccumulating, CMS.INCRBY, args);
}

public static SerializedCommand Info(RedisKey key)
{
var info = new SerializedCommand(CMS.INFO, key);
var info = new SerializedCommand(CommandCategories.ReadOnly, CMS.INFO, key);
return info;
}

public static SerializedCommand InitByDim(RedisKey key, long width, long depth)
{
return new(CMS.INITBYDIM, key, width, depth);
return new(CommandCategories.WriteAccumulating, CMS.INITBYDIM, key, width, depth);
}

public static SerializedCommand InitByProb(RedisKey key, double error, double probability)
{
return new(CMS.INITBYPROB, key, error, probability);
return new(CommandCategories.WriteAccumulating, CMS.INITBYPROB, key, error, probability);
}

public static SerializedCommand Merge(RedisValue destination, long numKeys, RedisValue[] source,
Expand All @@ -58,7 +58,7 @@ public static SerializedCommand Merge(RedisValue destination, long numKeys, Redi
foreach (var w in weight) args.Add(w);
}

return new(CMS.MERGE, args);
return new(CommandCategories.WriteAccumulating, CMS.MERGE, args);
}

public static SerializedCommand Query(RedisKey key, params RedisValue[] items)
Expand All @@ -69,6 +69,6 @@ public static SerializedCommand Query(RedisKey key, params RedisValue[] items)
List<object> args = [key];
foreach (var item in items) args.Add(item);

return new(CMS.QUERY, args);
return new(CommandCategories.ReadOnly, CMS.QUERY, args);
}
}
24 changes: 12 additions & 12 deletions src/NRedisStack/CuckooFilter/CuckooCommandBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,32 +8,32 @@ public static class CuckooCommandBuilder

public static SerializedCommand Add(RedisKey key, RedisValue item)
{
return new(CF.ADD, key, item);
return new(CommandCategories.WriteAccumulating, CF.ADD, key, item);
}

public static SerializedCommand AddNX(RedisKey key, RedisValue item)
{
return new(CF.ADDNX, key, item);
return new(CommandCategories.WriteChecked, CF.ADDNX, key, item);
}

public static SerializedCommand Count(RedisKey key, RedisValue item)
{
return new(CF.COUNT, key, item);
return new(CommandCategories.ReadOnly, CF.COUNT, key, item);
}

public static SerializedCommand Del(RedisKey key, RedisValue item)
{
return new(CF.DEL, key, item);
return new(CommandCategories.WriteAccumulating, CF.DEL, key, item);
}

public static SerializedCommand Exists(RedisKey key, RedisValue item)
{
return new(CF.EXISTS, key, item);
return new(CommandCategories.ReadOnly, CF.EXISTS, key, item);
}

public static SerializedCommand Info(RedisKey key)
{
var info = new SerializedCommand(CF.INFO, key);
var info = new SerializedCommand(CommandCategories.ReadOnly, CF.INFO, key);
return info;
}

Expand Down Expand Up @@ -61,7 +61,7 @@ public static SerializedCommand Insert(RedisKey key, RedisValue[] items, int? ca
args.Add(item);
}

return new(CF.INSERT, args);
return new(CommandCategories.WriteAccumulating, CF.INSERT, args);
}

public static SerializedCommand InsertNX(RedisKey key, RedisValue[] items, int? capacity = null, bool nocreate = false)
Expand All @@ -88,12 +88,12 @@ public static SerializedCommand InsertNX(RedisKey key, RedisValue[] items, int?
args.Add(item);
}

return new(CF.INSERTNX, args);
return new(CommandCategories.WriteChecked, CF.INSERTNX, args);
}

public static SerializedCommand LoadChunk(RedisKey key, long iterator, Byte[] data)
{
return new(CF.LOADCHUNK, key, iterator, data);
return new(CommandCategories.WriteAccumulating, CF.LOADCHUNK, key, iterator, data);
}

public static SerializedCommand MExists(RedisKey key, params RedisValue[] items)
Expand All @@ -108,7 +108,7 @@ public static SerializedCommand MExists(RedisKey key, params RedisValue[] items)
args.Add(item);
}

return new(CF.MEXISTS, args);
return new(CommandCategories.ReadOnly, CF.MEXISTS, args);
}

public static SerializedCommand Reserve(RedisKey key, long capacity,
Expand All @@ -134,11 +134,11 @@ public static SerializedCommand Reserve(RedisKey key, long capacity,
args.Add(expansion);
}

return new(CF.RESERVE, args);
return new(CommandCategories.WriteAccumulating, CF.RESERVE, args);
}

public static SerializedCommand ScanDump(RedisKey key, long iterator)
{
return new(CF.SCANDUMP, key, iterator);
return new(CommandCategories.ReadOnly | CommandCategories.ServerSpecific, CF.SCANDUMP, key, iterator);
}
}
Loading
Loading