разные правки по беку
This commit is contained in:
gorbenko.pavel
+125
@@ -0,0 +1,125 @@
|
||||
using Hangfire;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Tnsu.ApprovalRoute.Domain.Entities;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.Persistence;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.SharePoint;
|
||||
|
||||
namespace Tnsu.ApprovalRoute.Application.ListPartitioning;
|
||||
|
||||
/// <summary>
|
||||
/// Фоновая задача: создать следующую партицию списка по типу заявок, записать её в
|
||||
/// реестр и переключить на неё запись.
|
||||
///
|
||||
/// Блокировка захватывается ЗДЕСЬ, при каждом запуске (в т.ч. на каждой повторной
|
||||
/// попытке Hangfire), а не в момент постановки в очередь. Enqueue и фактическое
|
||||
/// выполнение — разные события во времени: задача может полежать в очереди, быть
|
||||
/// повторена автоматически после сбоя, в теории — перезапущена вручную из дашборда.
|
||||
/// Всё это заново становится тем же самым «выполнением» с точки зрения Hangfire, но
|
||||
/// не с точки зрения блокировки: settled только выполнение может её удержать, и
|
||||
/// проверять это надо на каждом фактическом входе в код, создающий список в
|
||||
/// SharePoint, а не один раз на входе в очередь. Иначе, к примеру, зависший на
|
||||
/// повторе процесс и новый независимый триггер (например, второй HTTP-запрос,
|
||||
/// поймавший тот же порог до переключения списка) синхронизировались бы неверно.
|
||||
///
|
||||
/// Повторы разрешены, но их немного: провижинер идемпотентен (переиспользует список
|
||||
/// с целевым именем и дозаполняет колонки), поэтому повтор после частичного сбоя
|
||||
/// безопасен и не создаёт вторую партицию. Больше трёх попыток смысла нет — если
|
||||
/// SharePoint отвечает ошибкой стабильно, задача должна остаться видимой в Hangfire,
|
||||
/// а не молотить впустую.
|
||||
/// </summary>
|
||||
[AutomaticRetry(Attempts = 3)]
|
||||
public sealed class CreateNextListPartitionJob(
|
||||
ApprovalRouteDbContext db,
|
||||
ListPartitioningLock provisioningLock,
|
||||
ListPartitionRegistry registry,
|
||||
ISharePointListProvisioner provisioner,
|
||||
IOptions<ListPartitioningOptions> options,
|
||||
ILogger<CreateNextListPartitionJob> logger)
|
||||
{
|
||||
public async Task RunAsync(int requestTypeId, CancellationToken cancellationToken)
|
||||
{
|
||||
// Единственная настоящая защита от параллельного запуска: атомарный захват
|
||||
// флага в строке request_types. Проверка перед постановкой в очередь —
|
||||
// только чтобы не плодить лишние задачи; гонку разруливает именно здесь.
|
||||
if (!await provisioningLock.TryAcquireAsync(
|
||||
requestTypeId, options.Value.StaleLockAfter, cancellationToken))
|
||||
{
|
||||
logger.LogInformation(
|
||||
"Провижининг списка для типа заявок {RequestTypeId} уже идёт — задача пропущена.",
|
||||
requestTypeId);
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var requestType = await db.RequestTypes
|
||||
.FirstOrDefaultAsync(x => x.Id == requestTypeId, cancellationToken);
|
||||
|
||||
if (requestType is null)
|
||||
{
|
||||
logger.LogWarning("Тип заявок {RequestTypeId} не найден — провижининг отменён.", requestTypeId);
|
||||
return;
|
||||
}
|
||||
|
||||
if (string.IsNullOrWhiteSpace(requestType.ListId) || string.IsNullOrWhiteSpace(requestType.SiteUrl))
|
||||
{
|
||||
logger.LogWarning(
|
||||
"У типа заявок {RequestTypeId} не настроен список SharePoint — провижининг отменён.",
|
||||
requestTypeId);
|
||||
return;
|
||||
}
|
||||
|
||||
// Задачу могли поставить раньше, чем реестр успел узнать про текущую
|
||||
// партицию (например, ручным запуском) — регистрируем её, иначе серия
|
||||
// осталась бы без своего первого номера.
|
||||
var current = await registry.EnsureCurrentRegisteredAsync(requestType, cancellationToken);
|
||||
|
||||
var maxNumber = await db.RequestListPartitions
|
||||
.Where(x => x.RequestTypeId == requestTypeId)
|
||||
.MaxAsync(x => (int?)x.Number, cancellationToken) ?? current.Number;
|
||||
|
||||
var nextNumber = maxNumber + 1;
|
||||
|
||||
logger.LogInformation(
|
||||
"Создаю партицию №{Number} для типа заявок {RequestTypeId} по структуре {SourceListId}.",
|
||||
nextNumber, requestTypeId, requestType.ListId);
|
||||
|
||||
// Партиция всегда создаётся на том же сайте, что и текущая (см. комментарий
|
||||
// на RequestListPartition о недопустимости разъезда серии по сайтам) — сайт
|
||||
// берём из RequestType, а не откуда-либо ещё, так что расхождение
|
||||
// структурно невозможно.
|
||||
var created = await provisioner.CreateNextListPairAsync(
|
||||
requestType.SiteUrl, requestType.ListId, nextNumber, cancellationToken);
|
||||
|
||||
// Реестр и переключение записи — одной транзакцией: иначе можно остаться
|
||||
// с записанной в реестр партицией, в которую никто не пишет, или наоборот.
|
||||
await using var transaction = await db.Database.BeginTransactionAsync(cancellationToken);
|
||||
|
||||
db.RequestListPartitions.Add(new RequestListPartition
|
||||
{
|
||||
RequestTypeId = requestTypeId,
|
||||
Number = nextNumber,
|
||||
ListId = created.ListId,
|
||||
Title = created.Title,
|
||||
CreatedAt = DateTimeOffset.UtcNow
|
||||
});
|
||||
|
||||
requestType.ListId = created.ListId;
|
||||
|
||||
await db.SaveChangesAsync(cancellationToken);
|
||||
await transaction.CommitAsync(cancellationToken);
|
||||
|
||||
logger.LogInformation(
|
||||
"Партиция №{Number} ({ListId}) создана, запись по типу заявок {RequestTypeId} переключена на неё.",
|
||||
nextNumber, created.ListId, requestTypeId);
|
||||
}
|
||||
finally
|
||||
{
|
||||
// Снимаем блокировку и на успехе, и на исключении: иначе упавшая задача
|
||||
// держала бы тип заблокированным до истечения StaleLockAfter.
|
||||
await provisioningLock.ReleaseAsync(requestTypeId, CancellationToken.None);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
namespace Tnsu.ApprovalRoute.Application.ListPartitioning;
|
||||
|
||||
/// <summary>Одна партиция серии — для админки/портала (вся серия) и для ответа «текущий список».</summary>
|
||||
/// <param name="IsCurrent">
|
||||
/// true — в эту партицию идёт запись новых заявок; остальные партиции серии — архив только для чтения.
|
||||
/// </param>
|
||||
public sealed record RequestListPartitionDto(
|
||||
int Number,
|
||||
string SiteUrl,
|
||||
string ListId,
|
||||
string? Title,
|
||||
bool IsCurrent,
|
||||
DateTimeOffset CreatedAt);
|
||||
|
||||
/// <summary>Вся серия партиций одного типа заявок — единица ответа bulk-эндпоинта для портала.</summary>
|
||||
public sealed record RequestTypeListSeriesDto(
|
||||
int RequestTypeId,
|
||||
IReadOnlyList<RequestListPartitionDto> Partitions);
|
||||
|
||||
/// <summary>Ответ «куда писать новую заявку».</summary>
|
||||
/// <param name="ItemCount">
|
||||
/// Сколько элементов сейчас в списке — по нему видно, насколько он близок к порогу.
|
||||
/// null, если SharePoint не ответил (тогда условие создания следующей партиции не проверялось).
|
||||
/// </param>
|
||||
/// <param name="ProvisioningQueued">
|
||||
/// true — этим запросом поставлена в очередь задача создания следующей партиции серии.
|
||||
/// </param>
|
||||
public sealed record CurrentListPartitionDto(
|
||||
int RequestTypeId,
|
||||
int Number,
|
||||
string SiteUrl,
|
||||
string ListId,
|
||||
string? Title,
|
||||
int? ItemCount = null,
|
||||
bool ProvisioningQueued = false);
|
||||
@@ -0,0 +1,72 @@
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Tnsu.ApprovalRoute.Domain.Entities;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.Persistence;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.SharePoint;
|
||||
|
||||
namespace Tnsu.ApprovalRoute.Application.ListPartitioning;
|
||||
|
||||
/// <summary>
|
||||
/// Наполнение реестра партиций. Вынесено отдельно, потому что нужно и читающему
|
||||
/// эндпоинту, и фоновой задаче: реестр появился позже самих списков, и любой из них
|
||||
/// может встретить тип заявок, которого в реестре ещё нет.
|
||||
/// </summary>
|
||||
public sealed class ListPartitionRegistry(
|
||||
ApprovalRouteDbContext db,
|
||||
ISharePointClient sharePoint,
|
||||
ILogger<ListPartitionRegistry> logger)
|
||||
{
|
||||
/// <summary>
|
||||
/// Гарантирует, что текущая партиция типа заявок есть в реестре, и возвращает её строку.
|
||||
///
|
||||
/// Реестр самозаполняющийся: до этой фичи списки жили только в
|
||||
/// RequestType.ListId, и переключить список руками в админке можно и сейчас.
|
||||
/// Поэтому неизвестный реестру ListId дописывается следующим номером, а не
|
||||
/// считается ошибкой.
|
||||
///
|
||||
/// Требует заполненного ListId — вызывающая сторона это проверяет.
|
||||
/// </summary>
|
||||
public async Task<RequestListPartition> EnsureCurrentRegisteredAsync(
|
||||
RequestType requestType, CancellationToken cancellationToken)
|
||||
{
|
||||
var series = await db.RequestListPartitions
|
||||
.Where(x => x.RequestTypeId == requestType.Id)
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
var existing = series.FirstOrDefault(x => x.ListId == requestType.ListId);
|
||||
if (existing is not null) return existing;
|
||||
|
||||
var entity = new RequestListPartition
|
||||
{
|
||||
RequestTypeId = requestType.Id,
|
||||
Number = series.Count == 0 ? 1 : series.Max(x => x.Number) + 1,
|
||||
ListId = requestType.ListId!,
|
||||
Title = await TryGetTitleAsync(requestType.SiteUrl!, requestType.ListId!, cancellationToken),
|
||||
CreatedAt = DateTimeOffset.UtcNow
|
||||
};
|
||||
|
||||
db.RequestListPartitions.Add(entity);
|
||||
await db.SaveChangesAsync(cancellationToken);
|
||||
|
||||
logger.LogInformation(
|
||||
"Список {ListId} типа заявок {RequestTypeId} добавлен в реестр под номером {Number}.",
|
||||
entity.ListId, requestType.Id, entity.Number);
|
||||
|
||||
return entity;
|
||||
}
|
||||
|
||||
// Заголовок нужен только для отображения в админке/портале — из-за его
|
||||
// отсутствия регистрация партиции падать не должна.
|
||||
private async Task<string?> TryGetTitleAsync(string siteUrl, string listId, CancellationToken cancellationToken)
|
||||
{
|
||||
try
|
||||
{
|
||||
return await sharePoint.GetListTitleAsync(siteUrl, listId, cancellationToken);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogWarning(ex, "Не удалось прочитать заголовок списка {ListId}.", listId);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
using FluentResults;
|
||||
using Hangfire;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Options;
|
||||
using Tnsu.ApprovalRoute.Application.Common.Errors;
|
||||
using Tnsu.ApprovalRoute.Domain.Entities;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.Persistence;
|
||||
using Tnsu.ApprovalRoute.Infrastructure.SharePoint;
|
||||
|
||||
namespace Tnsu.ApprovalRoute.Application.ListPartitioning;
|
||||
|
||||
/// <summary>
|
||||
/// Реестр нумерованных партиций списка по типу заявок: какая партиция текущая (куда
|
||||
/// писать) и вся серия целиком (архив + текущая) для админки и портала.
|
||||
/// </summary>
|
||||
public sealed class ListPartitionService(
|
||||
ApprovalRouteDbContext db,
|
||||
ISharePointClient sharePoint,
|
||||
ListPartitionRegistry registry,
|
||||
IBackgroundJobClient backgroundJobs,
|
||||
IOptions<ListPartitioningOptions> options,
|
||||
ILogger<ListPartitionService> logger)
|
||||
{
|
||||
/// <summary>
|
||||
/// Партиция, в которую сейчас нужно писать новые заявки.
|
||||
///
|
||||
/// Побочный эффект: если партиция набрала порог элементов, ставит в очередь
|
||||
/// задачу создания следующей. Побочный эффект в GET — сознательный компромисс
|
||||
/// (так описано в ТЗ): вызывающая сторона всё равно спрашивает адрес перед каждой
|
||||
/// записью, и это единственный момент, когда мы точно знаем, что список живой.
|
||||
/// Повторная постановка безопасна — задача разруливает гонку захватом блокировки.
|
||||
/// </summary>
|
||||
public async Task<Result<CurrentListPartitionDto>> GetCurrentAsync(
|
||||
int requestTypeId, CancellationToken cancellationToken)
|
||||
{
|
||||
var requestType = await db.RequestTypes
|
||||
.FirstOrDefaultAsync(x => x.Id == requestTypeId, cancellationToken);
|
||||
|
||||
if (requestType is null)
|
||||
return Result.Fail<CurrentListPartitionDto>(new NotFoundError("Тип заявки", requestTypeId));
|
||||
|
||||
if (string.IsNullOrWhiteSpace(requestType.ListId) || string.IsNullOrWhiteSpace(requestType.SiteUrl))
|
||||
return Result.Fail<CurrentListPartitionDto>(new ValidationError(
|
||||
$"У типа заявки {requestTypeId} не настроен список SharePoint."));
|
||||
|
||||
var current = await registry.EnsureCurrentRegisteredAsync(requestType, cancellationToken);
|
||||
|
||||
var itemCount = await TryGetItemCountAsync(requestType.SiteUrl, requestType.ListId, cancellationToken);
|
||||
var queued = await TryEnqueueProvisioningAsync(requestType, current.Number, itemCount, cancellationToken);
|
||||
|
||||
return Result.Ok(new CurrentListPartitionDto(
|
||||
requestTypeId, current.Number, requestType.SiteUrl, current.ListId, current.Title, itemCount, queued));
|
||||
}
|
||||
|
||||
/// <summary>Вся серия партиций типа заявок, от первой к последней — для админки.</summary>
|
||||
public async Task<Result<IReadOnlyList<RequestListPartitionDto>>> ListAsync(
|
||||
int requestTypeId, CancellationToken cancellationToken)
|
||||
{
|
||||
var requestType = await db.RequestTypes
|
||||
.FirstOrDefaultAsync(x => x.Id == requestTypeId, cancellationToken);
|
||||
|
||||
if (requestType is null)
|
||||
return Result.Fail<IReadOnlyList<RequestListPartitionDto>>(new NotFoundError("Тип заявки", requestTypeId));
|
||||
|
||||
return Result.Ok(await BuildSeriesAsync(requestType, cancellationToken));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Серии всех типов заявок разом — для портала: чтобы искать по заявкам сразу во
|
||||
/// всех партициях (архив + текущая) любого типа, порталу нужен весь список
|
||||
/// адресов один раз, а не по одному запросу на тип. Типы без настроенного
|
||||
/// списка SharePoint в ответ не попадают — искать там всё равно нечего.
|
||||
/// </summary>
|
||||
public async Task<Result<IReadOnlyList<RequestTypeListSeriesDto>>> ListAllAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
var requestTypes = await db.RequestTypes
|
||||
.Where(x => x.ListId != null && x.SiteUrl != null)
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
var result = new List<RequestTypeListSeriesDto>(requestTypes.Count);
|
||||
foreach (var requestType in requestTypes)
|
||||
{
|
||||
var partitions = await BuildSeriesAsync(requestType, cancellationToken);
|
||||
result.Add(new RequestTypeListSeriesDto(requestType.Id, partitions));
|
||||
}
|
||||
|
||||
return Result.Ok<IReadOnlyList<RequestTypeListSeriesDto>>(result);
|
||||
}
|
||||
|
||||
private async Task<IReadOnlyList<RequestListPartitionDto>> BuildSeriesAsync(
|
||||
RequestType requestType, CancellationToken cancellationToken)
|
||||
{
|
||||
// Тип без настроенного списка — пустая серия, а не ошибка: в админке такой
|
||||
// тип заявок вполне может существовать до привязки к SharePoint.
|
||||
if (string.IsNullOrWhiteSpace(requestType.ListId) || string.IsNullOrWhiteSpace(requestType.SiteUrl))
|
||||
return [];
|
||||
|
||||
await registry.EnsureCurrentRegisteredAsync(requestType, cancellationToken);
|
||||
|
||||
return await db.RequestListPartitions.AsNoTracking()
|
||||
.Where(x => x.RequestTypeId == requestType.Id)
|
||||
.OrderBy(x => x.Number)
|
||||
.Select(x => new RequestListPartitionDto(
|
||||
x.Number, requestType.SiteUrl!, x.ListId, x.Title, x.ListId == requestType.ListId, x.CreatedAt))
|
||||
.ToListAsync(cancellationToken);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Число элементов в списке. Ошибку SharePoint глушим: эндпоинт обязан отдать
|
||||
/// адрес списка даже когда SharePoint недоступен, иначе портал не сможет
|
||||
/// принять заявку из-за сбоя необязательной проверки порога.
|
||||
/// </summary>
|
||||
private async Task<int?> TryGetItemCountAsync(string siteUrl, string listId, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!options.Value.CheckThresholdOnRead) return null;
|
||||
|
||||
try
|
||||
{
|
||||
return await sharePoint.GetItemCountAsync(siteUrl, listId, cancellationToken);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogWarning(ex, "Не удалось получить число элементов списка {ListId} — порог не проверен.", listId);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Ставит задачу создания следующей партиции, если порог достигнут. Возвращает
|
||||
/// true, только если задача действительно поставлена.
|
||||
/// </summary>
|
||||
private async Task<bool> TryEnqueueProvisioningAsync(
|
||||
RequestType requestType, int currentNumber, int? itemCount, CancellationToken cancellationToken)
|
||||
{
|
||||
if (itemCount is null || itemCount < options.Value.ItemCountThreshold) return false;
|
||||
|
||||
// Следующая партиция уже создана, а запись на неё ещё не переключили —
|
||||
// задача не нужна (и переключать здесь нельзя: этим владеет провижининг).
|
||||
var hasNext = await db.RequestListPartitions
|
||||
.AnyAsync(x => x.RequestTypeId == requestType.Id && x.Number > currentNumber, cancellationToken);
|
||||
if (hasNext) return false;
|
||||
|
||||
// Провижининг уже идёт. Проверка неатомарная и это нормально: она экономит
|
||||
// постановку лишней задачи, а настоящую гонку ловит захват блокировки внутри
|
||||
// самой задачи (см. CreateNextListPartitionJob).
|
||||
if (requestType.ListPartitioningStartedAt is not null) return false;
|
||||
|
||||
backgroundJobs.Enqueue<CreateNextListPartitionJob>(
|
||||
job => job.RunAsync(requestType.Id, CancellationToken.None));
|
||||
|
||||
logger.LogInformation(
|
||||
"В списке {ListId} типа заявок {RequestTypeId} {ItemCount} элементов (порог {Threshold}) — " +
|
||||
"поставлена задача создания партиции №{NextNumber}.",
|
||||
requestType.ListId, requestType.Id, itemCount, options.Value.ItemCountThreshold, currentNumber + 1);
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
namespace Tnsu.ApprovalRoute.Application.ListPartitioning;
|
||||
|
||||
/// <summary>Настройки нумерованных партиций списков заявок (секция ListPartitioning в конфигурации).</summary>
|
||||
public sealed class ListPartitioningOptions
|
||||
{
|
||||
/// <summary>
|
||||
/// Порог элементов в списке данных, по достижении которого ставится задача на
|
||||
/// создание следующей партиции (пары списков).
|
||||
///
|
||||
/// 5000 — не предел SharePoint на число элементов (их может быть миллионы), а
|
||||
/// «list view threshold»: запросы, которым приходится просмотреть больше 5000
|
||||
/// элементов без подходящего индекса, SharePoint отклоняет. Порог намеренно чуть
|
||||
/// ниже, чтобы задача успела создать следующую партицию до того, как текущая
|
||||
/// начнёт упираться.
|
||||
/// </summary>
|
||||
public int ItemCountThreshold { get; set; } = 4500;
|
||||
|
||||
/// <summary>
|
||||
/// Через сколько блокировка провижининга считается брошенной и может быть
|
||||
/// перехвачена (процесс упал, не сняв флаг). См. RequestType.ListPartitioningStartedAt.
|
||||
/// </summary>
|
||||
public TimeSpan StaleLockAfter { get; set; } = TimeSpan.FromMinutes(30);
|
||||
|
||||
/// <summary>
|
||||
/// Проверять ли порог в эндпоинте «текущий список». false — эндпоинт только
|
||||
/// отдаёт список, не обращаясь к SharePoint за числом элементов и никого не
|
||||
/// ставя в очередь. Полезно, если SharePoint временно недоступен или нужно
|
||||
/// приостановить автосоздание партиций, не трогая остальную логику.
|
||||
/// </summary>
|
||||
public bool CheckThresholdOnRead { get; set; } = true;
|
||||
}
|
||||
Reference in New Issue
Block a user