mikhail/parr_api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'report' into dev

Browse Source
This commit is contained in:
Mikhail Trubnikov
2026-05-19 09:51:51 +10:00
parent b267dfe7c5 178d136dba
commit edc96bda33
43 changed files with 695 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
PARR.API/Contracts/V1/ApiRoutes.cs
View File

@@ -303,6 +303,8 @@
public const string WorkGroup = BaseStat + "/workload/work-groups";
public const string ResponseArea = BaseStat + "/workload/response-areas";
public const string ReportInfo = BaseStat + "/workload/report-info";
}
#endregion
@@ -564,6 +566,15 @@
#endregion
#region Tasks
public static class Tasks
{
public const string GetActiveTasks = Base + "/tasks/active";
}
#endregion
}
}

9
PARR.API/Contracts/V1/Responses/ActiveTaskResponse.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace PARR.API.Contracts.V1.Responses
{
public record ActiveTaskResponse : TaskItemBaseResponse
{
public required TaskItemTypeResponse Type { get; init; }
public required TaskItemStatusResponse Status { get; init; }
}
}

14
PARR.API/Contracts/V1/Responses/Statistics/StatWorkloadCacheInfoResponse.cs Normal file
View File

@@ -0,0 +1,14 @@
using PARR.Domain.DTOs.Workload;
namespace PARR.API.Contracts.V1.Responses.Statistics
{
/// <summary>
/// Инфо о формирование КЭШ для отчета Workload
/// </summary>
public record StatWorkloadCacheInfoResponse
{
public WorkloadCacheInfo.StatusEnum Status { get; set; }
public DateTimeOffset? Date { get; init; }
}
}

21
PARR.API/Contracts/V1/Responses/TaskItemResponse.cs Normal file
View File

@@ -0,0 +1,21 @@
namespace PARR.API.Contracts.V1.Responses
{
public record TaskItemBaseResponse
{
public Guid Id { get; init; }
public DateTimeOffset DateCreated { get; init; }
public DateTimeOffset? DateModified { get; init; }
public int RetryCount { get; init; }
public DateTimeOffset? ProcessedAt { get; init; }
}
public record TaskItemResponse : TaskItemBaseResponse
{
}
}

13
PARR.API/Contracts/V1/Responses/TaskItemStatusResponse.cs Normal file
View File

@@ -0,0 +1,13 @@
using PARR.Domain.Enums;
namespace PARR.API.Contracts.V1.Responses
{
public record TaskItemStatusResponse
{
public TaskItemStatusEnum Code { get; init; }
public required string Name { get; init; }
public required string Description { get; init; }
}
}

33
PARR.API/Contracts/V1/Responses/TaskItemTypeResponse.cs Normal file
View File

@@ -0,0 +1,33 @@
using PARR.Domain.Enums;
namespace PARR.API.Contracts.V1.Responses
{
public record TaskItemTypeResponse
{
public TaskTypeEnum Code { get; init; }
public required string Name { get; init; }
public required string Description { get; init; }
/// <summary>
/// Максимальное кол-во попыток
/// </summary>
public int MaxRetries { get; init; }
/// <summary>
/// Максимальное время выполнения
/// </summary>
public int MaxExecutionTimeMinutes { get; init; }
/// <summary>
/// Одновременно может быть только одна задача или несколько
/// </summary>
public bool IsSingleton { get; init; }
/// <summary>
/// Сколько дней хранить в БД
/// </summary>
public int RetentionDays { get; init; }
}
}

95
PARR.API/Controllers/V1/GeneratorTemplateController.cs
View File

@@ -1,95 +0,0 @@
namespace PARR.API.Controllers.V1
{
//[Authorize(Roles = ParrRoles.Administrator.Role)]
//public class GeneratorTemplateController : BaseApiController
//{
// private readonly IValidator<GeneratorTemplateRequest> validator;
// private readonly IRabbitService mqService;
// private readonly IUriService uriService;
// private readonly MqSettings mqSettings;
// private readonly IClientService clientService;
// public GeneratorTemplateController(
// IValidator<GeneratorTemplateRequest> validator,
// IRabbitService mqService,
// IUriService uriService,
// MqSettings mqSettings,
// IClientService clientService
// )
// {
// this.validator = validator;
// this.mqService = mqService;
// this.uriService = uriService;
// this.mqSettings = mqSettings;
// this.clientService = clientService;
// }
// /// !!!!!!!!!! Это старый контроллер, удалить !!!!!!!!!!
// /// <summary>
// /// Запрос на генерацию шаблонов
// /// </summary>
// /// <returns></returns>
// [HttpPost(ApiRoutes.GeneratorTemplate.Create)]
// public async Task<IActionResult> Create([FromBody] GeneratorTemplateRequest request)
// {
// var resultValidate = await validator.ValidateAsync(request);
// if (!resultValidate.IsValid)
// return BadRequest(new Response(resultValidate.Errors));
// var result = true;
// request.Ek.ForEach(ek =>
// {
// //todo: проверить в ForEach(async status - отрабатывает ли нормально async, возможно надо переделать в обычный foreach
// request.Status.ForEach(async status =>
// {
// var obj = new GeneratorTemplateMq
// {
// Action = request.Action,
// ApplicationId = request.ApplicationId,
// Ek = ek,
// WorkId = request.WorkId,
// StatusEk = status,
// IsActiveTemplate = request.IsActiveTemplate,
// IsActiveSchedule = request.IsActiveSchedule,
// HistoryInitiator = new HistoryInitiator { InitiatorIp = clientService.GetClientIp()?.ToString(), InitiatorParrComponentId = ParrComponentsEnum.Api }
// };
// //var msg = JsonSerializer.Serialize(obj);
// //var _result = await mqService.SendAsync(mqSettings.GenerateTemplates, new[] { msg });
// var _result = await mqService.SendAsync(mqSettings.GenerateTemplates, new List<object> { obj });
// if (_result.IsSuccess == false)
// result = false;
// });
// });
// //var obj = new GeneratorTemplateMq
// //{
// // Action = request.Action,
// // ApplicationId = request.ApplicationId,
// // Ek = request.Ek,
// // WorkId = request.WorkId,
// // StatusEk = request.Status,
// // IsActiveTemplate = request.IsActiveTemplate,
// // IsActiveSchedule = request.IsActiveSchedule
// //};
// //var msg = JsonSerializer.Serialize(obj);
// //var result = mqService.Send(mqSettings.GenerateTemplates, new[] { msg });
// //if (!result.IsSuccess)
// if (!result)
// return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при отправке данных." } }));
// var createdUri = uriService.GetAllUri(ApiRoutes.Template.GetAll);
// return Created(createdUri, new Response<string?>(null, true, new List<ErrorModel>(), "Отправлен запрос на генерацию шаблонов."));
// }
//}
}

