Збудувати систему робочого потоку з HTMX та ASP.NET Core M SK1 Part 4: Hangfire Integration and Automation (Українська (Ukrainian))

Збудувати систему робочого потоку з HTMX та ASP.NET Core M SK1 Part 4: Hangfire Integration and Automation

Wednesday, 15 January 2025

//

12 minute read

Введение

В Частина 3, ми створили красивий візуальний редактор . Але наші робочі потоки запускаються тільки тоді, коли ми їх ручно запускаємо МSK2 В даному останньому пості МСК3 ми М СК4 зробимо робочі процеси дійсно автономними, використовуючи Hangfire для МСК5

  • Заплановане виконання - Запустити робочі потоки на графіку
  • Вибори API - Прослідкувати зовнішні API і триггерувати зміни
  • Керування державою - Статуї триггера трека впродовж виконання
  • Дошка для вібрацій - Наблюдайте за усіма роботами на фоні

Чому Hangfire?

Він ідеальний для наших потреб, тому що

  • Поміщає робочі місця в нашій базі даних PostgreSQL
  • Допоставляє вбудовану панель управления "-".
  • Подтримують повторювані роботи
  • Є автоматична логіка повторного спробування
  • Скала горизонтально

Модель триггера

По-перше, , дозволили ' зрозуміти наш триггерний стан МSK2 ми вже створили це в частині МSK3

[Table("workflow_trigger_states")]
public class WorkflowTriggerStateEntity
{
    public int Id { get; set; }
    public int WorkflowDefinitionId { get; set; }

    // Type: "Schedule", "ApiPoll", "Webhook"
    public string TriggerType { get; set; } = string.Empty;

    // Configuration as JSON
    public string ConfigJson { get; set; } = "{}";

    // Current state as JSON (stores last poll time, content hash, etc.)
    public string StateJson { get; set; } = "{}";

    public bool IsEnabled { get; set; } = true;
    public DateTime? LastCheckedAt { get; set; }
    public DateTime? LastFiredAt { get; set; }
    public int FireCount { get; set; } = 0;
    public string? LastError { get; set; }
}

Ця сутність відстежує все про триггер робочого потоку:

  • Коли вона закінчилась
  • Яка його конфігурація
  • Якого значення він має? ' в МSK1 для Statesful triggers )
  • Будь-які помилки, що виникли

Плановані робочі потоки

Модель налаштування

public class ScheduleTriggerConfig
{
    public string IntervalType { get; set; } = "minutes"; // minutes, hours, days
    public int IntervalValue { get; set; } = 60;
    public Dictionary<string, object>? InputData { get; set; }
}

Планувальника робота

public class WorkflowSchedulerJob
{
    private readonly MostlylucidDbContext _context;
    private readonly WorkflowExecutionService _executionService;
    private readonly ILogger<WorkflowSchedulerJob> _logger;

    [AutomaticRetry(Attempts = 3)]
    public async Task ExecuteScheduledWorkflowsAsync()
    {
        _logger.LogInformation("Checking for scheduled workflows");

        // Get all enabled schedule triggers
        var triggers = await _context.WorkflowTriggerStates
            .Include(t => t.WorkflowDefinition)
            .Where(t => t.IsEnabled && t.TriggerType == "Schedule")
            .ToListAsync();

        foreach (var trigger in triggers)
        {
            try
            {
                var config = JsonSerializer.Deserialize<ScheduleTriggerConfig>(
                    trigger.ConfigJson);

                if (config == null) continue;

                // Check if it's time to run
                if (!ShouldRunScheduledWorkflow(trigger, config))
                    continue;

                _logger.LogInformation(
                    "Executing scheduled workflow {WorkflowId}",
                    trigger.WorkflowDefinition.WorkflowId);

                // Execute the workflow
                await _executionService.ExecuteWorkflowAsync(
                    trigger.WorkflowDefinition.WorkflowId,
                    config.InputData,
                    "Scheduler");

                // Update trigger state
                trigger.LastCheckedAt = DateTime.UtcNow;
                trigger.LastFiredAt = DateTime.UtcNow;
                trigger.FireCount++;

                var state = JsonSerializer.Deserialize<Dictionary<string, object>>(
                                trigger.StateJson) ?? new();
                state["lastRun"] = DateTime.UtcNow.ToString("O");
                trigger.StateJson = JsonSerializer.Serialize(state);

                await _context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Error executing scheduled workflow {TriggerId}",
                    trigger.Id);
                trigger.LastError = ex.Message;
                await _context.SaveChangesAsync();
            }
        }
    }

    private bool ShouldRunScheduledWorkflow(
        WorkflowTriggerStateEntity trigger,
        ScheduleTriggerConfig config)
    {
        // First run?
        if (!trigger.LastFiredAt.HasValue)
            return true;

        var timeSinceLastRun = DateTime.UtcNow - trigger.LastFiredAt.Value;

        return config.IntervalType.ToLower() switch
        {
            "minutes" => timeSinceLastRun.TotalMinutes >= config.IntervalValue,
            "hours" => timeSinceLastRun.TotalHours >= config.IntervalValue,
            "days" => timeSinceLastRun.TotalDays >= config.IntervalValue,
            _ => false
        };
    }
}

