Class RedisLocker

A Redis Locker that can be used as both:

a Read Write Locker that uses a (single) Redis server to store the locks and counts.
a Resource Locker that uses a (single) Redis server to store the lock. This solution should be process-safe. The only references to locks are string keys derived from identifier paths.

The Read Write algorithm roughly goes as follows:

Acquire a read lock: allowed as long as there is no write lock. On acquiring the read counter goes up.
Acquire a write lock: allowed as long as there is no other write lock AND the read counter is 0.
Release a read lock: decreases the read counter with 1
Release a write lock: unlocks the write lock

The Resource locking algorithm uses a single mutex/lock.

All operations, such as checking for a write lock AND read count, are executed in a single Lua script. These scripts are used by Redis as a single new command. Redis executes its operations in a single thread, as such, each such operation can be considered atomic.

See

Redis Commands documentation

Hierarchy

RedisLocker

Implements

Index

Constructors

constructor

new RedisLocker(redisClient?: string, attemptSettings?: AttemptSettings): RedisLocker
Parameters
- redisClient: string = '127.0.0.1:6379'
- attemptSettings: AttemptSettings = {}
Returns RedisLocker
- Defined in src/util/locking/RedisLocker.ts:57

Properties

`Private` `Readonly` attemptSettings

attemptSettings: Required<AttemptSettings>

`Protected` `Readonly` logger

logger: Logger = ...

`Private` `Readonly` redis

redis: Redis

`Private` `Readonly` redisLock

redisLock: RedisResourceLock

`Private` `Readonly` redisRw

redisRw: RedisReadWriteLock

Methods

acquire

acquire(identifier: ResourceIdentifier): Promise<void>
Acquires a lock on the requested identifier. The promise will resolve when the lock has been acquired.
Parameters
- identifier: ResourceIdentifier
  
  Resource to acquire a lock on.
Returns Promise<void>
Implementation of ResourceLocker.acquire
- Defined in src/util/locking/RedisLocker.ts:173

`Private` createRedisClient

createRedisClient(redisClientString: string): Redis
Generate and return a RedisClient based on the provided string
Parameters
- redisClientString: string
  
  A string that contains either a host address and a port number like '127.0.0.1:6379' or just a port number like '6379'.
Returns Redis
- Defined in src/util/locking/RedisLocker.ts:75

finalize

finalize(): Promise<void>
Returns Promise<void>
Implementation of Finalizable.finalize
- Defined in src/util/locking/RedisLocker.ts:185

`Private` getReadWriteKey

getReadWriteKey(identifier: ResourceIdentifier): string
Create a scoped Redis key for Read-Write locking.

Returns
A scoped Redis key that allows cleanup afterwards without affecting other keys.
Parameters
- identifier: ResourceIdentifier
  
  The identifier object to create a Redis key for
Returns string
- Defined in src/util/locking/RedisLocker.ts:136

`Private` getResourceKey

getResourceKey(identifier: ResourceIdentifier): string
Create a scoped Redis key for Resource locking.

Returns
A scoped Redis key that allows cleanup afterwards without affecting other keys.
Parameters
- identifier: ResourceIdentifier
  
  The identifier object to create a Redis key for
Returns string
- Defined in src/util/locking/RedisLocker.ts:145

release

release(identifier: ResourceIdentifier): Promise<void>
Releases a lock on the requested identifier. The promise will resolve when the lock has been released. In case there is no lock on the resource an error should be thrown.
Parameters
- identifier: ResourceIdentifier
  
  Resource to release the lock on.
Returns Promise<void>
Implementation of ResourceLocker.release
- Defined in src/util/locking/RedisLocker.ts:178

`Private` tryRedisFn

tryRedisFn(fn: (() => Promise<boolean>)): Promise<void>
Try a Redis function according to the set AttemptSettings Since the locking strategy is custom-built on Redis and Redis itself does not have a lock concept, this function allows us to wait until we acquired a lock.

The AttemptSettings will dictate how many times we should retry the Redis functions before giving up and throwing an error.

Returns
Promise that resolves if operation succeeded. Rejects with error otherwise

See
To convert from Redis operation to Promise use fromResp2ToBool to wrap the function
Parameters
- fn: (() => Promise<boolean>)
  
  The function to try
  - - (): Promise<boolean>
    - Returns Promise<boolean>
Returns Promise<void>
- Defined in src/util/locking/RedisLocker.ts:107

withReadLock

withReadLock<T>(identifier: ResourceIdentifier, whileLocked: (() => T | Promise<T>)): Promise<T>
Run the given function while the resource is locked. The lock will be released when the (async) input function resolves. This function should be used for operations that only require reading the resource.

Returns
A promise resolving when the lock is released.
Type Parameters
- T
Parameters
- identifier: ResourceIdentifier
  
  Identifier of the resource that needs to be locked.
- whileLocked: (() => T | Promise<T>)
  
  A function to execute while the resource is locked.
  - - (): T | Promise<T>
    - Returns T | Promise<T>
Returns Promise<T>
Implementation of ReadWriteLocker.withReadLock
- Defined in src/util/locking/RedisLocker.ts:151

withWriteLock

withWriteLock<T>(identifier: ResourceIdentifier, whileLocked: (() => T | Promise<T>)): Promise<T>
Run the given function while the resource is locked. The lock will be released when the (async) input function resolves. This function should be used for operations that could modify the resource.

Returns
A promise resolving when the lock is released.
Type Parameters
- T
Parameters
- identifier: ResourceIdentifier
  
  Identifier of the resource that needs to be locked.
- whileLocked: (() => T | Promise<T>)
  
  A function to execute while the resource is locked.
  - - (): T | Promise<T>
    - Returns T | Promise<T>
Returns Promise<T>
Implementation of ReadWriteLocker.withWriteLock
- Defined in src/util/locking/RedisLocker.ts:161

Class RedisLocker

See

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

redisClient: string = '127.0.0.1:6379'

attemptSettings: AttemptSettings = {}

Returns RedisLocker

Properties

Private Readonly attemptSettings

Protected Readonly logger

Private Readonly redis

Private Readonly redisLock

Private Readonly redisRw

Methods

acquire

Parameters

identifier: ResourceIdentifier

Returns Promise<void>

Private createRedisClient

Parameters

redisClientString: string

Returns Redis

finalize

Returns Promise<void>

Private getReadWriteKey

Returns

Parameters

identifier: ResourceIdentifier

Returns string

Private getResourceKey

Returns

Parameters

identifier: ResourceIdentifier

Returns string

release

Parameters

identifier: ResourceIdentifier

Returns Promise<void>

Private tryRedisFn

Returns

See

Parameters

fn: (() => Promise<boolean>)

Returns Promise<boolean>

Returns Promise<void>

withReadLock

Returns

Type Parameters

T

Parameters

identifier: ResourceIdentifier

whileLocked: (() => T | Promise<T>)

Returns T | Promise<T>

Returns Promise<T>

withWriteLock

Returns

Type Parameters

T

Parameters

identifier: ResourceIdentifier

whileLocked: (() => T | Promise<T>)

Returns T | Promise<T>

Returns Promise<T>

Settings

Member Visibility

Theme

`Private` `Readonly` attemptSettings

`Protected` `Readonly` logger

`Private` `Readonly` redis

`Private` `Readonly` redisLock

`Private` `Readonly` redisRw

`Private` createRedisClient

`Private` getReadWriteKey

`Private` getResourceKey

`Private` tryRedisFn