212
PARR.API/Controllers/V1/JobAutoControlController.cs
View File

@@ -1,212 +0,0 @@
using Microsoft.AspNetCore.Authorization;
using PARR.API.Controllers.V1.Base;
using PARR.Domain.Common.Roles;
namespace PARR.API.Controllers.V1
{
/// <summary>
/// Управление автоматическим созданием/деактивацией/активацией РР
/// </summary>
[Authorize(Roles = ParrRoles.Administrator.Role)]
public class JobAutoControlController : BaseApiController
{
//private readonly IJobAutoControlService jobAutoControlService;
//private readonly IApplicationsInWorkService applicationsInWorkService;
//private readonly IMapper mapper;
//private readonly IValidator<JobAutoControlRequest> validator;
//private readonly IUriService uriService;
//public JobAutoControlController(
// IJobAutoControlService jobAutoControlService,
// IApplicationsInWorkService applicationsInWorkService,
// IMapper mapper,
// IValidator<JobAutoControlRequest> validator,
// IUriService uriService
// )
//{
// this.jobAutoControlService = jobAutoControlService;
// this.applicationsInWorkService = applicationsInWorkService;
// this.mapper = mapper;
// this.validator = validator;
// this.uriService = uriService;
//}
///// <summary>
///// Получить настройки автоматического управления РР
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <returns></returns>
//[HttpGet(ApiRoutes.JobAutoControl.Get)]
//public async Task<IActionResult> Get([FromRoute] Guid applicationInWorkId)
//{
// var obj = await jobAutoControlService.Get()
// .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
// .Include(t => t.JobEkMasks)
// .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
// .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// if (obj == null)
// {
// // проверим, есть ли вообще такой AppInWork
// var appInWork = await applicationsInWorkService.GetAsync(applicationInWorkId);
// if (appInWork == null)
// return NotFound();
// return NoContent();
// }
// var response = mapper.Map<JobAutoControlResponse>(obj);
// return Ok(new Response<JobAutoControlResponse>(response, true));
//}
///// <summary>
///// Создать настройки автоматического управления РР
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <param name="request"></param>
///// <returns></returns>
//[HttpPost(ApiRoutes.JobAutoControl.Create)]
//public async Task<IActionResult> Create([FromRoute] Guid applicationInWorkId, [FromBody] JobAutoControlRequest request)
//{
// var exist = await jobAutoControlService.Get().FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// if (exist != null)
// return BadRequest(new Response(false, new List<ErrorModel> {
// new ErrorModel { FieldName = nameof(applicationInWorkId), Message = $"Запись с {nameof(applicationInWorkId)}: {applicationInWorkId} уже существует." }
// }));
// var resultValidate = await validator.ValidateAsync(request);
// if (!resultValidate.IsValid)
// return BadRequest(new Response(resultValidate.Errors));
// var newObj = new DAL.Models.JobAutoControl
// {
// Id = Guid.NewGuid(),
// ApplicationInWorkId = applicationInWorkId,
// CreateNew = request.CreateNew,
// Deactivate = request.Deactivate,
// Activate = request.Activate,
// OnTemplateIsActive = request.OnTemplateIsActive,
// OnScheduleIsActive = request.OnScheduleIsActive,
// OffTemplateIsActive = request.OffTemplateIsActive,
// OffScheduleIsActive = request.OffScheduleIsActive
// };
// // убираем пробелы и дубли
// request.EkMasks.Where(t => t.Trim() != string.Empty).Distinct().ToList().ForEach(mask => newObj.JobEkMasks.Add(new JobEkMask
// {
// Id = Guid.NewGuid(),
// DateCreated = DateTimeOffset.UtcNow,
// Name = mask.Trim(),
// JobAutoControlId = newObj.Id
// }));
// request.EnabledEkStatuses.ForEach(status => newObj.JobAutoControlInEkStatuses.Add(new JobAutoControlInEkStatus
// {
// EkStatusCode = (int)status,
// JobAutoControlId = newObj.Id
// }));
// if (!await jobAutoControlService.CreateAsync(newObj) || !await jobAutoControlService.CommitAsync())
// return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при создани записи." } }));
// var locationUri = uriService.GetUri(ApiRoutes.JobAutoControl.Get, ApiRoutes.JobAutoControl.appInWorkId, applicationInWorkId);
// var createdObj = await jobAutoControlService.Get()
// .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
// .Include(t => t.JobEkMasks)
// .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
// .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// return Created(locationUri, new Response<JobAutoControlResponse>(mapper.Map<JobAutoControlResponse>(createdObj), true));
//}
///// <summary>
///// Обновить настройки автоматического управления РР
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <param name="request"></param>
///// <returns></returns>
//[HttpPut(ApiRoutes.JobAutoControl.Update)]
//public async Task<IActionResult> Update([FromRoute] Guid applicationInWorkId, [FromBody] JobAutoControlRequest request)
//{
// var resultValidate = await validator.ValidateAsync(request);
// if (!resultValidate.IsValid)
// return BadRequest(new Response(resultValidate.Errors));
// var orig = await jobAutoControlService.Get()
// .Include(t => t.JobEkMasks)
// .Include(t => t.JobAutoControlInEkStatuses)
// .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// if (orig == null)
// return BadRequest(new Response(false, new List<ErrorModel> {
// new ErrorModel { FieldName = nameof(applicationInWorkId), Message = $"Запись с {nameof(applicationInWorkId)}: {applicationInWorkId} не существует." }
// }));
// orig.DateModified = DateTimeOffset.UtcNow;
// orig.CreateNew = request.CreateNew;
// orig.Deactivate = request.Deactivate;
// orig.Activate = request.Activate;
// orig.OnTemplateIsActive = request.OnTemplateIsActive;
// orig.OnScheduleIsActive = request.OnScheduleIsActive;
// orig.OffTemplateIsActive = request.OffTemplateIsActive;
// orig.OffScheduleIsActive = request.OffScheduleIsActive;
// orig.JobEkMasks.Clear();
// // убираем пробелы и дубли
// request.EkMasks.Where(t => t.Trim() != string.Empty).Distinct().ToList().ForEach(mask => orig.JobEkMasks.Add(new JobEkMask
// {
// //Id = Guid.NewGuid(), // не пойму почему не нужно это поле. с ним ошибка.
// DateCreated = DateTimeOffset.UtcNow,
// Name = mask.Trim(),
// JobAutoControlId = orig.Id
// }));
// orig.JobAutoControlInEkStatuses.Clear();
// request.EnabledEkStatuses.ForEach(status => orig.JobAutoControlInEkStatuses.Add(new JobAutoControlInEkStatus
// {
// EkStatusCode = (int)status,
// JobAutoControlId = orig.Id
// }));
// if (!await jobAutoControlService.CommitAsync())
// return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Ошибка при изменении записи." } }));
// var updatedObj = await jobAutoControlService.Get()
// .Include(t => t.ApplicationsInWork).ThenInclude(t => t.WorkGroups).ThenInclude(t => t.WorkGroup)
// .Include(t => t.JobEkMasks)
// .Include(t => t.JobAutoControlInEkStatuses).ThenInclude(t => t.EkStatus)
// .FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// return Ok(new Response<JobAutoControlResponse>(mapper.Map<JobAutoControlResponse>(updatedObj), true));
//}
///// <summary>
///// Удалить настройки автоматического управления РР
///// </summary>
///// <param name="applicationInWorkId"></param>
///// <returns></returns>
//[HttpDelete(ApiRoutes.JobAutoControl.Delete)]
//public async Task<IActionResult> Delete([FromRoute] Guid applicationInWorkId)
//{
// var obj = await jobAutoControlService.Get().FirstOrDefaultAsync(t => t.ApplicationInWorkId == applicationInWorkId);
// if (obj == null)
// return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при удалении настроект. Не найден настройки с {nameof(applicationInWorkId)}: {applicationInWorkId}" } }));
// if (!jobAutoControlService.Delete(obj) || !await jobAutoControlService.CommitAsync())
// return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = $"Ошибка при удалении настроек." } }));
// return NoContent();
//}
}
}