Як це працює:

  1. Кожна хвилина, дзвінки Hangfire ExecuteScheduledWorkflowsAsync()
  2. Ми запитуємо про активовані триггери графіку
  3. Для кожного триггера, перевірити, чи минуло достатньо часу
  4. Якщо так, запустити робочий процес
  5. Обновлюйте стан триггера з останнім часом запуску

Оцінки API

Дослідження API цікавіше - ми перевіряємо зовнішні API і запускаємо робочі потоки, коли змінюється зміст !

Модель налаштування

public class ApiPollTriggerConfig
{
    public string Url { get; set; } = string.Empty;
    public int IntervalSeconds { get; set; } = 300; // 5 minutes
    public bool AlwaysTrigger { get; set; } = false;
    public Dictionary<string, string>? Headers { get; set; }
}

Дослідження

[AutomaticRetry(Attempts = 3)]
public async Task PollApiTriggersAsync()
{
    _logger.LogInformation("Polling API triggers");

    var triggers = await _context.WorkflowTriggerStates
        .Include(t => t.WorkflowDefinition)
        .Where(t => t.IsEnabled && t.TriggerType == "ApiPoll")
        .ToListAsync();

    foreach (var trigger in triggers)
    {
        try
        {
            var config = JsonSerializer.Deserialize<ApiPollTriggerConfig>(
                trigger.ConfigJson);

            if (config == null) continue;

            // Check if it's time to poll
            if (trigger.LastCheckedAt.HasValue)
            {
                var timeSinceLastCheck = DateTime.UtcNow - trigger.LastCheckedAt.Value;
                if (timeSinceLastCheck.TotalSeconds < config.IntervalSeconds)
                    continue;
            }

            _logger.LogInformation("Polling API for workflow {WorkflowId}",
                trigger.WorkflowDefinition.WorkflowId);

            // Poll the API
            using var httpClient = new HttpClient();
            var response = await httpClient.GetAsync(config.Url);
            var content = await response.Content.ReadAsStringAsync();

            // Get previous state
            var state = JsonSerializer.Deserialize<Dictionary<string, object>>(
                            trigger.StateJson) ?? new();

            var previousHash = state.GetValueOrDefault("contentHash")?.ToString();
            var currentHash = ComputeHash(content);

            // Has content changed?
            if (previousHash != currentHash || config.AlwaysTrigger)
            {
                _logger.LogInformation(
                    "API content changed, triggering workflow {WorkflowId}",
                    trigger.WorkflowDefinition.WorkflowId);

                // Pass response as input to workflow
                var inputData = new Dictionary<string, object>
                {
                    ["apiResponse"] = content,
                    ["statusCode"] = (int)response.StatusCode,
                    ["previousHash"] = previousHash ?? string.Empty,
                    ["currentHash"] = currentHash
                };

                // Execute the workflow
                await _executionService.ExecuteWorkflowAsync(
                    trigger.WorkflowDefinition.WorkflowId,
                    inputData,
                    $"ApiPoll:{config.Url}");

                trigger.LastFiredAt = DateTime.UtcNow;
                trigger.FireCount++;

                // Update state
                state["contentHash"] = currentHash;
                state["lastContent"] = content.Length > 1000
                    ? content.Substring(0, 1000)
                    : content;
                state["lastPoll"] = DateTime.UtcNow.ToString("O");
            }

            trigger.LastCheckedAt = DateTime.UtcNow;
            trigger.StateJson = JsonSerializer.Serialize(state);
            trigger.LastError = null;

            await _context.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error polling API trigger {TriggerId}",
                trigger.Id);
            trigger.LastError = ex.Message;
            trigger.LastCheckedAt = DateTime.UtcNow;
            await _context.SaveChangesAsync();
        }
    }
}

