java.lang.Object
- dk.cloudcreate.essentials.components.foundation.fencedlock.DBFencedLockManager<UOW,LOCK>

All Implemented Interfaces:: FencedLockManager, Lifecycle

public class DBFencedLockManager<UOW extends UnitOfWork,LOCK extends DBFencedLock>
extends Object
implements FencedLockManager

Field Summary

Fields
Modifier and Type	Field	Description
`protected org.slf4j.Logger`	`log`
`protected int`	`syncAcquireLockPauseIntervalMs`	`tryAcquireLock(LockName)`/`tryAcquireLock(LockName, Duration)` and `acquireLock(LockName)` pause interval between retries
`protected UnitOfWorkFactory<? extends UOW>`	`unitOfWorkFactory`

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`DBFencedLockManager(FencedLockStorage<UOW,LOCK> lockStorage, UnitOfWorkFactory<? extends UOW> unitOfWorkFactory, Optional<String> lockManagerInstanceId, Duration lockTimeOut, Duration lockConfirmationInterval, Optional<EventBus> eventBus)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`FencedLock`	`acquireLock(LockName lockName)`	Acquire the lock on this JVM Node.
`void`	`acquireLockAsync(LockName lockName, LockCallback lockCallback)`	Asynchronously try to acquire a lock by the given name and call the `LockCallback.lockAcquired(FencedLock)` when the lock is acquired To stop the background acquiring process, you need to call `FencedLockManager.cancelAsyncLockAcquiring(LockName)` with the same lockName
`void`	`cancelAsyncLockAcquiring(LockName lockName)`	Cancel a previously started asynchronous lock acquiring background process IF this JVM node had acquired a `FencedLock` then this lock will be released AND the `LockCallback.lockReleased(FencedLock)` will be called on the `LockCallback` instance that was supplied to the `FencedLockManager.acquireLockAsync(LockName, LockCallback)` Otherwise only the background lock acquiring process will be stopped.
`void`	`deleteAllLocksInDB()`
`long`	`getInitialTokenValue()`
`String`	`getLockManagerInstanceId()`	Get the instance id that distinguishes different `FencedLockManager` instances from each other For local JVM testing you can assign a unique instance id to allow multiple `FencedLockManager`'s to compete for Locks. In production the hostname should be returned
`Long`	`getUninitializedTokenValue()`
`boolean`	`isLockAcquired(LockName lockName)`	Is the lock acquired
`boolean`	`isLockAcquiredByAnotherLockManagerInstance(LockName lockName)`	Is the lock already acquired by another JVM node
`boolean`	`isLockedByThisLockManagerInstance(LockName lockName)`	Is the lock already acquired by this JVM node
`boolean`	`isStarted()`	Returns true if the process is started
`Optional<FencedLock>`	`lookupLock(LockName lockName)`	Lookup a lock
`protected void`	`notify(FencedLockEvents event)`
`void`	`pause()`
`protected void`	`releaseLock(LOCK lock)`	Internal method only to be called by subclasses of `DBFencedLockManager` and `DBFencedLock`
`void`	`resume()`
`void`	`start()`	Start the processing.
`void`	`stop()`	Stop the processing.
`String`	`toString()`
`Optional<FencedLock>`	`tryAcquireLock(LockName lockName)`	Try to acquire the lock using this Lock Manager instance
`Optional<FencedLock>`	`tryAcquireLock(LockName lockName, Duration timeout)`	Try to acquire the lock on this JVM Node

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - log
```
protected final org.slf4j.Logger log
```
  - unitOfWorkFactory
```
protected final UnitOfWorkFactory<? extends UOW extends UnitOfWork> unitOfWorkFactory
```
  - syncAcquireLockPauseIntervalMs
```
protected int syncAcquireLockPauseIntervalMs
```
    tryAcquireLock(LockName)/tryAcquireLock(LockName, Duration) and acquireLock(LockName) pause interval between retries
- Constructor Detail
  - DBFencedLockManager
```
protected DBFencedLockManager(FencedLockStorage<UOW,LOCK> lockStorage,
                              UnitOfWorkFactory<? extends UOW> unitOfWorkFactory,
                              Optional<String> lockManagerInstanceId,
                              Duration lockTimeOut,
                              Duration lockConfirmationInterval,
                              Optional<EventBus> eventBus)