5
PARR.API/Controllers/V1/ShortcodeApplyController.cs
View File

@@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Requests;
@@ -7,9 +8,11 @@ using PARR.API.Contracts.V1.Responses.Base;
using PARR.API.Controllers.V1.Base;
using PARR.Core.Repositories.Interfaces;
using PARR.Core.Services.Shortcodes;
using PARR.Domain.Common.Roles;
namespace PARR.API.Controllers.V1
{
[Authorize(Roles = ParrRoles.Administrator.Role)]
public class ShortcodeApplyController : BaseApiController
{
private readonly ILogger<ShortcodeController> logger;

21
PARR.API/Controllers/V1/Statistics/StatWorkloadController.cs
View File

@@ -1,7 +1,6 @@
using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NodaTime;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Requests.BaseRequests;
using PARR.API.Contracts.V1.Requests.Queries;
@@ -71,8 +70,6 @@ namespace PARR.API.Controllers.V1.Statistics
}
/// <summary>
/// Сформировать отчетность
/// </summary>
@@ -111,6 +108,22 @@ namespace PARR.API.Controllers.V1.Statistics
}
/// <summary>
/// Получить информацию о формировании КЭШ
/// </summary>
/// <returns></returns>
[HttpGet(ApiRoutes.Workload.ReportInfo)]
public async Task<IActionResult> GetReportInfo()
{
var report = await workloadService.GetReportInfoAsync();
var response = mapper.Map<StatWorkloadCacheInfoResponse>(report);
return Ok(new Response<StatWorkloadCacheInfoResponse>(response, true));
}
/// <summary>
/// Универсальный метод получения отчетности
/// </summary>
@@ -124,7 +137,7 @@ namespace PARR.API.Controllers.V1.Statistics
var report = await workloadService.GetWorkloadReport(reportType, dateStart, durationDays, offset, filter);
if (report == null)
return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { Message = "Необходимо сформировать отчетность." } }));
return BadRequest(new Response<string?>(null, false, new List<ErrorModel> { new ErrorModel { Message = "Необходимо сформировать отчетность." } }, "empty"));
var resonse = mapper.Map<StatWorkloadReportResponse>(report);

5
PARR.API/Controllers/V1/SyncTaskController.cs
View File

