FilesExpand file tree

 oracle

/

RedisDistributedLock.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

79 lines (70 loc) · 3.8 KB

 oracle

/

RedisDistributedLock.cs

Copy path

Top

File metadata and controls

• Code
• Blame

79 lines (70 loc) · 3.8 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

using Medallion.Threading.Internal;

using Medallion.Threading.Redis.Primitives;

using Medallion.Threading.Redis.RedLock;

using StackExchange.Redis;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace Medallion.Threading.Redis

{

/// <summary>

/// Implements a <see cref="IDistributedLock"/> using Redis. Can leverage multiple servers via the RedLock algorithm.

/// </summary>

public sealed partial class RedisDistributedLock : IInternalDistributedLock<RedisDistributedLockHandle>

{

private readonly IReadOnlyList<IDatabase> _databases;

private readonly RedisDistributedLockOptions _options;

/// <summary>

/// Constructs a lock named <paramref name="key"/> using the provided <paramref name="database"/> and <paramref name="options"/>.

/// </summary>

public RedisDistributedLock(RedisKey key, IDatabase database, Action<RedisDistributedSynchronizationOptionsBuilder>? options = null)

: this(key, new[] { database ?? throw new ArgumentNullException(nameof(database)) }, options)

{

}

/// <summary>

/// Constructs a lock named <paramref name="key"/> using the provided <paramref name="databases"/> and <paramref name="options"/>.

/// </summary>

public RedisDistributedLock(RedisKey key, IEnumerable<IDatabase> databases, Action<RedisDistributedSynchronizationOptionsBuilder>? options = null)

{

if (key == default(RedisKey)) { throw new ArgumentNullException(nameof(key)); }

this._databases = ValidateDatabases(databases);

this.Key = key;

this._options = RedisDistributedSynchronizationOptionsBuilder.GetOptions(options);

}

internal static IReadOnlyList<IDatabase> ValidateDatabases(IEnumerable<IDatabase> databases)

{

var databasesArray = databases?.ToArray() ?? throw new ArgumentNullException(nameof(databases));

if (databasesArray.Length == 0) { throw new ArgumentException("may not be empty", nameof(databases)); }

if (databasesArray.Contains(null!)) { throw new ArgumentNullException(nameof(databases), "may not contain null"); }

return databasesArray;

}

/// <summary>

/// The Redis key used to implement the lock

/// </summary>

public RedisKey Key { get; }

/// <summary>

/// Implements <see cref="IDistributedLock.Name"/>

/// </summary>

public string Name => this.Key.ToString();

ValueTask<RedisDistributedLockHandle?> IInternalDistributedLock<RedisDistributedLockHandle>.InternalTryAcquireAsync(TimeoutValue timeout, CancellationToken cancellationToken) =>

BusyWaitHelper.WaitAsync(

state: this,

tryGetValue: (@this, cancellationToken) => @this.TryAcquireAsync(cancellationToken),

timeout: timeout,

minSleepTime: this._options.MinBusyWaitSleepTime,

maxSleepTime: this._options.MaxBusyWaitSleepTime,

cancellationToken: cancellationToken

);

private async ValueTask<RedisDistributedLockHandle?> TryAcquireAsync(CancellationToken cancellationToken)

{

var primitive = new RedisMutexPrimitive(this.Key, RedLockHelper.CreateLockId(), this._options.RedLockTimeouts);

var tryAcquireTasks = await new RedLockAcquire(primitive, this._databases, cancellationToken).TryAcquireAsync().ConfigureAwait(false);

return tryAcquireTasks != null

? new RedisDistributedLockHandle(new RedLockHandle(primitive, tryAcquireTasks, extensionCadence: this._options.ExtensionCadence, expiry: this._options.RedLockTimeouts.Expiry))

: null;

}

}

}