/// <summary>
/// Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per <see cref="LOCK_POLL_INTERVAL"/>
/// (currently 1000) milliseconds until <paramref name="lockWaitTimeout"/> is
/// passed.
/// </summary>
/// <param name="lockWaitTimeout"> length of time to wait in
/// milliseconds or
/// <see cref="LOCK_OBTAIN_WAIT_FOREVER"/> to retry forever </param>
/// <returns> <c>true</c> if lock was obtained </returns>
/// <exception cref="LockObtainFailedException"> if lock wait times out </exception>
/// <exception cref="ArgumentOutOfRangeException"> if <paramref name="lockWaitTimeout"/> is
/// out of bounds </exception>
/// <exception cref="IOException"> if <see cref="Obtain()"/> throws <see cref="IOException"/> </exception>
public bool Obtain(long lockWaitTimeout)
{
FailureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
{
throw new ArgumentOutOfRangeException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention)
}
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
string reason = "Lock obtain timed out: " + this.ToString();
if (FailureReason != null)
{
reason += ": " + FailureReason;
}
LockObtainFailedException e = FailureReason != null
? new LockObtainFailedException(reason, FailureReason)
: new LockObtainFailedException(reason);
throw e;
}
Thread.Sleep(TimeSpan.FromMilliseconds(LOCK_POLL_INTERVAL));
// LUCENENET NOTE: No need to catch and rethrow same excepton type ThreadInterruptedException
locked = Obtain();
}
return(locked);
}
/// <summary>Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per {@link #LOCK_POLL_INTERVAL}
/// (currently 1000) milliseconds until lockWaitTimeout is
/// passed.
/// </summary>
/// <param name="lockWaitTimeout">length of time to wait in
/// milliseconds or {@link
/// #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
/// </param>
/// <returns> true if lock was obtained
/// </returns>
/// <throws> LockObtainFailedException if lock wait times out </throws>
/// <throws> IllegalArgumentException if lockWaitTimeout is </throws>
/// <summary> out of bounds
/// </summary>
/// <throws> IOException if obtain() throws IOException </throws>
public virtual bool Obtain(long lockWaitTimeout)
{
failureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
{
throw new System.ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
}
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
System.String reason = "Lock obtain timed out: " + this.ToString();
if (failureReason != null)
{
reason += (": " + failureReason);
}
LockObtainFailedException e;
if (failureReason != null)
{
e = new LockObtainFailedException(reason, failureReason);
}
else
{
e = new LockObtainFailedException(reason);
}
throw e;
}
try
{
System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * LOCK_POLL_INTERVAL));
}
catch (System.Threading.ThreadInterruptedException e)
{
// In 3.0 we will change this to throw
// InterruptedException instead
SupportClass.ThreadClass.Current().Interrupt();
throw new System.IO.IOException(e.ToString());
}
locked = Obtain();
}
return(locked);
}
/// <summary>
/// Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per <see cref="LOCK_POLL_INTERVAL"/>
/// (currently 1000) milliseconds until <paramref name="lockWaitTimeout"/> is
/// passed.
/// </summary>
/// <param name="lockWaitTimeout"> length of time to wait in
/// milliseconds or
/// <see cref="LOCK_OBTAIN_WAIT_FOREVER"/> to retry forever </param>
/// <returns> <c>true</c> if lock was obtained </returns>
/// <exception cref="LockObtainFailedException"> if lock wait times out </exception>
/// <exception cref="ArgumentException"> if <paramref name="lockWaitTimeout"/> is
/// out of bounds </exception>
/// <exception cref="IOException"> if <see cref="Obtain()"/> throws <see cref="IOException"/> </exception>
public bool Obtain(long lockWaitTimeout)
{
FailureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
{
throw new ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
}
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
string reason = "Lock obtain timed out: " + this.ToString();
if (FailureReason != null)
{
reason += ": " + FailureReason;
}
LockObtainFailedException e = new LockObtainFailedException(reason);
e = FailureReason != null
? new LockObtainFailedException(reason, FailureReason)
: new LockObtainFailedException(reason);
throw e;
}
//#if FEATURE_THREAD_INTERRUPT
// try
// {
//#endif
Thread.Sleep(TimeSpan.FromMilliseconds(LOCK_POLL_INTERVAL));
//#if FEATURE_THREAD_INTERRUPT // LUCENENET NOTE: Senseless to catch and rethrow the same exception type
// }
// catch (ThreadInterruptedException ie)
// {
// throw new ThreadInterruptedException(ie.ToString(), ie);
// }
//#endif
locked = Obtain();
}
return(locked);
}
/// <summary>
/// Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per <see cref="LOCK_POLL_INTERVAL"/>
/// (currently 1000) milliseconds until <paramref name="lockWaitTimeout"/> is
/// passed.
/// </summary>
/// <param name="lockWaitTimeout"> length of time to wait in
/// milliseconds or
/// <see cref="LOCK_OBTAIN_WAIT_FOREVER"/> to retry forever </param>
/// <returns> <c>true</c> if lock was obtained </returns>
/// <exception cref="LockObtainFailedException"> if lock wait times out </exception>
/// <exception cref="ArgumentException"> if <paramref name="lockWaitTimeout"/> is
/// out of bounds </exception>
/// <exception cref="System.IO.IOException"> if <see cref="Obtain()"/> throws <see cref="System.IO.IOException"/> </exception>
public bool Obtain(long lockWaitTimeout)
{
FailureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
{
throw new ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
}
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
string reason = "Lock obtain timed out: " + this.ToString();
if (FailureReason != null)
{
reason += ": " + FailureReason;
}
LockObtainFailedException e = new LockObtainFailedException(reason);
e = FailureReason != null
? new LockObtainFailedException(reason, FailureReason)
: new LockObtainFailedException(reason);
throw e;
}
#if !NETSTANDARD
try
{
#endif
Thread.Sleep(TimeSpan.FromMilliseconds(LOCK_POLL_INTERVAL));
#if !NETSTANDARD
}
catch (ThreadInterruptedException ie)
{
throw new ThreadInterruptedException(ie.ToString(), ie);
}
#endif
locked = Obtain();
}
return(locked);
}
/// <summary>
/// Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per <seealso cref="#LOCK_POLL_INTERVAL"/>
/// (currently 1000) milliseconds until lockWaitTimeout is
/// passed. </summary>
/// <param name="lockWaitTimeout"> length of time to wait in
/// milliseconds or {@link
/// #LOCK_OBTAIN_WAIT_FOREVER} to retry forever </param>
/// <returns> true if lock was obtained </returns>
/// <exception cref="LockObtainFailedException"> if lock wait times out </exception>
/// <exception cref="IllegalArgumentException"> if lockWaitTimeout is
/// out of bounds </exception>
/// <exception cref="System.IO.IOException"> if obtain() throws System.IO.IOException </exception>
public bool Obtain(long lockWaitTimeout)
{
FailureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
{
throw new System.ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
}
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
string reason = "Lock obtain timed out: " + this.ToString();
if (FailureReason != null)
{
reason += ": " + FailureReason;
}
LockObtainFailedException e = new LockObtainFailedException(reason);
e = FailureReason != null
? new LockObtainFailedException(reason, FailureReason)
: new LockObtainFailedException(reason);
throw e;
}
try
{
Thread.Sleep(TimeSpan.FromMilliseconds(LOCK_POLL_INTERVAL));
}
catch (ThreadInterruptedException ie)
{
throw new ThreadInterruptedException(ie);
}
locked = Obtain();
}
return locked;
}
/// <summary>Attempts to obtain an exclusive lock within amount of
/// time given. Polls once per {@link #LOCK_POLL_INTERVAL}
/// (currently 1000) milliseconds until lockWaitTimeout is
/// passed.
/// </summary>
/// <param name="lockWaitTimeout">length of time to wait in
/// milliseconds or {@link
/// #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
/// </param>
/// <returns> true if lock was obtained
/// </returns>
/// <throws> LockObtainFailedException if lock wait times out </throws>
/// <throws> IllegalArgumentException if lockWaitTimeout is </throws>
/// <summary> out of bounds
/// </summary>
/// <throws> IOException if obtain() throws IOException </throws>
public virtual bool Obtain(long lockWaitTimeout)
{
failureReason = null;
bool locked = Obtain();
if (lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER)
throw new System.ArgumentException("lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number (got " + lockWaitTimeout + ")");
long maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
long sleepCount = 0;
while (!locked)
{
if (lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ >= maxSleepCount)
{
System.String reason = "Lock obtain timed out: " + this.ToString();
if (failureReason != null)
{
reason += (": " + failureReason);
}
LockObtainFailedException e;
if (failureReason != null)
{
e = new LockObtainFailedException(reason, failureReason);
}
else
{
e = new LockObtainFailedException(reason);
}
throw e;
}
try
{
System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * LOCK_POLL_INTERVAL));
}
catch (System.Threading.ThreadInterruptedException e)
{
throw new System.IO.IOException(e.ToString());
}
locked = Obtain();
}
return locked;
}