@@ -1,4 +1,5 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Requests;
using PARR.API.Contracts.V1.Responses.Base;
@@ -8,11 +9,13 @@ using PARR.API.Settings;
using PARR.Core.Common.Interfaces.RabbitServices;
using PARR.Core.Services.MatchingStatusService;
using PARR.Domain.Common.Rabbit.Messages;
using PARR.Domain.Common.Roles;
using PARR.Domain.Entities.Base.History;
using PARR.Domain.Enums;
namespace PARR.API.Controllers.V1
{
[Authorize(Roles = ParrRoles.Administrator.Role)]
public class SyncTaskController : BaseApiController
{
private readonly ILogger<SyncTaskController> logger;

51
PARR.API/Controllers/V1/TaskController.cs Normal file
View File

@@ -0,0 +1,51 @@
using AutoMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PARR.API.Contracts.V1;
using PARR.API.Contracts.V1.Responses;
using PARR.API.Contracts.V1.Responses.Base;
using PARR.API.Controllers.V1.Base;
using PARR.Core.Services.TaskServices.Interfaces;
using PARR.Domain.Common.Roles;
using PARR.Domain.Enums;
namespace PARR.API.Controllers.V1
{
/// <summary>
/// Контроллер по управлению Task (задания, очереди)
/// </summary>
[Authorize(Roles = ParrRoles.Administrator.Role)]
public class TaskController : BaseApiController
{
private readonly ITaskManagementService taskManagementService;
private readonly IMapper mapper;
public TaskController(
ITaskManagementService taskManagementService,
IMapper mapper
)
{
this.taskManagementService = taskManagementService;
this.mapper = mapper;
}
/// <summary>
/// Получить список активных задач (задания, очереди)
/// </summary>
/// <returns></returns>
[HttpGet(ApiRoutes.Tasks.GetActiveTasks)]
public async Task<IActionResult> GetActiveTasks([FromQuery] TaskTypeEnum? typeCode)
{
var activeTasks = await taskManagementService.GetActiveTasksAsync(typeCode);
if (activeTasks.Count == 0)
return NoContent();
var response = mapper.Map<List<ActiveTaskResponse>>(activeTasks);
return Ok(new Response<List<ActiveTaskResponse>>(response, true));
}
}
}

5
PARR.API/Controllers/V1/TaskStatusController.cs
View File

@@ -11,6 +11,9 @@ using PARR.Domain.Common.Roles;
namespace PARR.API.Controllers.V1
{
/// <summary>
/// Статусы заданий роботам
/// </summary>
[Authorize(Roles = ParrRoles.EsppRobot.RoleOrAdmin)]
public class TaskStatusController : BaseApiController
{
@@ -27,7 +30,7 @@ namespace PARR.API.Controllers.V1
}
/// <summary>
/// Получить список статусов заданий
/// Получить список статусов заданий роботам
/// </summary>
/// <returns></returns>
[HttpGet(ApiRoutes.TaskStatus.GetAll)]

9
PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs Normal file
View File

@@ -0,0 +1,9 @@
using Microsoft.AspNetCore.Diagnostics;
namespace PARR.API.Infrastructure.Middleware
{
public class GlobalExceptionHandler//: IExceptionHandler
{
//todo:
}
}

24
PARR.API/MappingProfiles/DomainToResponseProfile.cs
View File

@@ -6,6 +6,7 @@ using PARR.API.MappingProfiles.Resolvers;
using PARR.Core.Repositories.Interfaces.Schedule;
using PARR.Domain.DTOs.Matching;
using PARR.Domain.DTOs.Shortcode;
using PARR.Domain.DTOs.TaskDTO;
using PARR.Domain.DTOs.Workload;
using PARR.Domain.Entities;
using PARR.Domain.Entities.Base.History;
@@ -443,6 +444,29 @@ namespace PARR.API.MappingProfiles
CreateMap<WorkloadDailyItem, WorkloadDailyItemResponse>();
CreateMap<WorkloadCacheInfo, StatWorkloadCacheInfoResponse>();
#endregion
#region Task
//CreateMap<TaskItemBase, TaskItemBaseResponse>()
// .Include<TaskItemBase, TaskItemResponse>()
// .Include<TaskItemBase, ActiveTaskResponse>();
//CreateMap<TaskItemBase, TaskItemResponse>();
CreateMap<ActiveTask, ActiveTaskResponse>();
// ---
CreateMap<TaskType, TaskItemTypeResponse>();
CreateMap<PARR.Domain.DTOs.TaskDTO.TaskStatus, TaskItemStatusResponse>();
#endregion
}

2
PARR.API/appsettings.json
View File

@@ -111,7 +111,7 @@
}
],
"RabbitMq": {
"ThresholdConnections": 28
"ThresholdConnections": 29
}
}
}

8
PARR.Core/Common/Interfaces/IRedisCacheService.cs
View File

@@ -94,6 +94,14 @@
/// <returns></returns>
Task<T?> GetHashFieldAsync<T>(string hashKey, string field);
/// <summary>
/// Получить случайную первую запись из Hash
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="hashKey"></param>
/// <returns></returns>
Task<(string Field, T? Value)?> GetFirstHashFieldAsync<T>(string hashKey);
/// <summary>
/// Получить все значения из Hash
/// </summary>

2
PARR.Core/DependencyInjection.cs
View File

@@ -107,6 +107,8 @@ namespace PARR.Core
services.AddScoped<WorkloadCacheService>();
services.AddScoped<IWorkloadService, WorkloadService>();
services.AddSingleton<IWorkloadIntervalService, WorkloadIntervalService>();
#endregion
#region NextRun

36
PARR.Core/Infrastructure/Mapping/TaskMappingProfile.cs Normal file
View File

@@ -0,0 +1,36 @@
using AutoMapper;
using PARR.Domain.DTOs.TaskDTO;
namespace PARR.Core.Infrastructure.Mapping
{
/// <summary>
/// Маппинг все что касается Task
/// </summary>
internal class TaskMappingProfile : Profile
{
public TaskMappingProfile()
{
#region TaskItem
CreateMap<Domain.Entities.TaskEntities.TaskItem, TaskItemBase>()
.Include<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.TaskItem>()
.Include<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.ActiveTask>();
CreateMap<Domain.Entities.TaskEntities.TaskItem, Domain.DTOs.TaskDTO.TaskItem>();
#endregion
#region ActiveTask
CreateMap<Domain.Entities.TaskEntities.TaskItem, ActiveTask>()
.ForMember(d => d.Type, o => o.MapFrom(s => s.TaskType))
.ForMember(d => d.Status, o => o.MapFrom(s => s.TaskStatus));
#endregion
#region TaskType
CreateMap<Domain.Entities.TaskEntities.TaskType, Domain.DTOs.TaskDTO.TaskType>();
#endregion
#region TaskStatus
CreateMap<Domain.Entities.TaskEntities.TaskStatus, Domain.DTOs.TaskDTO.TaskStatus>();
#endregion
}
}
}

4
PARR.Core/PARR.Core.csproj
View File

@@ -6,10 +6,6 @@
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Folder Include="Infrastructure\" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
<PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.5.2" />

35
PARR.Core/Services/TaskServices/Implementations/TaskManagementService.cs
View File

