Ausnahmerichtlinie

Eine Ausnahmerichtlinie besteht aus Regeln, die festlegen, welche Aktionen beim Erfüllen einer Bedingung erfolgen. Sie können diese Richtlinien im Auftragsrouter speichern und dann an eine oder mehrere Warteschlangen anfügen.

Trigger

Die folgenden Trigger können zum Steuern von Aktionen verwendet werden:

Warteschlangenlänge: Wird ausgelöst, wenn die Länge der Warteschlange beim Hinzufügen des Auftrags einen festgelegten Schwellenwert überschreitet

Wartezeit: Wird ausgelöst, wenn der Auftrag sich für die Dauer des festgelegten Schwellenwerts in der Warteschlange befindet

Wenn diese Trigger ausgelöst werden, führen sie eine oder mehrere Aktionen aus und senden ein durch eine Ausnahme ausgelöstes Ereignis über Event Grid.

Aktionen

Abbrechen: Bricht den Auftrag ab und entfernt ihn aus der Warteschlange

Neuklassifizieren: Die angegebene Klassifizierungsrichtlinie wird mit geänderten Bezeichnungen erneut auf den Auftrag angewendet.

Manuelles Neuklassifizieren: Ändert die Warteschlangen-, Prioritäts- und Workerselektoren für den Auftrag

Beispiele

Im folgenden Beispiel konfigurieren wir eine Ausnahmerichtlinie, die einen Auftrag abbricht, bevor er eine Warteschlange mit einer Länge von mehr als 100 verknüpft.

await administrationClient.CreateExceptionPolicyAsync(new CreateExceptionPolicyOptions(
    exceptionPolicyId: "maxQueueLength",
    exceptionRules: new List<ExceptionRule>
    {
        new (id: "cancelJob",
            trigger: new QueueLengthExceptionTrigger(threshold: 100),
            actions: new List<ExceptionAction>{ new CancelExceptionAction() })
    }) { Name = "Max Queue Length Policy" });

await administrationClient.path("/routing/exceptionPolicies/{exceptionPolicyId}", "maxQueueLength").patch({
    body: {
        name: "Max Queue Length Policy",
        exceptionRules: [
        {
            id: "cancelJob",
            trigger: { kind: "queueLength", threshold: 100 },
            actions: [{ kind: "cancel" }]
        }
      ]
    }
});

administration_client.upsert_exception_policy(
    exception_policy_id = "maxQueueLength",
    name = "Max Queue Length Policy",
    exception_rules = [
        ExceptionRule(
            id = "cancelJob",
            trigger = QueueLengthExceptionTrigger(threshold = 100),
            actions = [ CancelExceptionAction() ]
        )
    ]
)

administrationClient.createExceptionPolicy(new CreateExceptionPolicyOptions("maxQueueLength",
    List.of(new ExceptionRule(
        "cancelJob",
        new QueueLengthExceptionTrigger(100),
        List.of(new CancelExceptionAction())))
).setName("Max Queue Length Policy"));

Im folgenden Beispiel wird eine Ausnahmerichtlinie mit Regeln konfiguriert, die folgende Auswirkung haben:

• Die Auftragspriorität wird auf 10 festgelegt, nachdem er sich für eine Minute in der Warteschlange befunden hat.
• Der Auftrag wird in queue2 verschoben, nachdem er sich für fünf Minuten in der Warteschlange befunden hat.

await administrationClient.CreateExceptionPolicyAsync(new CreateExceptionPolicyOptions(
    exceptionPolicyId: "policy2",
    exceptionRules: new List<ExceptionRule>
    {
        new(
            id: "increasePriority",
            trigger: new WaitTimeExceptionTrigger(threshold: TimeSpan.FromMinutes(1)),
            actions: new List<ExceptionAction>
            {
                new ManualReclassifyExceptionAction { Priority = 10 }
            }),
        new(
            id: "changeQueue",
            trigger: new WaitTimeExceptionTrigger(threshold: TimeSpan.FromMinutes(5)),
            actions: new List<ExceptionAction>
            {
                new ManualReclassifyExceptionAction { QueueId = "queue2" }
            })
    }) { Name = "Escalation Policy" });

await administrationClient.path("/routing/exceptionPolicies/{exceptionPolicyId}", "policy2").patch({
    body: {
        name: "Escalation Policy",
        exceptionRules: [
        {
            id: "increasePriority",
            trigger: { kind: "waitTime", thresholdSeconds: "60" },
            actions: [{ "manual-reclassify", priority: 10 }]
        },
        {
            id: "changeQueue",
            trigger: { kind: "waitTime", thresholdSeconds: "300" },
            actions: [{ kind: "manual-reclassify", queueId: "queue2" }]
        }]
    },
    contentType: "application/merge-patch+json"
  });

administration_client.upsert_exception_policy(
    exception_policy_id = "policy2",
    name = "Escalation Policy",
    exception_rules = [
        ExceptionRule(
            id = "increasePriority",
            trigger = WaitTimeExceptionTrigger(threshold_seconds = 60),
            actions = [ ManualReclassifyExceptionAction(priority = 10) ]
        ),
        ExceptionRule(
            id = "changeQueue",
            trigger = WaitTimeExceptionTrigger(threshold_seconds = 60),
            actions = [ ManualReclassifyExceptionAction(queue_id = "queue2") ]
        )
    ]
)

administrationClient.createExceptionPolicy(new CreateExceptionPolicyOptions("policy2", List.of(
    new ExceptionRule("increasePriority", new WaitTimeExceptionTrigger(Duration.ofMinutes(1)),
        List.of(new ManualReclassifyExceptionAction().setPriority(10))),
    new ExceptionRule("changeQueue", new WaitTimeExceptionTrigger(Duration.ofMinutes(5)),
        List.of(new ManualReclassifyExceptionAction().setQueueId("queue2"))))
).setName("Escalation Policy"));