/// <summary>
/// Given a list of words, re-create the ones that we need to insert.
/// </summary>
/// <param name="words"></param>
/// <param name="token"></param>
/// <returns></returns>
private async Task <IList <long> > InsertWordsAsync(
interfaces.IO.IWords words,
CancellationToken token)
{
// if we have nothing to do... we are done.
if (!words.Any())
{
return(new List <long>());
}
// the ids of the words we just added
var ids = new List <long>(words.Count);
try
{
foreach (var word in words)
{
// get out if needed.
token.ThrowIfCancellationRequested();
// if the word is not valid, there isn't much we can do.
if (!IsValidWord(word))
{
continue;
}
// the word we want to insert.
var wordId = await InsertWordAsync(word, token).ConfigureAwait(false);
if (-1 == wordId)
{
// we log errors in the insert function
continue;
}
// we added this id.
ids.Add(wordId);
}
// all done, return whatever we did.
return(ids);
}
catch (OperationCanceledException)
{
_logger.Warning("Received cancellation request - Insert multiple words");
throw;
}
catch (Exception ex)
{
_logger.Exception(ex);
throw;
}
}
private async Task <IConnectionFactory> BeginWrite(bool createTransaction, int timeoutMs, CancellationToken token)
{
// set the value
try
{
if (null == _transactionSpinner)
{
throw new InvalidOperationException("You cannot start using the database as it has not started yet.");
}
var factory = await _transactionSpinner.BeginWrite(() => new SqliteReadWriteConnectionFactory(createTransaction, _config), timeoutMs, token).ConfigureAwait(false);
PrepareTransaction(factory);
return(factory);
}
catch (TimeoutException)
{
throw;
}
catch (OperationCanceledException e)
{
_logger.Warning("Received cancellation request - Getting count value.");
// is it my token?
if (e.CancellationToken != token)
{
_logger.Exception(e);
}
throw;
}
catch (Exception e)
{
_logger.Exception(e);
throw;
}
}
/// <summary>
/// The call back function to check if we are parsing that directory or not.
/// </summary>
/// <param name="directory"></param>
/// <returns></returns>
private bool ParseDirectory(DirectoryInfo directory)
{
if (!helper.File.CanReadDirectory(directory))
{
_logger.Warning($"Cannot Parse Directory: {directory.FullName}");
return false;
}
if (!helper.File.IsSubDirectory(IgnorePaths, directory))
{
// we will be parsing it and the sub-directories.
return true;
}
// we are ignoreing this.
_logger.Verbose($"Ignoring: {directory.FullName} and sub-directories.");
// we are not parsing this
return false;
}
/// <inheritdoc />
public Task WorkAsync(CancellationToken token)
{
lock (_taskLock)
{
// are we still running the start?
if (!_runningTask?.IsCompleted ?? true)
{
return(Task.CompletedTask);
}
}
try
{
lock (_taskLock)
{
// we can re-parse everthing
_runningTask = ParseAllDirectoriesAsync(token);
}
return(_runningTask);
}
catch (OperationCanceledException)
{
_logger.Warning("Files/Folder parser processor: Received cancellation request - Work");
throw;
}
catch (Exception e)
{
_logger.Exception("There was an exception re-parsing the directories.", e);
throw;
}
}