@@ -1,11 +1,12 @@
using Microsoft.EntityFrameworkCore;
using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using PARR.Core.Common.Interfaces.RabbitServices;
using PARR.Core.Repositories.Interfaces.TaskRepositories;
using PARR.Core.Services.TaskServices.Interfaces;
using PARR.Domain.Common.Rabbit.Messages;
using PARR.Domain.DTOs.TaskDTO;
using PARR.Domain.Entities.Base.History;
using PARR.Domain.Entities.TaskEntities;
using PARR.Domain.Enums;
using PARR.Domain.Settings;
using System.Text.Encodings.Web;
@@ -19,24 +20,29 @@ namespace PARR.Core.Services.TaskServices.Implementations
private readonly ITaskTypeRepository taskTypeRepository;
private readonly ITaskRepository taskRepository;
private readonly IRabbitService rabbitService;
private readonly IMapper mapper;
public TaskManagementService(
ILogger<TaskManagementService> logger,
ITaskTypeRepository taskTypeRepository,
ITaskRepository taskRepository,
IRabbitService rabbitService
IRabbitService rabbitService,
IMapper mapper
)
{
this.logger = logger;
this.taskTypeRepository = taskTypeRepository;
this.taskRepository = taskRepository;
this.rabbitService = rabbitService;
this.mapper = mapper;
}
public async Task<Guid> CreateTaskAsync<T>(TaskTypeEnum typeCode, T payload, IHistoryInitiator initiator, IMqSettings mqSettings)
{
var taskType = await taskTypeRepository.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Code == typeCode);
var taskType = await taskTypeRepository.Get()
.AsNoTracking()
.FirstOrDefaultAsync(t => t.Code == typeCode);
if (taskType == null)
{
@@ -59,7 +65,7 @@ namespace PARR.Core.Services.TaskServices.Implementations
var payloadStr = PayloadToString(payload);
// Создаем новую запись задачи
var task = new TaskItem
var task = new Domain.Entities.TaskEntities.TaskItem
{
Id = Guid.NewGuid(),
TypeCode = typeCode,
@@ -99,12 +105,29 @@ namespace PARR.Core.Services.TaskServices.Implementations
}
public async Task<List<ActiveTask>> GetActiveTasksAsync(TaskTypeEnum? typeCode = null)
{
var query = taskRepository.Get()
.AsNoTracking()
.Include(t => t.TaskStatus)
.Include(t => t.TaskType)
.Where(t => t.StatusCode == TaskItemStatusEnum.Pending || t.StatusCode == TaskItemStatusEnum.Processing);
if (typeCode.HasValue)
query = query.Where(t => t.TypeCode == typeCode.Value);
var tasks = await query.OrderByDescending(t => t.DateCreated).ToListAsync();
return mapper.Map<List<ActiveTask>>(tasks);
}
/// <summary>
/// Получить активную singleton задачу указанного типа
/// </summary>
/// <param name="typeCode"></param>
/// <returns></returns>
private async Task<TaskItem?> GetActiveSingletonTaskAsync(TaskTypeEnum typeCode)
private async Task<Domain.Entities.TaskEntities.TaskItem?> GetActiveSingletonTaskAsync(TaskTypeEnum typeCode)
{
return await taskRepository.Get().AsNoTracking()
.FirstOrDefaultAsync(t => t.TypeCode == typeCode && (

14
PARR.Core/Services/TaskServices/Interfaces/ITaskManagementService.cs
View File

@@ -1,4 +1,5 @@
using PARR.Domain.Entities.Base.History;
using PARR.Domain.DTOs.TaskDTO;
using PARR.Domain.Entities.Base.History;
using PARR.Domain.Enums;
using PARR.Domain.Settings;
@@ -10,7 +11,8 @@ namespace PARR.Core.Services.TaskServices.Interfaces
public interface ITaskManagementService
{
/// <summary>
/// Создать новую задачу в БД и опубликовать в очередь
/// Создать новую задачу в БД и опубликовать в очередь.
/// В случае ошибок генерирует Exception.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="typeCode">Тип задачи</param>
@@ -19,5 +21,13 @@ namespace PARR.Core.Services.TaskServices.Interfaces
/// <param name="mqSettings">Настройки очереди</param>
/// <returns></returns>
Task<Guid> CreateTaskAsync<T>(TaskTypeEnum typeCode, T payload, IHistoryInitiator initiator, IMqSettings mqSettings);
/// <summary>
/// Получить список активных задач
/// </summary>
/// <param name="typeCode"></param>
/// <returns></returns>
Task<List<ActiveTask>> GetActiveTasksAsync(TaskTypeEnum? typeCode = null);
}
}

12
PARR.Core/Services/Workload/Implementations/WorkloadCacheService.cs
View File

@@ -328,6 +328,18 @@ namespace PARR.Core.Services.Workload.Implementations
}
/// <summary>
/// Вернуть первую запись из TamplateCache если есть
/// </summary>
/// <returns></returns>
public async Task<TemplateCache?> GetFirstTemplateCacheAsync()
{
var cache = await redisCacheService.GetFirstHashFieldAsync<TemplateCache>(redisCacheService.GetKey(cacheTemplateKey));
return cache?.Value;
}
/// <summary>
/// Формирует ключ для отчета Workload
/// </summary>

55
PARR.Core/Services/Workload/Implementations/WorkloadIntervalService.cs Normal file
View File

@@ -0,0 +1,55 @@
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using PARR.Core.Common.Interfaces;
using PARR.Core.Services.TaskServices.Interfaces;
using PARR.Core.Services.Workload.Interfaces;
using PARR.Domain.Entities.Base.History;
using PARR.Domain.Settings;
namespace PARR.Core.Services.Workload.Implementations
{
internal class WorkloadIntervalService : IWorkloadIntervalService
{
private readonly ILogger<WorkloadIntervalService> logger;
private readonly IIntervalService intervalService;
private readonly IServiceProvider serviceProvider;
public WorkloadIntervalService(
ILogger<WorkloadIntervalService> logger,
IIntervalService intervalService,
IServiceProvider serviceProvider
)
{
this.logger = logger;
this.intervalService = intervalService;
this.serviceProvider = serviceProvider;
}
public async Task StartAsync(TimeSpan interval, IMqSettings mqSettings)
{
logger.LogInformation("Запуск сервиса формирования кэш отчетов Workload по интервалу.");
await intervalService.IntervalInitAsync(async () =>
{
await using (var scope = serviceProvider.CreateAsyncScope())
{
var taskManagementService = scope.ServiceProvider.GetRequiredService<ITaskManagementService>();
var initiator = new HistoryInitiator { InitiatorParrComponentId = Domain.Enums.ParrComponentsEnum.WorkloadBuilder, InitiatorComment = $"Генерация кэш workload по интервалу '{interval}'" };
try
{
var taskId = await taskManagementService.CreateTaskAsync<object?>(Domain.Enums.TaskTypeEnum.Workload, default, initiator, mqSettings);
logger.LogInformation("Создана задача {taskId} на формирование кэш отчета.", taskId);
}
catch (Exception ex)
{
logger.LogError(ex, "Ошибка при отправке задания на формирование кэш отчета.");
}
}
}, interval);
}
}
}

42
PARR.Core/Services/Workload/Implementations/WorkloadService.cs
View File

@@ -1,7 +1,9 @@
using Microsoft.Extensions.Logging;
using PARR.Core.Services.NextRunServices;
using PARR.Core.Services.TaskServices.Interfaces;
using PARR.Core.Services.Workload.Interfaces;
using PARR.Core.Services.Workload.Models;
using PARR.Domain.DTOs.TaskDTO;
using PARR.Domain.DTOs.Workload;
using PARR.Domain.Enums;
@@ -12,16 +14,19 @@ namespace PARR.Core.Services.Workload.Implementations
private readonly ILogger<WorkloadService> logger;
private readonly WorkloadCacheService workloadCacheService;
private readonly INextRunService nextRunService;
private readonly ITaskManagementService taskManagementService;
public WorkloadService(
ILogger<WorkloadService> logger,
WorkloadCacheService workloadCacheService,
INextRunService nextRunService
INextRunService nextRunService,
ITaskManagementService taskManagementService
)
{
this.logger = logger;
this.workloadCacheService = workloadCacheService;
this.nextRunService = nextRunService;
this.taskManagementService = taskManagementService;
}
@@ -107,6 +112,39 @@ namespace PARR.Core.Services.Workload.Implementations
return report;
}
public async Task<WorkloadCacheInfo> GetReportInfoAsync()
{
// может быть три статуса
// 1 - отчет сейчас формируется (дата начала формирования отчета)
// 2 - отчет сформирован (вернуть дату формирования кэш)
// 3 - отчет сейчас не формируется, кэша нет (date = null)
// 1. проверить что выполнились все задания на обновление кэш
var activeTasks = await taskManagementService.GetActiveTasksAsync(TaskTypeEnum.Workload);
if (activeTasks.Count > 0)
{
// идет формирование отчета
// задача может быт только одна, так как у нее такой тип
var task = activeTasks.First();
return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.Processing, Date = task.DateCreated };
}
// 2. получить дату кэш
// Если нет активных задач, значит может быть кэш существует, пробуем получить дату из кэш
var templateCache = await workloadCacheService.GetFirstTemplateCacheAsync();
if (templateCache != null)
{
return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.Generated, Date = templateCache.Timestamp };
}
// Если кэш нет, то возвращаем null
return new WorkloadCacheInfo { Status = WorkloadCacheInfo.StatusEnum.NotFound };
}
/// <summary>
/// Получить список дней для отчета, с отметкой выходной/рабочий
/// </summary>
@@ -115,7 +153,7 @@ namespace PARR.Core.Services.Workload.Implementations
/// <returns></returns>
private async Task<List<WorkloadDayItem>> GetReportDays(DateOnly dateStart, int durationDays)
{
var dateEnd = dateStart.AddDays(durationDays);
var dateEnd = dateStart.AddDays(durationDays - 1);
var days = await nextRunService.GetWorkDaysAsync(dateStart, dateEnd, false);
var weekends = await nextRunService.GetWeekendsAsync(dateStart, dateEnd);

18
PARR.Core/Services/Workload/Interfaces/IWorkloadIntervalService.cs Normal file
View File

@@ -0,0 +1,18 @@
using PARR.Domain.Settings;
namespace PARR.Core.Services.Workload.Interfaces
{
/// <summary>
/// Формирование кэш отчетов по интервалу
/// </summary>
public interface IWorkloadIntervalService
{
/// <summary>
/// Запуск формирования по интервалу
/// </summary>
/// <param name="interval">Интервал</param>
/// <param name="mqSettings">Настройки очереди куда отправлять задание</param>
/// <returns></returns>
Task StartAsync(TimeSpan interval, IMqSettings mqSettings);
}
}

6
PARR.Core/Services/Workload/Interfaces/IWorkloadService.cs
View File

@@ -8,6 +8,12 @@ namespace PARR.Core.Services.Workload.Interfaces
/// </summary>
public interface IWorkloadService
{
/// <summary>
/// Получить статус кэш/отчета
/// </summary>
/// <returns></returns>
Task<WorkloadCacheInfo> GetReportInfoAsync();
/// <summary>
/// Получить отчет о загруженности
/// </summary>

5
PARR.DAL/Context/DataContext.cs
View File

@@ -518,7 +518,8 @@ namespace PARR.DAL.Context
new() { Id = ParrComponentsEnum.NextRun, Name = ParrComponentsEnum.NextRun.ToString(), Description = "Рассчет даты следующего срабатывания" },
new() { Id = ParrComponentsEnum.TemplateActivator, Name = ParrComponentsEnum.TemplateActivator.ToString(), Description = "Активатор шаблонов / расписаний" },
new() { Id = ParrComponentsEnum.TemplateDistributor, Name = ParrComponentsEnum.TemplateDistributor.ToString(), Description = "Автораспределение РР" },
new() { Id = ParrComponentsEnum.TemplateTaskGenerator, Name = ParrComponentsEnum.TemplateTaskGenerator.ToString(), Description = "Генератор шаблонов" }
new() { Id = ParrComponentsEnum.TemplateTaskGenerator, Name = ParrComponentsEnum.TemplateTaskGenerator.ToString(), Description = "Генератор шаблонов" },
new() { Id = ParrComponentsEnum.WorkloadBuilder, Name = ParrComponentsEnum.WorkloadBuilder.ToString(), Description = "Генератор кэша отчетов workload" }
);
});
@@ -579,7 +580,7 @@ namespace PARR.DAL.Context
{
f.HasData(new Domain.Entities.TaskEntities.TaskType[]
{
new() { Code = TaskTypeEnum.Workload, Name = TaskTypeEnum.Workload.ToString(), Description = "Формирование данных для отчетности - Загруженность", MaxRetries = 2, IsSingleton=true, MaxExecutionTimeMinutes=60, RetentionDays=90 }
new() { Code = TaskTypeEnum.Workload, Name = TaskTypeEnum.Workload.ToString(), Description = "Формирование данных для отчетности - Загруженность", MaxRetries = 2, IsSingleton=true, MaxExecutionTimeMinutes=90, RetentionDays=90 }
}
);
});

