Skip to content

Commit f416e95

Browse files
mgravellmgravell
committed
initial pub/sub implementation; needs test-server support for pub/sub
1 parent 164d382 commit f416e95

26 files changed

Lines changed: 880 additions & 594 deletions

‎src/StackExchange.Redis/MultiGroupDatabase.Async.cs‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -8,59 +8,59 @@ internal sealed partial class MultiGroupDatabase
88
{
99
// Async methods - Core operations
1010
public Task<RedisValue> DebugObjectAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
11-
=> GetDatabase().DebugObjectAsync(key, flags);
11+
=> GetActiveDatabase().DebugObjectAsync(key, flags);
1212

1313
public Task<EndPoint?> IdentifyEndpointAsync(RedisKey key = default, CommandFlags flags = CommandFlags.None)
14-
=> GetDatabase().IdentifyEndpointAsync(key, flags);
14+
=> GetActiveDatabase().IdentifyEndpointAsync(key, flags);
1515

1616
public Task KeyMigrateAsync(RedisKey key, EndPoint toServer, int toDatabase = 0, int timeoutMilliseconds = 0, MigrateOptions migrateOptions = MigrateOptions.None, CommandFlags flags = CommandFlags.None)
17-
=> GetDatabase().KeyMigrateAsync(key, toServer, toDatabase, timeoutMilliseconds, migrateOptions, flags);
17+
=> GetActiveDatabase().KeyMigrateAsync(key, toServer, toDatabase, timeoutMilliseconds, migrateOptions, flags);
1818

1919
public Task<TimeSpan> PingAsync(CommandFlags flags = CommandFlags.None)
20-
=> GetDatabase().PingAsync(flags);
20+
=> GetActiveDatabase().PingAsync(flags);
2121

2222
public Task<long> PublishAsync(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None)
23-
=> GetDatabase().PublishAsync(channel, message, flags);
23+
=> GetActiveDatabase().PublishAsync(channel, message, flags);
2424

2525
public Task<RedisResult> ExecuteAsync(string command, params object[] args)
26-
=> GetDatabase().ExecuteAsync(command, args);
26+
=> GetActiveDatabase().ExecuteAsync(command, args);
2727

2828
public Task<RedisResult> ExecuteAsync(string command, System.Collections.Generic.ICollection<object>? args, CommandFlags flags = CommandFlags.None)
29-
=> GetDatabase().ExecuteAsync(command, args, flags);
29+
=> GetActiveDatabase().ExecuteAsync(command, args, flags);
3030

3131
public Task<RedisResult> ScriptEvaluateAsync(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None)
32-
=> GetDatabase().ScriptEvaluateAsync(script, keys, values, flags);
32+
=> GetActiveDatabase().ScriptEvaluateAsync(script, keys, values, flags);
3333

3434
public Task<RedisResult> ScriptEvaluateAsync(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None)
35-
=> GetDatabase().ScriptEvaluateAsync(hash, keys, values, flags);
35+
=> GetActiveDatabase().ScriptEvaluateAsync(hash, keys, values, flags);
3636

3737
public Task<RedisResult> ScriptEvaluateAsync(LuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None)
38-
=> GetDatabase().ScriptEvaluateAsync(script, parameters, flags);
38+
=> GetActiveDatabase().ScriptEvaluateAsync(script, parameters, flags);
3939

4040
public Task<RedisResult> ScriptEvaluateAsync(LoadedLuaScript script, object? parameters = null, CommandFlags flags = CommandFlags.None)
41-
=> GetDatabase().ScriptEvaluateAsync(script, parameters, flags);
41+
=> GetActiveDatabase().ScriptEvaluateAsync(script, parameters, flags);
4242

4343
public Task<RedisResult> ScriptEvaluateReadOnlyAsync(string script, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None)
44-
=> GetDatabase().ScriptEvaluateReadOnlyAsync(script, keys, values, flags);
44+
=> GetActiveDatabase().ScriptEvaluateReadOnlyAsync(script, keys, values, flags);
4545

4646
public Task<RedisResult> ScriptEvaluateReadOnlyAsync(byte[] hash, RedisKey[]? keys = null, RedisValue[]? values = null, CommandFlags flags = CommandFlags.None)
47-
=> GetDatabase().ScriptEvaluateReadOnlyAsync(hash, keys, values, flags);
47+
=> GetActiveDatabase().ScriptEvaluateReadOnlyAsync(hash, keys, values, flags);
4848

4949
public Task<bool> LockExtendAsync(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None)
50-
=> GetDatabase().LockExtendAsync(key, value, expiry, flags);
50+
=> GetActiveDatabase().LockExtendAsync(key, value, expiry, flags);
5151

5252
public Task<RedisValue> LockQueryAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
53-
=> GetDatabase().LockQueryAsync(key, flags);
53+
=> GetActiveDatabase().LockQueryAsync(key, flags);
5454

5555
public Task<bool> LockReleaseAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None)
56-
=> GetDatabase().LockReleaseAsync(key, value, flags);
56+
=> GetActiveDatabase().LockReleaseAsync(key, value, flags);
5757