```
    Parameters:
    
    lockStorage - the lock storage used for the lock manager
    
    unitOfWorkFactory - the UnitOfWork factory
    
    lockManagerInstanceId - The unique name for this lock manager instance. If left Optional.empty() then the machines hostname is used
    
    lockTimeOut - the period between FencedLock.getLockLastConfirmedTimestamp() and the current time before the lock is marked as timed out
    
    lockConfirmationInterval - how often should the locks be confirmed. MUST is less than the lockTimeOut
    
    eventBus - optional LocalEventBus where FencedLockEvents will be published
- Method Detail
  - start
```
public void start()
```
    Description copied from interface: Lifecycle
    
    Start the processing. This operation must be idempotent, such that duplicate calls to Lifecycle.start() for an already started process (where Lifecycle.isStarted() returns true) is ignored
    
    Specified by:
    
    start in interface Lifecycle
  - notify
```
protected void notify(FencedLockEvents event)
```
  - pause
```
public void pause()
```
  - resume
```
public void resume()
```
  - releaseLock
```
protected void releaseLock(LOCK lock)
```
    Internal method only to be called by subclasses of DBFencedLockManager and DBFencedLock
    
    Parameters:
    
    lock - the lock to be released
  - lookupLock
```
public Optional<FencedLock> lookupLock(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Lookup a lock
    
    Specified by:
    
    lookupLock in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    Returns:
    
    an Optional with the locks current state or Optional.empty() if the lock doesn't exist
  - stop
```
public void stop()
```
    Description copied from interface: Lifecycle
    
    Stop the processing. This operation must be idempotent, such that duplicate calls to Lifecycle.stop() for an already stopped process (where Lifecycle.isStarted() returns false) is ignored
    
    Specified by:
    
    stop in interface Lifecycle
  - isStarted
```
public boolean isStarted()
```
    Description copied from interface: Lifecycle
    
    Returns true if the process is started
    
    Specified by:
    
    isStarted in interface Lifecycle
    
    Returns:
    
    true if the process is started otherwise false
  - tryAcquireLock
```
public Optional<FencedLock> tryAcquireLock(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Try to acquire the lock using this Lock Manager instance
    
    Specified by:
    
    tryAcquireLock in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    Returns:
    
    An Optional with the FencedLock IF it was acquired by the FencedLockManager on this JVM Node, otherwise it return an empty Optional
  - tryAcquireLock
```
public Optional<FencedLock> tryAcquireLock(LockName lockName,
                                           Duration timeout)
```
    Description copied from interface: FencedLockManager
    
    Try to acquire the lock on this JVM Node
    
    Specified by:
    
    tryAcquireLock in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    timeout - timeout for the lock acquiring
    
    Returns:
    
    An Optional with the FencedLock IF it was acquired by the FencedLockManager on this JVM Node, otherwise it return an empty Optional
  - acquireLock
```
public FencedLock acquireLock(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Acquire the lock on this JVM Node. If the lock already is acquired by another JVM Node, then this method will wait until the lock can be acquired by this JVM node
    
    Specified by:
    
    acquireLock in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    Returns:
    
    The FencedLock when can be acquired by this JVM Node
  - isLockAcquired
```
public boolean isLockAcquired(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Is the lock acquired
    
    Specified by:
    
    isLockAcquired in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    Returns:
    
    true if the lock is acquired, otherwise false
  - isLockedByThisLockManagerInstance
```
public boolean isLockedByThisLockManagerInstance(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Is the lock already acquired by this JVM node
    
    Specified by:
    
    isLockedByThisLockManagerInstance in interface FencedLockManager
    
    Parameters:
    
    lockName - the lock name
    
    Returns:
    
    true of the lock is acquired by this JVM node
  - isLockAcquiredByAnotherLockManagerInstance
```
public boolean isLockAcquiredByAnotherLockManagerInstance(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Is the lock already acquired by another JVM node
    
    Specified by:
    
    isLockAcquiredByAnotherLockManagerInstance in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    Returns:
    
    true of the lock is acquired by this JVM node
  - acquireLockAsync
```
public void acquireLockAsync(LockName lockName,
                             LockCallback lockCallback)
```
    Description copied from interface: FencedLockManager
    
    Asynchronously try to acquire a lock by the given name and call the LockCallback.lockAcquired(FencedLock) when the lock is acquired
    To stop the background acquiring process, you need to call FencedLockManager.cancelAsyncLockAcquiring(LockName) with the same lockName
    
    Specified by:
    
    acquireLockAsync in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
    
    lockCallback - the callback that's notified when a lock is acquired
  - cancelAsyncLockAcquiring
```
public void cancelAsyncLockAcquiring(LockName lockName)
```
    Description copied from interface: FencedLockManager
    
    Cancel a previously started asynchronous lock acquiring background process
    IF this JVM node had acquired a FencedLock then this lock will be released AND the LockCallback.lockReleased(FencedLock) will be called on the LockCallback instance that was supplied to the FencedLockManager.acquireLockAsync(LockName, LockCallback)
    Otherwise only the background lock acquiring process will be stopped.
    
    Specified by:
    
    cancelAsyncLockAcquiring in interface FencedLockManager
    
    Parameters:
    
    lockName - the name of the lock
  - getLockManagerInstanceId
```
public String getLockManagerInstanceId()
```
    Description copied from interface: FencedLockManager
    
    Get the instance id that distinguishes different FencedLockManager instances from each other
    For local JVM testing you can assign a unique instance id to allow multiple FencedLockManager's to compete for Locks.
    In production the hostname should be returned
    
    Specified by:
    
    getLockManagerInstanceId in interface FencedLockManager
    
    Returns:
    
    the instance id
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getUninitializedTokenValue
```
public Long getUninitializedTokenValue()
```
  - getInitialTokenValue
```
public long getInitialTokenValue()
```
  - deleteAllLocksInDB
```
public void deleteAllLocksInDB()
```

Class DBFencedLockManager<UOW extends UnitOfWork,​LOCK extends DBFencedLock>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

log

unitOfWorkFactory

syncAcquireLockPauseIntervalMs

Constructor Detail

DBFencedLockManager

Method Detail

start

notify

pause

resume

releaseLock

lookupLock

stop

isStarted

tryAcquireLock

tryAcquireLock

acquireLock

isLockAcquired

isLockedByThisLockManagerInstance

isLockAcquiredByAnotherLockManagerInstance

acquireLockAsync

cancelAsyncLockAcquiring

getLockManagerInstanceId

toString

getUninitializedTokenValue

getInitialTokenValue

deleteAllLocksInDB

Class DBFencedLockManager<UOW extends UnitOfWork,LOCK extends DBFencedLock>