private string ComputeHash(string content)
{
    using var sha256 = System.Security.Cryptography.SHA256.Create();
    var bytes = System.Text.Encoding.UTF8.GetBytes(content);
    var hash = sha256.ComputeHash(bytes);
    return Convert.ToBase64String(hash);
}

Як це працює:

  1. Кожна хвилина, перевіряє всі триггери API
  2. Для кожного триггера, перевірити, чи минуло достатньо часу з останнього опитування
  3. Запросити за допомогою настроїного URL
  4. Вирахуйте хеш контенту відповіді
  5. Порівняйте з попереднім хешом, зберіганим у стані
  6. Якщо змінити ( або AlwaysTrigger це правда), виконати робочий процес
  7. Передавати API відповідь як вхідні дані до робочого потоку
  8. Обновлюйте стан за допомогою нового hash

Використовуйте приклад ситуації

Monitor GitHub Releases:

{
  "triggerType": "ApiPoll",
  "config": {
    "url": "https://api.github.com/repos/dotnet/aspnetcore/releases/latest",
    "intervalSeconds": 3600,
    "alwaysTrigger": false
  }
}

Це перевіряє API GitHub щогодини. Коли виходить новий релиз, змінюється хеш контентуM SK2 і робочий процес виконується з даними релізу !

Зареєстрація робочих місць Hangfire

У вашому Program.cs або налагодження:

// Add Hangfire services
builder.Services.AddHangfire(config =>
{
    config.UsePostgreSqlStorage(
        builder.Configuration.GetConnectionString("DefaultConnection"));
});

builder.Services.AddHangfireServer();

// Register our job
builder.Services.AddScoped<WorkflowSchedulerJob>();

Потім, після запуску програмиM SK1 зареєструвати повторювані роботи:

app.UseHangfireDashboard("/hangfire");

// Register recurring jobs
RecurringJob.AddOrUpdate<WorkflowSchedulerJob>(
    "scheduled-workflows",
    job => job.ExecuteScheduledWorkflowsAsync(),
    Cron.Minutely);

RecurringJob.AddOrUpdate<WorkflowSchedulerJob>(
    "api-poll-triggers",
    job => job.PollApiTriggersAsync(),
    Cron.Minutely);

Навігаційний дошboard Hangfire

У Hangfire є вбудована панель управления, доступна на сайті /hangfire:

  • Роботи: Подивіться на всі заліковані, обробкаM SK2 і завершені завдання
  • Рекурентні роботи: Управляйте нашими планувальниками робочого процесу
  • Переходи: Ви бачите і повторює не вдалені завдання
  • Сервери: Мониторинг серверів Hangfire

Забезпечувати дисплей

app.UseHangfireDashboard("/hangfire", new DashboardOptions
{
    Authorization = new[]
    {
        new HangfireAuthorizationFilter()
    }
});

public class HangfireAuthorizationFilter : IDashboardAuthorizationFilter
{
    public bool Authorize(DashboardContext context)
    {
        var httpContext = context.GetHttpContext();

        // Only allow authenticated users
        return httpContext.User.Identity?.IsAuthenticated == true;
    }
}

Керування триггерами через інтерфейс

Дозвольте додати інтерфейс для створення та управління триггерами

[HttpPost("workflow/{id}/triggers")]
public async Task<IActionResult> CreateTrigger(
    string id,
    [FromBody] TriggerCreateRequest request)
{
    var workflow = await _context.WorkflowDefinitions
        .FirstOrDefaultAsync(w => w.WorkflowId == id);

    if (workflow == null)
        return NotFound();

    var trigger = new WorkflowTriggerStateEntity
    {
        WorkflowDefinitionId = workflow.Id,
        TriggerType = request.Type,
        ConfigJson = JsonSerializer.Serialize(request.Config),
        StateJson = "{}",
        IsEnabled = true
    };

    await _context.WorkflowTriggerStates.AddAsync(trigger);
    await _context.SaveChangesAsync();

    return Json(new { success = true, triggerId = trigger.Id });
}

