/// <summary> Commit changes resulting from delete, undeleteAll, or
/// setNorm operations
///
/// If an exception is hit, then either no changes or all
/// changes will have been committed to the index
/// (transactional semantics).
/// </summary>
/// <throws> IOException if there is a low-level IO error </throws>
protected internal override void DoCommit()
{
if (hasChanges)
{
if (segmentInfos != null)
{
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
IndexFileDeleter deleter = new IndexFileDeleter(directory, deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy, segmentInfos, null, null);
// Checkpoint the state we are about to change, in
// case we have to roll back:
StartCommit();
bool success = false;
try
{
CommitChanges();
segmentInfos.Write(directory);
success = true;
}
finally
{
if (!success)
{
// Rollback changes that were made to
// SegmentInfos but failed to get [fully]
// committed. This way this reader instance
// remains consistent (matched to what's
// actually in the index):
RollbackCommit();
// Recompute deletable files & remove them (so
// partially written .del files, etc, are
// removed):
deleter.Refresh();
}
}
// Have the deleter remove any now unreferenced
// files due to this commit:
deleter.Checkpoint(segmentInfos, true);
if (writeLock != null)
{
writeLock.Release(); // release write lock
writeLock = null;
}
}
else
CommitChanges();
}
hasChanges = false;
}
/// <summary> Commit changes resulting from delete, undeleteAll, or
/// setNorm operations
///
/// If an exception is hit, then either no changes or all
/// changes will have been committed to the index
/// (transactional semantics).
/// </summary>
/// <throws> IOException if there is a low-level IO error </throws>
protected internal override void DoCommit()
{
if (hasChanges)
{
if (segmentInfos != null)
{
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
IndexFileDeleter deleter = new IndexFileDeleter(directory, deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy, segmentInfos, null, null);
// Checkpoint the state we are about to change, in
// case we have to roll back:
StartCommit();
bool success = false;
try
{
CommitChanges();
// sync all the files we just wrote
for (int i = 0; i < segmentInfos.Count; i++)
{
SegmentInfo info = segmentInfos.Info(i);
IList<string> files = info.Files();
for (int j = 0; j < files.Count; j++)
{
string fileName = files[j];
if (!synced.ContainsKey(fileName))
{
System.Diagnostics.Debug.Assert(directory.FileExists(fileName));
directory.Sync(fileName);
synced[fileName] = fileName;
}
}
}
segmentInfos.Commit(directory);
success = true;
}
finally
{
if (!success)
{
// Rollback changes that were made to
// SegmentInfos but failed to get [fully]
// committed. This way this reader instance
// remains consistent (matched to what's
// actually in the index):
RollbackCommit();
// Recompute deletable files & remove them (so
// partially written .del files, etc, are
// removed):
deleter.Refresh();
}
}
// Have the deleter remove any now unreferenced
// files due to this commit:
deleter.Checkpoint(segmentInfos, true);
if (writeLock != null)
{
writeLock.Release(); // release write lock
writeLock = null;
}
}
else
CommitChanges();
}
hasChanges = false;
}
/// <summary> Commit changes resulting from delete, undeleteAll, or setNorm operations
/// <p/>
/// If an exception is hit, then either no changes or all changes will have been committed to the index (transactional
/// semantics).
///
/// </summary>
/// <throws> IOException if there is a low-level IO error </throws>
protected internal override void DoCommit(IDictionary<string, string> commitUserData)
{
if (hasChanges)
{
segmentInfos.UserData = commitUserData;
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
var deleter = new IndexFileDeleter(internalDirectory, deletionPolicy ?? new KeepOnlyLastCommitDeletionPolicy(), segmentInfos, null, null, synced);
segmentInfos.UpdateGeneration(deleter.LastSegmentInfos);
// Checkpoint the state we are about to change, in
// case we have to roll back:
StartCommit();
bool success = false;
try
{
foreach (SegmentReader t in subReaders)
t.Commit();
// Sync all files we just wrote
foreach(string fileName in segmentInfos.Files(internalDirectory, false))
{
if(!synced.Contains(fileName))
{
System.Diagnostics.Debug.Assert(internalDirectory.FileExists(fileName));
internalDirectory.Sync(fileName);
synced.Add(fileName);
}
}
segmentInfos.Commit(internalDirectory);
success = true;
}
finally
{
if (!success)
{
// Rollback changes that were made to
// SegmentInfos but failed to get [fully]
// committed. This way this reader instance
// remains consistent (matched to what's
// actually in the index):
RollbackCommit();
// Recompute deletable files & remove them (so
// partially written .del files, etc, are
// removed):
deleter.Refresh();
}
}
// Have the deleter remove any now unreferenced
// files due to this commit:
deleter.Checkpoint(segmentInfos, true);
deleter.Dispose();
maxIndexVersion = segmentInfos.Version;
if (writeLock != null)
{
writeLock.Release(); // release write lock
writeLock = null;
}
}
hasChanges = false;
}
/// <summary> Commit changes resulting from delete, undeleteAll, or
/// setNorm operations
///
/// If an exception is hit, then either no changes or all
/// changes will have been committed to the index
/// (transactional semantics).
/// </summary>
/// <throws> IOException if there is a low-level IO error </throws>
protected internal override void DoCommit()
{
if (hasChanges)
{
if (segmentInfos != null)
{
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
IndexFileDeleter deleter = new IndexFileDeleter(directory, deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy, segmentInfos, null, null);
// Checkpoint the state we are about to change, in
// case we have to roll back:
StartCommit();
bool success = false;
try
{
CommitChanges();
// sync all the files we just wrote
for (int i = 0; i < segmentInfos.Count; i++)
{
SegmentInfo info = segmentInfos.Info(i);
IList <string> files = info.Files();
for (int j = 0; j < files.Count; j++)
{
string fileName = files[j];
if (!synced.ContainsKey(fileName))
{
System.Diagnostics.Debug.Assert(directory.FileExists(fileName));
directory.Sync(fileName);
synced[fileName] = fileName;
}
}
}
segmentInfos.Commit(directory);
success = true;
}
finally
{
if (!success)
{
// Rollback changes that were made to
// SegmentInfos but failed to get [fully]
// committed. This way this reader instance
// remains consistent (matched to what's
// actually in the index):
RollbackCommit();
// Recompute deletable files & remove them (so
// partially written .del files, etc, are
// removed):
deleter.Refresh();
}
}
// Have the deleter remove any now unreferenced
// files due to this commit:
deleter.Checkpoint(segmentInfos, true);
if (writeLock != null)
{
writeLock.Release(); // release write lock
writeLock = null;
}
}
else
{
CommitChanges();
}
}
hasChanges = false;
}
/// <summary> Commit changes resulting from delete, undeleteAll, or setNorm operations
/// <p/>
/// If an exception is hit, then either no changes or all changes will have been committed to the index (transactional
/// semantics).
///
/// </summary>
/// <throws> IOException if there is a low-level IO error </throws>
protected internal override void DoCommit(System.Collections.IDictionary commitUserData)
{
if (hasChanges)
{
segmentInfos.SetUserData(commitUserData);
// Default deleter (for backwards compatibility) is
// KeepOnlyLastCommitDeleter:
IndexFileDeleter deleter = new IndexFileDeleter(directory, deletionPolicy == null?new KeepOnlyLastCommitDeletionPolicy():deletionPolicy, segmentInfos, null, null);
// Checkpoint the state we are about to change, in
// case we have to roll back:
StartCommit();
bool success = false;
try
{
for (int i = 0; i < subReaders.Length; i++)
subReaders[i].Commit();
// Sync all files we just wrote
System.Collections.IEnumerator it = segmentInfos.Files(directory, false).GetEnumerator();
while (it.MoveNext())
{
System.String fileName = (string)((System.Collections.DictionaryEntry) it.Current).Value;
if (!synced.Contains(fileName))
{
System.Diagnostics.Debug.Assert(directory.FileExists(fileName));
directory.Sync(fileName);
SupportClass.CollectionsHelper.AddIfNotContains(synced, fileName);
}
}
segmentInfos.Commit(directory);
success = true;
}
finally
{
if (!success)
{
// Rollback changes that were made to
// SegmentInfos but failed to get [fully]
// committed. This way this reader instance
// remains consistent (matched to what's
// actually in the index):
RollbackCommit();
// Recompute deletable files & remove them (so
// partially written .del files, etc, are
// removed):
deleter.Refresh();
}
}
// Have the deleter remove any now unreferenced
// files due to this commit:
deleter.Checkpoint(segmentInfos, true);
deleter.Close();
if (writeLock != null)
{
writeLock.Release(); // release write lock
writeLock = null;
}
}
hasChanges = false;
}