11
PARR.Domain/Cache/Models/Base/IBaseCache.cs
View File

@@ -5,10 +5,19 @@
/// </summary>
public interface IBaseCache<T>
{
/// <summary>
/// Объект
/// </summary>
public T Data { get; set; }
/// <summary>
/// Дата формирования Cache
/// </summary>
public DateTimeOffset Timestamp { get; set; }
/// <summary>
/// Источник Cache (class)
/// </summary>
public string Source { get; set; }
}
}

12
PARR.Domain/DTOs/TaskDTO/ActiveTask.cs Normal file
View File

@@ -0,0 +1,12 @@
namespace PARR.Domain.DTOs.TaskDTO
{
/// <summary>
/// DTO
/// </summary>
public record ActiveTask : TaskItemBase
{
public required TaskType Type { get; init; }
public required TaskStatus Status { get; init; }
}
}

26
PARR.Domain/DTOs/TaskDTO/TaskItem.cs Normal file
View File

@@ -0,0 +1,26 @@
namespace PARR.Domain.DTOs.TaskDTO
{
/// <summary>
/// DTO
/// </summary>
public record TaskItemBase
{
public Guid Id { get; init; }
public DateTimeOffset DateCreated { get; init; }
public DateTimeOffset? DateModified { get; init; }
public int RetryCount { get; init; }
public DateTimeOffset? ProcessedAt { get; init; }
}
/// <summary>
/// DTO
/// </summary>
public record TaskItem : TaskItemBase
{
//todo:
}
}