public class TriggerCreateRequest
{
    public string Type { get; set; } = string.Empty; // Schedule, ApiPoll
    public object Config { get; set; } = new();
}

Компонент інтерфейсу

<div class="card bg-base-100 shadow-xl">
    <div class="card-body">
        <h2 class="card-title">⏰ Add Trigger</h2>

        <div class="form-control">
            <label class="label">Trigger Type</label>
            <select class="select select-bordered" x-model="triggerType">
                <option value="Schedule">Schedule</option>
                <option value="ApiPoll">API Poll</option>
            </select>
        </div>

        <!-- Schedule Config -->
        <template x-if="triggerType === 'Schedule'">
            <div class="space-y-4">
                <div class="form-control">
                    <label class="label">Interval</label>
                    <div class="flex gap-2">
                        <input type="number"
                               x-model="scheduleConfig.intervalValue"
                               class="input input-bordered flex-1" />
                        <select x-model="scheduleConfig.intervalType"
                                class="select select-bordered">
                            <option value="minutes">Minutes</option>
                            <option value="hours">Hours</option>
                            <option value="days">Days</option>
                        </select>
                    </div>
                </div>
            </div>
        </template>

        <!-- API Poll Config -->
        <template x-if="triggerType === 'ApiPoll'">
            <div class="space-y-4">
                <div class="form-control">
                    <label class="label">API URL</label>
                    <input type="url"
                           x-model="apiConfig.url"
                           class="input input-bordered"
                           placeholder="https://api.example.com/data" />
                </div>

                <div class="form-control">
                    <label class="label">Poll Interval (seconds)</label>
                    <input type="number"
                           x-model="apiConfig.intervalSeconds"
                           class="input input-bordered"
                           value="300" />
                </div>
            </div>
        </template>

        <button @click="createTrigger()" class="btn btn-primary mt-4">
            Create Trigger
        </button>
    </div>
</div>

Реальний- Світовий приклад робочого процесу

