public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_map = IndexMap.FromFile(GetTempFilePath(), x => false);
_map.EnterUnsafeState(PathName);
_map.LeaveUnsafeState(PathName);
}
public void Setup()
{
_map = IndexMap.FromFile(_file, x => false);
var directory = new FileInfo(_file).DirectoryName;
_map.EnterUnsafeState(directory);
_map.LeaveUnsafeState(directory);
}
private void ReadOffQueue()
{
_backgroundRunningEvent.Reset();
try
{
while (true)
{
TableItem tableItem;
//ISearchTable table;
lock (_awaitingTablesLock)
{
Log.Trace("Awaiting tables queue size is: {0}.", _awaitingMemTables.Count);
if (_awaitingMemTables.Count == 1)
{
_backgroundRunning = false;
return;
}
tableItem = _awaitingMemTables[_awaitingMemTables.Count - 1];
}
PTable ptable;
var memtable = tableItem.Table as IMemTable;
if (memtable != null)
{
memtable.MarkForConversion();
ptable = PTable.FromMemtable(memtable, _fileNameProvider.GetFilenameNewTable());
}
else
ptable = (PTable) tableItem.Table;
_indexMap.EnterUnsafeState(_directory);
var mergeResult = _indexMap.AddFile(ptable,
tableItem.PrepareCheckpoint,
tableItem.CommitCheckpoint,
_fileNameProvider);
_indexMap = mergeResult.MergedMap;
_indexMap.SaveToFile(Path.Combine(_directory, IndexMapFilename));
_indexMap.LeaveUnsafeState(_directory);
lock (_awaitingTablesLock)
{
//oh well at least its only a small lock that is very unlikely to ever be hit
var memTables = _awaitingMemTables.ToList();
var corrTable = memTables.First(x => x.Table.Id == ptable.Id);
memTables.Remove(corrTable);
// parallel thread could already switch table,
// so if we have another PTable instance with same ID,
// we need to kill that instance as we added ours already
if (!ReferenceEquals(corrTable.Table, ptable) && corrTable.Table is PTable)
((PTable)corrTable.Table).MarkForDestruction();
Log.Trace("There are now {0} awaiting tables.", memTables.Count);
_awaitingMemTables = memTables;
}
mergeResult.ToDelete.ForEach(x => x.MarkForDestruction());
}
}
finally
{
_backgroundRunning = false;
_backgroundRunningEvent.Set();
}
}
private void ReadOffQueue()
{
try
{
while (true)
{
TableItem tableItem;
//ISearchTable table;
lock (_awaitingTablesLock)
{
Log.Trace("Awaiting tables queue size is: {0}.", _awaitingMemTables.Count);
if (_awaitingMemTables.Count == 1)
{
_backgroundRunning = false;
_backgroundRunningEvent.Set();
return;
}
tableItem = _awaitingMemTables[_awaitingMemTables.Count - 1];
}
PTable ptable;
var memtable = tableItem.Table as IMemTable;
if (memtable != null)
{
memtable.MarkForConversion();
ptable = PTable.FromMemtable(memtable, _fileNameProvider.GetFilenameNewTable());
}
else
{
ptable = (PTable)tableItem.Table;
}
_indexMap.EnterUnsafeState(_directory);
var mergeResult = _indexMap.AddFile(ptable,
tableItem.PrepareCheckpoint,
tableItem.CommitCheckpoint,
_fileNameProvider);
_indexMap = mergeResult.MergedMap;
_indexMap.SaveToFile(Path.Combine(_directory, IndexMapFilename));
_indexMap.LeaveUnsafeState(_directory);
lock (_awaitingTablesLock)
{
//oh well at least its only a small lock that is very unlikely to ever be hit
var memTables = _awaitingMemTables.ToList();
var corrTable = memTables.First(x => x.Table.Id == ptable.Id);
memTables.Remove(corrTable);
// parallel thread could already switch table,
// so if we have another PTable instance with same ID,
// we need to kill that instance as we added ours already
if (!ReferenceEquals(corrTable.Table, ptable) && corrTable.Table is PTable)
{
((PTable)corrTable.Table).MarkForDestruction();
}
Log.Trace("There are now {0} awaiting tables.", memTables.Count);
_awaitingMemTables = memTables;
}
mergeResult.ToDelete.ForEach(x => x.MarkForDestruction());
}
}
catch (Exception exc)
{
Log.ErrorException(exc, "Error in TableIndex.ReadOffQueue");
throw;
}
}