16
PARR.Domain/DTOs/TaskDTO/TaskStatus.cs Normal file
View File

@@ -0,0 +1,16 @@
using PARR.Domain.Enums;
namespace PARR.Domain.DTOs.TaskDTO
{
/// <summary>
/// DTO
/// </summary>
public record TaskStatus
{
public TaskItemStatusEnum Code { get; init; }
public required string Name { get; init; }
public required string Description { get; init; }
}
}

36
PARR.Domain/DTOs/TaskDTO/TaskType.cs Normal file
View File

@@ -0,0 +1,36 @@
using PARR.Domain.Enums;
namespace PARR.Domain.DTOs.TaskDTO
{
/// <summary>
/// DTO
/// </summary>
public record TaskType
{
public TaskTypeEnum Code { get; init; }
public required string Name { get; init; }
public required string Description { get; init; }
/// <summary>
/// Максимальное кол-во попыток
/// </summary>
public int MaxRetries { get; init; }
/// <summary>
/// Максимальное время выполнения
/// </summary>
public int MaxExecutionTimeMinutes { get; init; }
/// <summary>
/// Одновременно может быть только одна задача или несколько
/// </summary>
public bool IsSingleton { get; init; }
/// <summary>
/// Сколько дней хранить в БД
/// </summary>
public int RetentionDays { get; init; }
}
}

36
PARR.Domain/DTOs/Workload/WorkloadCacheInfo.cs Normal file
View File

@@ -0,0 +1,36 @@
using System.Text.Json.Serialization;
namespace PARR.Domain.DTOs.Workload
{
/// <summary>
/// Инфо о состоянии КЭШ для отчета Workload
/// </summary>
public record WorkloadCacheInfo
{
/// <summary>
/// Статус отчета
/// </summary>
[JsonConverter(typeof(JsonStringEnumConverter))]
public enum StatusEnum
{
/// <summary>
/// Отчет формируется
/// </summary>
Processing = 1,
/// <summary>
/// Отчет сформирован
/// </summary>
Generated = 2,
/// <summary>
/// Нет отчета
/// </summary>
NotFound = 3
}
public StatusEnum Status { get; init; }
public DateTimeOffset? Date { get; init; }
}
}

7
PARR.Domain/Enums/ParrComponentsEnum.cs
View File

@@ -79,6 +79,11 @@ namespace PARR.Domain.Enums
/// <summary>
/// Генератор Template
/// </summary>
TemplateTaskGenerator = 13
TemplateTaskGenerator = 13,
/// <summary>
/// Генератор кэша отчетов Workload
/// </summary>
WorkloadBuilder = 14
}
}

32
PARR.Infrastructure/Redis/RedisCacheService.cs
View File