5858
public Task<bool> LockTakeAsync(RedisKey key, RedisValue value, TimeSpan expiry, CommandFlags flags = CommandFlags.None)
59-
=> GetDatabase().LockTakeAsync(key, value, expiry, flags);
59+
=> GetActiveDatabase().LockTakeAsync(key, value, expiry, flags);
6060

6161
public Task<RedisValue[]> SortAsync(RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
62-
=> GetDatabase().SortAsync(key, skip, take, order, sortType, by, get, flags);
62+
=> GetActiveDatabase().SortAsync(key, skip, take, order, sortType, by, get, flags);
6363

6464
public Task<long> SortAndStoreAsync(RedisKey destination, RedisKey key, long skip = 0, long take = -1, Order order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by = default, RedisValue[]? get = null, CommandFlags flags = CommandFlags.None)
65-
=> GetDatabase().SortAndStoreAsync(destination, key, skip, take, order, sortType, by, get, flags);
65+
=> GetActiveDatabase().SortAndStoreAsync(destination, key, skip, take, order, sortType, by, get, flags);
6666
}

‎src/StackExchange.Redis/MultiGroupDatabase.Geo.Async.cs‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -6,47 +6,47 @@ internal sealed partial class MultiGroupDatabase
66
{
77
// Geo Async
88
public Task<bool> GeoAddAsync(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None)
9-
=> GetDatabase().GeoAddAsync(key, longitude, latitude, member, flags);
9+
=> GetActiveDatabase().GeoAddAsync(key, longitude, latitude, member, flags);
1010

1111
public Task<bool> GeoAddAsync(RedisKey key, GeoEntry value, CommandFlags flags = CommandFlags.None)
12-
=> GetDatabase().GeoAddAsync(key, value, flags);
12+
=> GetActiveDatabase().GeoAddAsync(key, value, flags);
1313

1414
public Task<long> GeoAddAsync(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None)
15-
=> GetDatabase().GeoAddAsync(key, values, flags);
15+
=> GetActiveDatabase().GeoAddAsync(key, values, flags);
1616

1717
public Task<bool> GeoRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
18-
=> GetDatabase().GeoRemoveAsync(key, member, flags);
18+
=> GetActiveDatabase().GeoRemoveAsync(key, member, flags);
1919

2020
public Task<double?> GeoDistanceAsync(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None)
21-
=> GetDatabase().GeoDistanceAsync(key, member1, member2, unit, flags);
21+
=> GetActiveDatabase().GeoDistanceAsync(key, member1, member2, unit, flags);
2222

2323
public Task<string?[]> GeoHashAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
24-
=> GetDatabase().GeoHashAsync(key, members, flags);
24+
=> GetActiveDatabase().GeoHashAsync(key, members, flags);
2525

2626
public Task<string?> GeoHashAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
27-
=> GetDatabase().GeoHashAsync(key, member, flags);
27+
=> GetActiveDatabase().GeoHashAsync(key, member, flags);
2828

2929
public Task<GeoPosition?[]> GeoPositionAsync(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
30-
=> GetDatabase().GeoPositionAsync(key, members, flags);
30+
=> GetActiveDatabase().GeoPositionAsync(key, members, flags);
3131

3232
public Task<GeoPosition?> GeoPositionAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
33-
=> GetDatabase().GeoPositionAsync(key, member, flags);
33+
=> GetActiveDatabase().GeoPositionAsync(key, member, flags);
3434

3535
public Task<GeoRadiusResult[]> GeoRadiusAsync(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
36-
=> GetDatabase().GeoRadiusAsync(key, member, radius, unit, count, order, options, flags);
36+
=> GetActiveDatabase().GeoRadiusAsync(key, member, radius, unit, count, order, options, flags);
3737

3838
public Task<GeoRadiusResult[]> GeoRadiusAsync(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
39-
=> GetDatabase().GeoRadiusAsync(key, longitude, latitude, radius, unit, count, order, options, flags);
39+
=> GetActiveDatabase().GeoRadiusAsync(key, longitude, latitude, radius, unit, count, order, options, flags);
4040

4141
public Task<GeoRadiusResult[]> GeoSearchAsync(RedisKey key, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
42-
=> GetDatabase().GeoSearchAsync(key, member, shape, count, demandClosest, order, options, flags);
42+
=> GetActiveDatabase().GeoSearchAsync(key, member, shape, count, demandClosest, order, options, flags);
4343

4444
public Task<GeoRadiusResult[]> GeoSearchAsync(RedisKey key, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
45-
=> GetDatabase().GeoSearchAsync(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
45+
=> GetActiveDatabase().GeoSearchAsync(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
4646

4747
public Task<long> GeoSearchAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None)
48-
=> GetDatabase().GeoSearchAndStoreAsync(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
48+
=> GetActiveDatabase().GeoSearchAndStoreAsync(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
4949

5050
public Task<long> GeoSearchAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None)
51-
=> GetDatabase().GeoSearchAndStoreAsync(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
51+
=> GetActiveDatabase().GeoSearchAndStoreAsync(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
5252
}

‎src/StackExchange.Redis/MultiGroupDatabase.Geo.cs‎

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -4,47 +4,47 @@ internal sealed partial class MultiGroupDatabase
44
{
55
// Geo operations
66
public bool GeoAdd(RedisKey key, double longitude, double latitude, RedisValue member, CommandFlags flags = CommandFlags.None)
7-
=> GetDatabase().GeoAdd(key, longitude, latitude, member, flags);
7+
=> GetActiveDatabase().GeoAdd(key, longitude, latitude, member, flags);
88

99
public bool GeoAdd(RedisKey key, GeoEntry value, CommandFlags flags = CommandFlags.None)
10-
=> GetDatabase().GeoAdd(key, value, flags);
10+
=> GetActiveDatabase().GeoAdd(key, value, flags);
1111

1212
public long GeoAdd(RedisKey key, GeoEntry[] values, CommandFlags flags = CommandFlags.None)
13-
=> GetDatabase().GeoAdd(key, values, flags);
13+
=> GetActiveDatabase().GeoAdd(key, values, flags);
1414

1515
public bool GeoRemove(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
16-
=> GetDatabase().GeoRemove(key, member, flags);
16+
=> GetActiveDatabase().GeoRemove(key, member, flags);
1717

1818
public double? GeoDistance(RedisKey key, RedisValue member1, RedisValue member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None)
19-
=> GetDatabase().GeoDistance(key, member1, member2, unit, flags);
19+
=> GetActiveDatabase().GeoDistance(key, member1, member2, unit, flags);
2020

2121
public string?[] GeoHash(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
22-
=> GetDatabase().GeoHash(key, members, flags);
22+
=> GetActiveDatabase().GeoHash(key, members, flags);
2323

2424
public string? GeoHash(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
25-
=> GetDatabase().GeoHash(key, member, flags);
25+
=> GetActiveDatabase().GeoHash(key, member, flags);
2626

2727
public GeoPosition?[] GeoPosition(RedisKey key, RedisValue[] members, CommandFlags flags = CommandFlags.None)
28-
=> GetDatabase().GeoPosition(key, members, flags);
28+
=> GetActiveDatabase().GeoPosition(key, members, flags);
2929

3030
public GeoPosition? GeoPosition(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None)
31-
=> GetDatabase().GeoPosition(key, member, flags);
31+
=> GetActiveDatabase().GeoPosition(key, member, flags);
3232

3333
public GeoRadiusResult[] GeoRadius(RedisKey key, RedisValue member, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
34-
=> GetDatabase().GeoRadius(key, member, radius, unit, count, order, options, flags);
34+
=> GetActiveDatabase().GeoRadius(key, member, radius, unit, count, order, options, flags);
3535

3636
public GeoRadiusResult[] GeoRadius(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
37-
=> GetDatabase().GeoRadius(key, longitude, latitude, radius, unit, count, order, options, flags);
37+
=> GetActiveDatabase().GeoRadius(key, longitude, latitude, radius, unit, count, order, options, flags);
3838

3939
public GeoRadiusResult[] GeoSearch(RedisKey key, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
40-
=> GetDatabase().GeoSearch(key, member, shape, count, demandClosest, order, options, flags);
40+
=> GetActiveDatabase().GeoSearch(key, member, shape, count, demandClosest, order, options, flags);
4141

4242
public GeoRadiusResult[] GeoSearch(RedisKey key, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None)
43-
=> GetDatabase().GeoSearch(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
43+
=> GetActiveDatabase().GeoSearch(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
4444

4545
public long GeoSearchAndStore(RedisKey sourceKey, RedisKey destinationKey, RedisValue member, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None)
46-
=> GetDatabase().GeoSearchAndStore(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
46+
=> GetActiveDatabase().GeoSearchAndStore(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
4747

4848
public long GeoSearchAndStore(RedisKey sourceKey, RedisKey destinationKey, double longitude, double latitude, GeoSearchShape shape, int count = -1, bool demandClosest = true, Order? order = null, bool storeDistances = false, CommandFlags flags = CommandFlags.None)
49-
=> GetDatabase().GeoSearchAndStore(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
49+
=> GetActiveDatabase().GeoSearchAndStore(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
5050
}

0 commit comments

Comments
 (0)