public async Task <HashSet <string> > GetVerifiedPackagesAsync()
{
var stopwatch = Stopwatch.StartNew();
using (var connection = await _connectionFactory.OpenAsync())
using (var command = connection.CreateCommand())
{
command.CommandText = GetVerifiedPackagesSql;
using (var reader = await command.ExecuteReaderAsync())
{
var output = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
while (await reader.ReadAsync())
{
var id = reader.GetString(0);
output.Add(id);
}
stopwatch.Stop();
_telemetryService.TrackReadLatestVerifiedPackagesFromDatabase(output.Count, stopwatch.Elapsed);
return(output);
}
}
}
public async Task <FeedPackageDetails> GetPackageOrNull(string id, string version)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
var packages = new List <FeedPackageDetails>();
var packageQuery = BuildGetPackageSqlQuery();
using (var sqlConnection = await _connectionFactory.OpenAsync())
{
#pragma warning disable CA2100 // Review SQL queries for security vulnerabilities
using (var packagesCommand = new SqlCommand(packageQuery, sqlConnection)
{
CommandTimeout = _commandTimeout
})
#pragma warning restore CA2100 // Review SQL queries for security vulnerabilities
{
packagesCommand.Parameters.AddWithValue(PackageIdParameterName, id);
packagesCommand.Parameters.AddWithValue(PackageVersionParameterName, version);
using (_telemetryService.TrackGetPackageQueryDuration(id, version))
{
return((await ReadPackagesAsync(packagesCommand)).SingleOrDefault());
}
}
}
}
public async Task <FeedPackageDetails> GetPackageOrNull(string id, string version)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
var packages = new List <FeedPackageDetails>();
var packageQuery = BuildGetPackageSqlQuery();
using (var sqlConnection = await _connectionFactory.OpenAsync())
{
using (var packagesCommand = new SqlCommand(packageQuery, sqlConnection)
{
CommandTimeout = _commandTimeout
})
{
packagesCommand.Parameters.AddWithValue(PackageIdParameterName, id);
packagesCommand.Parameters.AddWithValue(PackageVersionParameterName, version);
using (_telemetryService.TrackGetPackageQueryDuration(id, version))
{
using (var packagesReader = await packagesCommand.ExecuteReaderAsync())
{
while (await packagesReader.ReadAsync())
{
packages.Add(_db2catalogProjection.ReadFeedPackageDetailsFromDataReader(packagesReader));
}
}
}
}
}
return(packages.SingleOrDefault());
}
public async Task AddPackageRevalidationsAsync(IReadOnlyList <PackageRevalidation> revalidations)
{
_logger.LogDebug("Persisting package revalidations to database...");
var table = PrepareTable(revalidations);
using (var connection = await _connectionFactory.OpenAsync())
{
var bulkCopy = new SqlBulkCopy(
connection,
SqlBulkCopyOptions.TableLock | SqlBulkCopyOptions.FireTriggers | SqlBulkCopyOptions.UseInternalTransaction,
externalTransaction: null);
foreach (DataColumn column in table.Columns)
{
bulkCopy.ColumnMappings.Add(column.ColumnName, column.ColumnName);
}
bulkCopy.DestinationTableName = TableName;
bulkCopy.WriteToServer(table);
}
_logger.LogDebug("Finished persisting package revalidations to database...");
}
protected async Task BackgroundProcessing(CancellationToken cancellationToken)
{
bool hasItems = true;
while (!cancellationToken.IsCancellationRequested)
{
try
{
var allItems = new List <QueueItem>();
using (var connection = sqlConnectionFactory.GetConnection())
{
await sqlConnectionFactory.OpenAsync(connection, cancellationToken);
if (!hasItems)
{
hasItems = await queueItemRepository.HasItems(connection);
if (!hasItems)
{
logger.LogInformation($"No items to process, going to sleep for {config.NoQueueItemsToProcessSleepTimeMS} milliseconds");
await Task.Delay(config.NoQueueItemsToProcessSleepTimeMS, cancellationToken);
sqlConnectionFactory.Close(connection);
continue;
}
}
var workers = await queueWorkerRepository.GetQueueWorkers(connection);
foreach (var worker in workers.Where(w => w.Enabled).OrderByDescending(w => w.Priority))
{
var items = await queueItemRepository.GetQueueItems(connection, worker.Id, worker.Retries, worker.BatchSize);
items.ForEach(i => i.QueueWorker = worker);
allItems.AddRange(items);
if (allItems.Count > config.GlobalBatchSizeLimit)
{
break;
}
}
sqlConnectionFactory.Close(connection);
}
if (!allItems.Any())
{
logger.LogInformation($"No items to process, going to sleep for {config.NoQueueItemsToProcessSleepTimeMS} milliseconds");
hasItems = false;
await Task.Delay(config.NoQueueItemsToProcessSleepTimeMS, cancellationToken);
continue;
}
var allTasks = new List <Task>();
foreach (var item in allItems.OrderByDescending(i => i.QueueWorker.Priority).ThenBy(i => i.Id))
{
allTasks.Add(ProcessItem(item, cancellationToken));
}
await Task.WhenAll(allTasks);
}
catch (Exception ex)
{
logger.LogError(ex, $"Error processing queue.");
await Task.Delay(config.NoQueueItemsToProcessSleepTimeMS, cancellationToken);
}
}
logger.LogInformation("QueueProcessor Service is cancelled.");
}