@@ -213,6 +213,38 @@ namespace PARR.Infrastructure.Redis
return JsonSerializer.Deserialize<T>(value);
}
public async Task<(string Field, T? Value)?> GetFirstHashFieldAsync<T>(string hashKey)
{
logger.LogDebug("Запрос первого поля из хеша '{HashKey}'", hashKey);
int attempts = 0;
int maxAttempts = 5;
await foreach (var entry in redis.HashScanAsync(hashKey, pageSize: 1))
{
if (++attempts > maxAttempts)
{
logger.LogWarning("Превышен лимит попыток ({Max}) для хеша '{HashKey}'", maxAttempts, hashKey);
return null;
}
if (entry.Value.IsNullOrEmpty)
{
logger.LogDebug("Поле '{Field}' в хеше '{HashKey}' пустое, пропускаем", entry.Name, hashKey);
continue;
}
var deserialized = JsonSerializer.Deserialize<T>(entry.Value);
logger.LogDebug("Получено поле '{Field}' из хеша '{HashKey}', тип: {Type}", entry.Name, hashKey, typeof(T).Name);
return (entry.Name.ToString(), deserialized);
}
logger.LogDebug("Хеш '{HashKey}' пуст или не существует", hashKey);
return null;
}
public async Task<Dictionary<string, T>> GetAllHashFieldsAsync<T>(string hashKey)
{
// получить все записи из Hash

25
PARR.WorkloadBuilderWorker/IntervalWorker.cs Normal file
View File

@@ -0,0 +1,25 @@
using PARR.Core.Services.Workload.Interfaces;
using PARR.WorkloadBuilderWorker.Settings;
namespace PARR.WorkloadBuilderWorker
{
public class IntervalWorker : BackgroundService
{
private readonly ILogger<IntervalWorker> logger;
private readonly IWorkloadIntervalService workloadIntervalService;
private readonly WorkerSettings workerSettings;
public IntervalWorker(ILogger<IntervalWorker> logger, IWorkloadIntervalService workloadIntervalService, WorkerSettings workerSettings)
{
this.logger = logger;
this.workloadIntervalService = workloadIntervalService;
this.workerSettings = workerSettings;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
logger.LogInformation("Запуск {workerName}", nameof(IntervalWorker));
await workloadIntervalService.StartAsync(workerSettings.RepeatEvery, workerSettings.MqSettings);
}
}
}

19
PARR.WorkloadBuilderWorker/Program.cs
View File

@@ -46,8 +46,25 @@ builder.Configuration.AddDalConfigurations(builder.Services);
builder.Services.AddDallSettings(builder.Configuration);
#endregion
// Задается через переменные окружеия
var runRabbit = builder.Configuration.GetValue<bool>("ENABLE_RABBIT", true);
var runInterval = builder.Configuration.GetValue<bool>("ENABLE_INTERVAL", true);
builder.Services.AddHostedService<Worker>();
if (runRabbit)
{
builder.Services.AddHostedService<RabbitWorker>();
}
if (runInterval)
{
builder.Services.AddHostedService<IntervalWorker>();
}
// Настройка краша при ошибке. Если хоть один из воркеров упадет, то падает целиком проект
builder.Services.Configure<HostOptions>(options =>
{
options.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.StopHost;
});
var host = builder.Build();
host.Run();

7
PARR.WorkloadBuilderWorker/Worker.cs → PARR.WorkloadBuilderWorker/RabbitWorker.cs
View File

@@ -3,13 +3,15 @@ using PARR.WorkloadBuilderWorker.Settings;
namespace PARR.WorkloadBuilderWorker
{
public class Worker : BackgroundService
public class RabbitWorker : BackgroundService
{
private readonly ILogger<RabbitWorker> logger;
private readonly IWorkloadCacheBuilderService workloadCacheBuilderService;
private readonly WorkerSettings workerSettings;
public Worker(ILogger<Worker> logger, IWorkloadCacheBuilderService workloadCacheBuilderService, WorkerSettings WorkerSettings)
public RabbitWorker(ILogger<RabbitWorker> logger, IWorkloadCacheBuilderService workloadCacheBuilderService, WorkerSettings WorkerSettings)
{
this.logger = logger;
this.workloadCacheBuilderService = workloadCacheBuilderService;
this.workerSettings = WorkerSettings;
}
@@ -17,6 +19,7 @@ namespace PARR.WorkloadBuilderWorker
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
logger.LogInformation("Запуск {workerName}", nameof(RabbitWorker));
await workloadCacheBuilderService.ProcessMessagesAsync(workerSettings.MqSettings);
}

8
PARR.WorkloadBuilderWorker/Settings/WorkerSettings.cs
View File

@@ -4,6 +4,14 @@ namespace PARR.WorkloadBuilderWorker.Settings
{
public record WorkerSettings
{
/// <summary>
/// Настройки MQ
/// </summary>
public MqSettingsBase MqSettings { get; init; } = new();
/// <summary>
/// Интервал повторений
/// </summary>
public TimeSpan RepeatEvery { get; init; }
}
}

3
PARR.WorkloadBuilderWorker/appsettings.json
View File

@@ -28,6 +28,7 @@
"QueueName": "parr-task-workload",
"User": "task_workload_reader",
"Password": "sdjfgIYFdifyKJFDhvsad@!314d"
}
},
"RepeatEvery": "12:00:00"
}
}

2
docker-compose.dcproj
View File

@@ -9,6 +9,7 @@
<DockerServiceName>parr.api</DockerServiceName>
</PropertyGroup>
<ItemGroup>
<None Include="docker-compose.task-reconciliation.yml" />
<None Include="docker-compose.template-matcher.yml" />
<None Include="docker-compose.template-generator.yml" />
<None Include="docker-compose.aihit-loader.yml" />
@@ -25,6 +26,7 @@
<None Include="docker-compose.template-activator.yml" />
<None Include="docker-compose.template-distributor.yml" />
<None Include="docker-compose.template-updater.yml" />
<None Include="docker-compose.workload-builder.yml" />
<None Include="docker-compose.yml" />
<None Include=".dockerignore" />
<None Include="stack.yml" />

27
docker-compose.workload-builder.yml
View File

@@ -2,11 +2,13 @@ version: '3.4'
# workload builder
services:
parr-workload-builder:
parr-workload-builder-interval:
image: harbor.dvgd.rzd/parr/parr-workload-builder:${tag:-latest}
environment:
- ASPNETCORE_ENVIRONMENT=Production
- TZ=Europe/Moscow
- ENABLE_RABBIT=false
- ENABLE_INTERVAL=true
logging:
driver: fluentd
options:
@@ -15,7 +17,28 @@ services:
fluentd-max-retries: '30'
fluentd-async: 'true'
fluentd-buffer-limit: '52428800'
tag: parr.workload-builder.serilog
tag: parr.workload-builder-interval.serilog
deploy:
replicas: 1
networks:
- parr-network
parr-workload-builder-rabbit:
image: harbor.dvgd.rzd/parr/parr-workload-builder:${tag:-latest}
environment:
- ASPNETCORE_ENVIRONMENT=Production
- TZ=Europe/Moscow
- ENABLE_RABBIT=true
- ENABLE_INTERVAL=false
logging:
driver: fluentd
options:
fluentd-address: dvgd-efk-01.dvgd.oao.rzd:24224
fluentd-retry-wait: '10s'
fluentd-max-retries: '30'
fluentd-async: 'true'
fluentd-buffer-limit: '52428800'
tag: parr.workload-builder-rabbit.serilog
deploy:
replicas: 1
networks: