/// <summary>Calls <see cref="DoBody" /> while <i>lock</i> is obtained. Blocks if lock
/// cannot be obtained immediately. Retries to obtain lock once per second
/// until it is obtained, or until it has tried ten times. Lock is released when
/// <see cref="DoBody" /> exits.
/// </summary>
/// <throws> LockObtainFailedException if lock could not </throws>
/// <summary> be obtained
/// </summary>
/// <throws> IOException if <see cref="Lock.Obtain(long)" /> throws IOException </throws>
public virtual System.Object run()
{
bool locked = false;
try
{
locked = lock_Renamed.Obtain(lockWaitTimeout);
return(DoBody());
}
finally
{
if (locked)
{
lock_Renamed.Release();
}
}
}
private void Init(Directory d, Analyzer a, bool create, IndexDeletionPolicy deletionPolicy, int maxFieldLength, DocumentsWriter.IndexingChain indexingChain, IndexCommit commit)
{
directory = d;
analyzer = a;
SetMessageID(defaultInfoStream);
this.maxFieldLength = maxFieldLength;
if (indexingChain == null)
indexingChain = DocumentsWriter.DefaultIndexingChain;
if (create)
{
// Clear the write lock in case it's leftover:
directory.ClearLock(WRITE_LOCK_NAME);
}
Lock writeLock = directory.MakeLock(WRITE_LOCK_NAME);
if (!writeLock.Obtain(writeLockTimeout))
// obtain write lock
{
throw new LockObtainFailedException("Index locked for write: " + writeLock);
}
this.writeLock = writeLock; // save it
bool success = false;
try
{
if (create)
{
// Try to read first. This is to allow create
// against an index that's currently open for
// searching. In this case we write the next
// segments_N file with no segments:
bool doCommit;
try
{
segmentInfos.Read(directory);
segmentInfos.Clear();
doCommit = false;
}
catch (System.IO.IOException)
{
// Likely this means it's a fresh directory
doCommit = true;
}
if (doCommit)
{
// Only commit if there is no segments file
// in this dir already.
segmentInfos.Commit(directory);
synced.UnionWith(segmentInfos.Files(directory, true));
}
else
{
// Record that we have a change (zero out all
// segments) pending:
changeCount++;
}
}
else
{
segmentInfos.Read(directory);
if (commit != null)
{
// Swap out all segments, but, keep metadata in
// SegmentInfos, like version & generation, to
// preserve write-once. This is important if
// readers are open against the future commit
// points.
if (commit.Directory != directory)
throw new System.ArgumentException("IndexCommit's directory doesn't match my directory");
SegmentInfos oldInfos = new SegmentInfos();
oldInfos.Read(directory, commit.SegmentsFileName);
segmentInfos.Replace(oldInfos);
changeCount++;
if (infoStream != null)
Message("init: loaded commit \"" + commit.SegmentsFileName + "\"");
}
// We assume that this segments_N was previously
// properly sync'd:
synced.UnionWith(segmentInfos.Files(directory, true));
}
SetRollbackSegmentInfos(segmentInfos);
docWriter = new DocumentsWriter(directory, this, indexingChain);
docWriter.SetInfoStream(infoStream);
docWriter.SetMaxFieldLength(maxFieldLength);
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
deleter = new IndexFileDeleter(directory, deletionPolicy == null?new KeepOnlyLastCommitDeletionPolicy():deletionPolicy, segmentInfos, infoStream, docWriter, synced);
if (deleter.startingCommitDeleted)
// Deletion policy deleted the "head" commit point.
// We have to mark ourself as changed so that if we
// are closed w/o any further changes we write a new
// segments_N file.
changeCount++;
PushMaxBufferedDocs();
if (infoStream != null)
{
Message("init: create=" + create);
MessageState();
}
success = true;
}
finally
{
if (!success)
{
if (infoStream != null)
{
Message("init: hit exception on init; releasing write lock");
}
try
{
writeLock.Release();
}
catch (Exception)
{
// don't mask the original exception
}
writeLock = null;
}
}
}
public static void Main(System.String[] args)
{
if (args.Length != 6)
{
System.Console.Out.WriteLine("\nUsage: java Lucene.Net.Store.LockStressTest myID verifierHostOrIP verifierPort lockFactoryClassName lockDirName sleepTime\n" + "\n" + " myID = int from 0 .. 255 (should be unique for test process)\n" + " verifierHostOrIP = host name or IP address where LockVerifyServer is running\n" + " verifierPort = port that LockVerifyServer is listening on\n" + " lockFactoryClassName = primary LockFactory class that we will use\n" + " lockDirName = path to the lock directory (only set for Simple/NativeFSLockFactory\n" + " sleepTimeMS = milliseconds to pause betweeen each lock obtain/release\n" + "\n" + "You should run multiple instances of this process, each with its own\n" + "unique ID, and each pointing to the same lock directory, to verify\n" + "that locking is working correctly.\n" + "\n" + "Make sure you are first running LockVerifyServer.\n" + "\n");
System.Environment.Exit(1);
}
int myID = System.Int32.Parse(args[0]);
if (myID < 0 || myID > 255)
{
System.Console.Out.WriteLine("myID must be a unique int 0..255");
System.Environment.Exit(1);
}
System.String verifierHost = args[1];
int verifierPort = System.Int32.Parse(args[2]);
System.String lockFactoryClassName = args[3];
System.String lockDirName = args[4];
int sleepTimeMS = System.Int32.Parse(args[5]);
System.Type c;
try
{
c = System.Type.GetType(lockFactoryClassName);
}
catch (System.Exception)
{
throw new System.IO.IOException("unable to find LockClass " + lockFactoryClassName);
}
LockFactory lockFactory;
try
{
lockFactory = (LockFactory)System.Activator.CreateInstance(c);
}
catch (System.UnauthorizedAccessException)
{
throw new System.IO.IOException("IllegalAccessException when instantiating LockClass " + lockFactoryClassName);
}
catch (System.InvalidCastException)
{
throw new System.IO.IOException("unable to cast LockClass " + lockFactoryClassName + " instance to a LockFactory");
}
catch (System.Exception)
{
throw new System.IO.IOException("InstantiationException when instantiating LockClass " + lockFactoryClassName);
}
System.IO.DirectoryInfo lockDir = new System.IO.DirectoryInfo(lockDirName);
if (lockFactory is NativeFSLockFactory)
{
((NativeFSLockFactory)lockFactory).LockDir = lockDir;
}
else if (lockFactory is SimpleFSLockFactory)
{
((SimpleFSLockFactory)lockFactory).LockDir = lockDir;
}
lockFactory.LockPrefix = "test";
LockFactory verifyLF = new VerifyingLockFactory((sbyte)myID, lockFactory, verifierHost, verifierPort);
Lock l = verifyLF.MakeLock("test.lock");
while (true)
{
bool obtained = false;
try
{
obtained = l.Obtain(10);
}
catch (LockObtainFailedException)
{
System.Console.Out.Write("x");
}
if (obtained)
{
System.Console.Out.Write("l");
l.Release();
}
System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * sleepTimeMS));
}
}
