io.flamingock.internal.core.external.store.lock

Class Lock

java.lang.Object

io.flamingock.internal.core.external.store.lock.Lock

Direct Known Subclasses:

CommunityLock

public class Lock
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
protected java.time.LocalDateTime	expiresAt It should never be null(after acquisition), just acquired(after now) or expired(before now)
protected long	leaseMillis
protected LockKey	lockKey
protected LockService	lockService
static java.lang.String	LOG_EXPIRED_TEMPLATE
protected io.flamingock.internal.util.id.RunnerId	owner
protected long	retryFrequencyMillis
protected long	stopTryingAfterMillis
protected io.flamingock.internal.util.TimeService	timeService

Constructor Summary

Constructors

Constructor and Description
Lock(io.flamingock.internal.util.id.RunnerId owner, LockKey lockKey, long leaseMillis, long stopTryingAfterMillis, long retryFrequencyMillis, LockService lockService, io.flamingock.internal.util.TimeService timeService)

Method Summary

Modifier and Type	Method and Description
void	ensure() Ensures the lock is safely acquired(safely here means it's acquired with enough margin to operate), or throws an exception otherwise.
java.time.LocalDateTime	expiresAt()
boolean	extend() Refreshes the lock if it's already taken.
protected void	handleLockException(boolean acquiringLock, java.time.Instant shouldStopTryingAt, LockServiceException ex)
boolean	isExpired()
void	release() This should be called once all the process guarded by the lock(those who assumed the lock is ensured) has finished.
java.lang.String	toString()
protected void	updateLease(long leaseMillis)
protected void	waitForLock(java.time.LocalDateTime expiresAt)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

LOG_EXPIRED_TEMPLATE

public static final java.lang.String LOG_EXPIRED_TEMPLATE

See Also:

Constant Field Values

lockKey

protected final LockKey lockKey

lockService

protected final LockService lockService

timeService

protected final io.flamingock.internal.util.TimeService timeService

owner

protected final io.flamingock.internal.util.id.RunnerId owner

leaseMillis

protected final long leaseMillis

retryFrequencyMillis

protected final long retryFrequencyMillis

stopTryingAfterMillis

protected final long stopTryingAfterMillis

expiresAt

protected volatile java.time.LocalDateTime expiresAt

It should never be null(after acquisition), just acquired(after now) or expired(before now)

Constructor Detail

Lock

public Lock(io.flamingock.internal.util.id.RunnerId owner,
            LockKey lockKey,
            long leaseMillis,
            long stopTryingAfterMillis,
            long retryFrequencyMillis,
            LockService lockService,
            io.flamingock.internal.util.TimeService timeService)

Method Detail

ensure

public final void ensure()
                  throws LockException

Ensures the lock is safely acquired(safely here means it's acquired with enough margin to operate), or throws an exception otherwise. In case the lock is about to expire, it will try to refresh it. In this scenario, the lock won't be considered ensured until it's successfully extended. However, this scenario shouldn't happen, when a well configured daemon is set up.

Throws:

LockException - if it cannot be ensured. Either is expired or, close to be expired and cannot be extended.

extend

public final boolean extend()
                     throws LockException

Refreshes the lock if it's already taken. Throws an exception otherwise.

Returns:

true if the lock has been successfully refreshed, or false if lock shouldn't be refreshed because it's in the middle of a release process, or it's already released.

Throws:

LockException - if there is any problem refreshing the lock or it's not acquired at all.

release

public final void release()

This should be called once all the process guarded by the lock(those who assumed the lock is ensured) has finished. Otherwise, a race condition where a process A ensures the lock, starts a task that takes 2 seconds, but before finishing, the lock is released(closed) and another instances acquire the lock, before process A has finished.

expiresAt

public java.time.LocalDateTime expiresAt()

updateLease

protected final void updateLease(long leaseMillis)

isExpired

public final boolean isExpired()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

handleLockException

protected void handleLockException(boolean acquiringLock,
                                   java.time.Instant shouldStopTryingAt,
                                   LockServiceException ex)

waitForLock

protected void waitForLock(java.time.LocalDateTime expiresAt)