Queue-Worker-Pattern¶
Mit dem Queue-Worker-Pattern beobachtet eine Anwendung eine oder mehrere Queues und übergibt jede Nachricht an
einen passenden Worker. Nachrichten sind JSON-Objekte; das Feld Worker entscheidet, welcher Worker die
Nachricht verarbeitet. Ein Worker kann sein Ergebnis in eine Result Queue schreiben, wo es der nächste Worker abholt.
sequenceDiagram
participant App as Anwendung
participant MQ as MessageQueue.NET
participant W as Queue Watcher
participant Wk as Worker
App->>MQ: JSON-Nachricht einreihen (Worker = "my.worker")
MQ->>W: Nachricht ausliefern (Long Polling)
W->>Wk: Process(message)
Wk-->>W: QueueProcessorResult
W->>MQ: Nachricht bestätigen
W->>MQ: Ergebnis in ResultQueue einreihen (optional)
Nachrichten¶
Jede Nachricht basiert auf BaseQueueProcessorMessage:
public class BaseQueueProcessorMessage
{
public string ProcessId { get; set; } = "";
public string Worker { get; set; } = ""; // (1)!
public string? ResultQueue { get; set; } // (2)!
public string? Publisher { get; set; }
public string? Subject { get; set; }
}
- Die
WorkerIddes Workers, der die Nachricht verarbeitet. - Optional: Das Ergebnis des Workers wird in diese Queue geschrieben.
GenericQueueProcessorMessage<T> ergänzt einen typisierten Body.
Worker¶
Ein Worker implementiert IQueueProcessor:
true: Die Nachricht wird nach der Verarbeitung bestätigt, auch wenn der Worker fehlschlägt.
Es gibt zwei Arten von Workern:
Einrichtung¶
Client-Service und Queue Watcher registrieren:
using MessageQueueNET.Client.Extensions.DependencyInjetion;
builder.Services
.AddMessageQueueClientService()
.AddQueueProcessorWatcher(config =>
{
config.MessageQueueApiUrl = "https://localhost:5001";
config.QueueNameFilter = "mq-processor.jobs"; // (1)!
});
- Eine Queue (
my-queue), ein Muster (my-queues.*) oder mehrere Muster (my-queues.*,our-queues.*).
Weitere Optionen: MessageQueueClientId, MessageQueueClientSecret, MaxPollingSeconds und TryRegisterQueues.
Test mit dem Ping-Worker¶
AddQueueProcessorWatcher fügt den PingWorker (mq.ping) hinzu. Er schreibt sein Ergebnis nach
ping.response.{ResultQueue}. Testen mit mqnet:
flowchart LR
cmd[mqnet: enqueue -ping]
q1([mq-processor.jobs])
watcher[Queue Watcher]
worker[PingWorker]
q2([ping.response.mq-processor.jobs])
cmd --> q1 --> watcher --> worker --> q2
Eigene Worker¶
Ein Body-Modell und bei Bedarf ein Ergebnis-Modell definieren:
public class CommandLineWorkerMessage
{
public string Command { get; set; } = "";
public string Arguments { get; set; } = "";
}
public class CommandLineWorkerResultBody
{
public int ExitCode { get; set; }
public string? Output { get; set; }
public string? ErrorOutput { get; set; }
}
Den Worker implementieren:
public class CommandLineWorker : IGenericQueueProcessor<CommandLineWorkerMessage>
{
public const string WorkerIdentifier = "mq.commandline";
public string WorkerId => WorkerIdentifier;
public bool ConfirmAlways => true;
public async Task<QueueProcessorResult> ProcessGeneric(
GenericQueueProcessorMessage<CommandLineWorkerMessage> message,
CancellationToken cancellationToken)
{
try
{
// Geschäftslogik ...
return new GenericQueueProcessorResult<CommandLineWorkerResultBody>() // (1)!
{
Worker = "mq-commandline.result.file",
Body = new CommandLineWorkerResultBody()
{
ExitCode = 0,
Output = "..."
}
};
}
catch (Exception ex)
{
return new QueueProcessorResult()
{
Succeeded = false,
ErrorMessages = ex.ToString()
};
}
}
}
- Hat die Nachricht eine
ResultQueue, wird dieses Ergebnis dort als Nachricht für den Workermq-commandline.result.fileeingereiht.
Den Worker registrieren:
Worker-Nachrichten senden¶
Die Nachricht serialisieren und mit dem Client einreihen:
var message = new GenericQueueProcessorMessage<CommandLineWorkerMessage>()
{
ProcessId = Guid.NewGuid().ToString(),
Worker = CommandLineWorker.WorkerIdentifier,
ResultQueue = "mq-processor.jobs.results",
Publisher = Environment.UserName,
Body = new()
{
Command = @"c:\temp\test.bat",
Arguments = "123"
}
};
await client.EnqueueAsync([JsonSerializer.Serialize(message)]);