Дозвольте створити повний автоматичний робочий процес, який

  1. Проаналізував API GitHub для нових релізів
  2. Проверяє, чи версія молодша за ту, яку ми бачили
  3. Записує повідомлення
  4. (Могла б надіслати електронну пошту , листа на SlackM SK2 і т.д.

Шаг 1: Створити робочий процес

{
  "name": "GitHub Release Monitor",
  "startNodeId": "parse-data",
  "nodes": [
    {
      "id": "parse-data",
      "type": "Transform",
      "name": "Extract Version",
      "inputs": {
        "operation": "json_parse",
        "data": "{{apiResponse}}"
      }
    },
    {
      "id": "log-release",
      "type": "Log",
      "name": "Log New Release",
      "inputs": {
        "message": "New release: {{tag_name}} - {{name}}",
        "level": "info"
      }
    }
  ],
  "connections": [
    {
      "sourceNodeId": "parse-data",
      "targetNodeId": "log-release"
    }
  ]
}

Шаг 2: Створити API Poll Trigger

{
  "type": "ApiPoll",
  "config": {
    "url": "https://api.github.com/repos/dotnet/aspnetcore/releases/latest",
    "intervalSeconds": 3600
  }
}

Тепер МСК0 щогодини МSK1 Хонгфайр буде :

  1. Запроси API GitHub
  2. Порівняйте хеш контенту з попереднім опитуванням
  3. Якщо змінювати,, запустити робочий процес
  4. Рабочий процес аналізує JSON і записує інформацію про реліз

Monitoring and Observability

Запис

Усі виконання потоку праці зареєстровані:

_logger.LogInformation(
    "Workflow {WorkflowId} execution {ExecutionId} completed in {Duration}ms with status {Status}",
    execution.WorkflowId,
    execution.Id,
    execution.DurationMs,
    execution.Status);

Метріка

Ми можемо додати метрики Прометеуса:

private static readonly Counter WorkflowExecutions = Metrics
    .CreateCounter("workflow_executions_total",
        "Total workflow executions",
        new CounterConfiguration
        {
            LabelNames = new[] { "workflow_id", "status" }
        });

// In execution service
WorkflowExecutions
    .WithLabels(workflow.Id, execution.Status.ToString())
    .Inc();

Застереження

Установити попередження для:

  • Невдачі робочі потоки (Status == Невдалий МSK2
  • Рабочі потоки займають надто багато часу
  • Непрацездатність API
  • Триггери, які не вистрілили в очікуваний час

Рівень ефективності

Завантаження бази даних

Коли багато операційних потоків часто прослуховуються, то завантаження бази даних може бути значущою.

Рішення: Batch queries

// Instead of querying per trigger
var triggers = await _context.WorkflowTriggerStates
    .Include(t => t.WorkflowDefinition)
    .Where(t => t.IsEnabled && t.TriggerType == "ApiPoll")
    .AsNoTracking() // Read-only
    .ToListAsync();

Ограничення швидкості API

Коли перевіряють зовнішні API:

Рішення: Экспоненційний відхилення

catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.TooManyRequests)
{
    // Back off
    var retryAfter = response.Headers.RetryAfter?.Delta ?? TimeSpan.FromMinutes(5);
    state["backoffUntil"] = DateTime.UtcNow.Add(retryAfter).ToString("O");
}

Заawansовані характеристики

Потрібні триггери

Тільки тоді, коли певні умови відповідають.:

public class ConditionalTriggerConfig : ApiPollTriggerConfig
{
    public string? Condition { get; set; } // e.g., "{{stars}} > 1000"
}

Триггер залежності

Шлях триггерів - один робочий процес

// After workflow completes
if (execution.Status == WorkflowExecutionStatus.Completed)
{
    var dependentTriggers = await _context.WorkflowTriggerStates
        .Where(t => t.TriggerType == "WorkflowComplete" &&
                    t.ConfigJson.Contains(execution.WorkflowId))
        .ToListAsync();

    foreach (var trigger in dependentTriggers)
    {
        await _executionService.ExecuteWorkflowAsync(
            trigger.WorkflowDefinition.WorkflowId,
            execution.OutputData,
            $"Triggered by {execution.WorkflowId}");
    }
}

Випробовування робіт Hangfire

Unit test your jobs:

[Fact]
public async Task ExecuteScheduledWorkflows_ShouldExecuteWhenIntervalPassed()
{
    // Arrange
    var mockContext = CreateMockContext();
    var mockExecutionService = new Mock<IWorkflowExecutionService>();
    var job = new WorkflowSchedulerJob(mockContext.Object,
        mockExecutionService.Object, Mock.Of<ILogger>());

    // Act
    await job.ExecuteScheduledWorkflowsAsync();

    // Assert
    mockExecutionService.Verify(s => s.ExecuteWorkflowAsync(
        It.IsAny<string>(),
        It.IsAny<Dictionary<string, object>>(),
        "Scheduler",
        It.IsAny<CancellationToken>()), Times.Once);
}

Завершення

Ми збудували цілу систему автоматизації.

✅ Працювати на графіку - Щогодини , щоденноM SK2 або на замовлення ✅ API для опитування - Наблюдайте за зовнішніми службами за змінами ✅ Статус трека - Пам 'ятайте, що ми бачили раніше ✅ Автоматичний-поновлення - Рухати через тимчасові невдачі ✅ Навігатор - Панель для всіх робіт ✅ Скала - Гамвайний вогник управляє балансуванням навантаження

Уся серія

Ми - МСК0 - побудували компанію - МSK1 - з нуля - систему робочого потоку - :

  • Частина 1: Вprowadzenie та архітектура
  • Частина 2: Кораовий двигун робочого потоку
  • Частина 3: Редактор візуального процесу роботи
  • Частина 4: інтеграція Хонґфайр .

Тепер у вас є:

  • Мощний двигун робочого потоку
  • Красивий візуальний редактор
  • Автоматична виконання
  • Мониторинг API
  • Полна спостережливість

Що' СледующаяM SK1

Можні покращення:

  • Веб-хок: Пришвидшує робочі потоки за допомогою кінцевих точок HTTP
  • Е-мейлні вузли: Посилати електронні листи з операційних потоків
  • Ноди бази даних: Базини запитів
  • Ноди штучного інтелекту: Об 'єднати з LLM
  • Sub- робочі потоки: Створити робочі потоки разом
  • Ринок робочого потоку: Шаблони для спільних операцій

Источник

Весь код доступний в базі даних:

  • Роботи Hangfire: Mostlylucid.SchedulerService/Jobs/
  • Моделі робочого процесу: Mostlylucid.Workflow.Shared/
  • Мотор робочого процесу: Mostlylucid.Workflow.Engine/

Дякую за те, що стежили за цією серії.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.