public async Task <IReadOnlyList <EntityCommit <PackageEntity> > > GetCommitsAsync(
QueryEntities <PackageEntity> queryEntities,
DateTimeOffset start,
DateTimeOffset end,
int batchSize)
{
return(await EnumeratorUtility.GetCommitsAsync(
(s, e, b) => GetRangeAsync(queryEntities, s, e, b),
x => x.CatalogPackage.LastCommitTimestamp,
InitializePackageCommit,
start,
end,
batchSize));
}
private async Task <IReadOnlyList <PackageEntity> > GetRangeAsync(
QueryEntities <PackageEntity> queryEntities,
long start,
long end,
int batchSize)
{
using (var entities = new EntityContext())
{
return(await queryEntities(entities)
.Include(x => x.PackageRegistration)
.Include(x => x.CatalogPackage)
.Where(x => x.CatalogPackage != null)
.Where(x => x.CatalogPackage.LastCommitTimestamp > start && x.CatalogPackage.LastCommitTimestamp <= end)
.OrderBy(x => x.CatalogPackage.LastCommitTimestamp)
.Take(batchSize)
.ToListAsync());
}
}
/// <summary>
/// Copies the local properties (properties that are not written in Write method).
/// </summary>
private void CopyLocalProperties(CacheClientConfiguration cfg)
{
Debug.Assert(cfg != null);
if (QueryEntities != null && cfg.QueryEntities != null)
{
var entities = cfg.QueryEntities.Where(x => x != null).ToDictionary(x => GetQueryEntityKey(x), x => x);
foreach (var entity in QueryEntities.Where(x => x != null))
{
QueryEntity src;
if (entities.TryGetValue(GetQueryEntityKey(entity), out src))
{
entity.CopyLocalProperties(src);
}
}
}
}
private async Task <IReadOnlyDictionary <string, long> > AddOrUpdatePackagesAsync <T>(
QueryEntities <PackageEntity> getPackages,
IEnumerable <T> foreignPackages,
Func <IEnumerable <T>, IEnumerable <T> > sort,
Func <T, string> getId,
Func <T, string> getVersion,
Func <PackageEntity, T, Task> initializePackageFromForeignAsync,
Func <PackageEntity, T, Task> updatePackageFromForeignAsync,
Action <EntityContext, PackageEntity, PackageEntity> updateExistingPackage)
{
using (var entityContext = new EntityContext())
{
var packageRegistrations = await AddPackageRegistrationsAsync(
entityContext,
foreignPackages.Select(getId),
includePackages : false);
// Create a mapping from package identity to latest package.
var identityToLatest = new Dictionary <string, PackageEntity>(StringComparer.OrdinalIgnoreCase);
foreach (var foreignPackage in foreignPackages)
{
var id = getId(foreignPackage);
var version = NuGetVersion.Parse(getVersion(foreignPackage)).ToNormalizedString();
var identity = $"{id}/{version}";
if (!identityToLatest.TryGetValue(identity, out var latestPackage))
{
latestPackage = new PackageEntity
{
PackageRegistration = packageRegistrations[id],
Version = version,
Identity = identity,
};
await initializePackageFromForeignAsync(latestPackage, foreignPackage);
identityToLatest[latestPackage.Identity] = latestPackage;
}
else
{
await updatePackageFromForeignAsync(latestPackage, foreignPackage);
}
}
var getExistingStopwatch = Stopwatch.StartNew();
var identities = identityToLatest.Keys.ToList();
var existingPackages = await getPackages(entityContext)
.Where(p => identities.Contains(p.Identity))
.ToListAsync();
_logger.LogInformation(
"Got {ExistingCount} existing. {ElapsedMilliseconds}ms",
existingPackages.Count,
getExistingStopwatch.ElapsedMilliseconds);
// Keep track of the resulting package keys.
var identityToPackageKey = new Dictionary <string, long>(StringComparer.OrdinalIgnoreCase);
// Update existing records.
foreach (var existingPackage in existingPackages)
{
var latestPackage = identityToLatest[existingPackage.Identity];
identityToLatest.Remove(existingPackage.Identity);
updateExistingPackage(entityContext, existingPackage, latestPackage);
identityToPackageKey.Add(existingPackage.Identity, existingPackage.PackageKey);
}
// Add new records.
await entityContext.Packages.AddRangeAsync(identityToLatest.Values);
// Commit the changes.
var commitStopwatch = Stopwatch.StartNew();
var changes = await entityContext.SaveChangesAsync();
_logger.LogInformation(
"Committed {Changes} changes. {ElapsedMilliseconds}ms",
changes,
commitStopwatch.ElapsedMilliseconds);
// Add the new package keys.
foreach (var pair in identityToLatest)
{
identityToPackageKey.Add(pair.Key, pair.Value.PackageKey);
}
return(identityToPackageKey);
}
}
public QueryEntitiesResponse QueryEntities(string environmentId, string collectionId, QueryEntities entityQuery)
{
try
{
var result = DiscoveryRepository.QueryEntities(environmentId, collectionId, entityQuery);
return(result);
}
catch (Exception ex)
{
Logger.Error("DiscoveryService.QueryEntities failed", this, ex);
}
return(null);
}
