File bsc#1117934-0001-Fix-scheduler-cl-5301-respect-... of Package pacemaker

Overview Repositories Revisions Requests Users Attributes Meta

File bsc#1117934-0001-Fix-scheduler-cl-5301-respect-order-constraints-when.patch of Package pacemaker (Revision 0af0dce49461b1acff542bea8cb6fdde)

Currently displaying revision 0af0dce49461b1acff542bea8cb6fdde , Show latest

From 99c01db7a94be6eeb2c62ed17c6640b1c80fa919 Mon Sep 17 00:00:00 2001
From: "Gao,Yan" <ygao@suse.com>
Date: Fri, 22 Feb 2019 11:49:30 +0100
Subject: [PATCH 1/3] Fix: scheduler: cl#5301 - respect order constraints when
 relevant resources are being probed

This fixes violations of order constraints introduced by faf44d811 and
8f76b7821.

Given the typical scenario with an order constraint "A.stop -> B.stop",
if A has been cleaned up and is being reprobed while B is stopping,
B.stop should wait for A.probe to complete. Since the pseudo action
"probe_complete" has been dropped by 8f76b7821, the solution here is to
optionally order "A.probe -> B.stop" as the possible alternative of
"A.stop -> B.stop".

This also addresses the cases where actions of B are other actions
than "stop", including order constraints like "A.stop -> B.start"
implied by anti-colocations.
---
 pengine/allocate.c | 165 +++++++++++++++++++++++++++++++++++-
 1 file changed, 164 insertions(+), 1 deletion(-)

Index: pacemaker-1.1.18+20180430.b12c320f5/pengine/allocate.c
===================================================================
--- pacemaker-1.1.18+20180430.b12c320f5.orig/pengine/allocate.c
+++ pacemaker-1.1.18+20180430.b12c320f5/pengine/allocate.c
@@ -2181,8 +2181,164 @@ apply_remote_node_ordering(pe_working_se
     }
 }
 
+static gboolean
+order_first_probe_unneeded(pe_action_t * probe, pe_action_t * rh_action)
+{
+    /* No need to probe the resource on the node that is being
+     * unfenced. Otherwise it might introduce transition loop
+     * since probe will be performed after the node is
+     * unfenced.
+     */
+    if (safe_str_eq(rh_action->task, CRM_OP_FENCE)
+         && probe->node && rh_action->node
+         && probe->node->details == rh_action->node->details) {
+        const char *op = g_hash_table_lookup(rh_action->meta, "stonith_action");
+
+        if (safe_str_eq(op, "on")) {
+            return TRUE;
+        }
+    }
+
+    // Shutdown waits for probe to complete only if it's on the same node
+    if ((safe_str_eq(rh_action->task, CRM_OP_SHUTDOWN))
+        && probe->node && rh_action->node
+        && probe->node->details != rh_action->node->details) {
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
 static void
-order_probes(pe_working_set_t * data_set) 
+order_first_probes(pe_working_set_t * data_set)
+{
+    GListPtr gIter = NULL;
+
+    for (gIter = data_set->ordering_constraints; gIter != NULL; gIter = gIter->next) {
+        order_constraint_t *order = gIter->data;
+        enum pe_ordering order_type = pe_order_optional;
+
+        pe_resource_t *lh_rsc = order->lh_rsc;
+        pe_resource_t *rh_rsc = order->rh_rsc;
+        pe_action_t *lh_action = order->lh_action;
+        pe_action_t *rh_action = order->rh_action;
+        const char *lh_action_task = order->lh_action_task;
+        const char *rh_action_task = order->rh_action_task;
+
+        char *key = NULL;
+        GListPtr probes = NULL;
+        GListPtr rh_actions = NULL;
+
+        GListPtr pIter = NULL;
+
+        if (lh_rsc == NULL) {
+            continue;
+
+        } else if (rh_rsc && lh_rsc == rh_rsc) {
+            continue;
+        }
+
+        if (lh_action == NULL && lh_action_task == NULL) {
+            continue;
+        }
+
+        if (rh_action == NULL && rh_action_task == NULL) {
+            continue;
+        }
+
+        /* Technically probe is expected to return "not running", which could be
+         * the alternative of stop action if the status of the resource is
+         * unknown yet.
+         */
+        if (lh_action && safe_str_neq(lh_action->task, RSC_STOP)) {
+            continue;
+
+        } else if (lh_action == NULL
+                   && lh_action_task
+                   && crm_ends_with(lh_action_task, "_" RSC_STOP "_0") == FALSE) {
+            continue;
+        }
+
+        /* Do not probe the resource inside of a stopping container. Otherwise
+         * it might introduce transition loop since probe will be performed
+         * after the container starts again.
+         */
+        if (rh_rsc && lh_rsc->container == rh_rsc) {
+            if (rh_action && safe_str_eq(rh_action->task, RSC_STOP)) {
+                continue;
+
+            } else if (rh_action == NULL && rh_action_task
+                       && crm_ends_with(rh_action_task,"_" RSC_STOP "_0")) {
+                continue;
+            }
+        }
+
+        if (order->type == pe_order_none) {
+            continue;
+        }
+
+        // Preserve the order options for future filtering
+        if (is_set(order->type, pe_order_apply_first_non_migratable)) {
+            set_bit(order_type, pe_order_apply_first_non_migratable);
+        }
+
+        if (is_set(order->type, pe_order_same_node)) {
+            set_bit(order_type, pe_order_same_node);
+        }
+
+        // Keep the order types for future filtering
+        if (order->type == pe_order_anti_colocation
+                   || order->type == pe_order_load) {
+            order_type = order->type;
+        }
+
+        key = generate_op_key(lh_rsc->id, RSC_STATUS, 0);
+        probes = find_actions(lh_rsc->actions, key, NULL);
+        free(key);
+
+        if (probes == NULL) {
+            continue;
+        }
+
+        if (rh_action) {
+            rh_actions = g_list_prepend(rh_actions, rh_action);
+
+        } else if (rh_rsc && rh_action_task) {
+            rh_actions = find_actions(rh_rsc->actions, rh_action_task, NULL);
+        }
+
+        if (rh_actions == NULL) {
+            g_list_free(probes);
+            continue;
+        }
+
+        crm_trace("Processing for LH probe based on ordering constraint %s -> %s"
+                  " (id=%d, type=%.6x)",
+                  lh_action ? lh_action->uuid : lh_action_task,
+                  rh_action ? rh_action->uuid : rh_action_task,
+                  order->id, order->type);
+
+        for (pIter = probes; pIter != NULL; pIter = pIter->next) {
+            pe_action_t *probe = (pe_action_t *) pIter->data;
+            GListPtr rIter = NULL;
+
+            for (rIter = rh_actions; rIter != NULL; rIter = rIter->next) {
+                pe_action_t *rh_action_iter = (pe_action_t *) rIter->data;
+
+                if (order_first_probe_unneeded(probe, rh_action_iter)) {
+                    continue;
+                }
+                order_actions(probe, rh_action_iter, order_type);
+            }
+        }
+
+        g_list_free(rh_actions);
+        g_list_free(probes);
+    }
+}
+
+static void
+order_then_probes(pe_working_set_t * data_set)
 {
 #if 0
     GListPtr gIter = NULL;
@@ -2303,6 +2459,13 @@ order_probes(pe_working_set_t * data_set
 #endif
 }
 
+static void
+order_probes(pe_working_set_t * data_set)
+{
+    order_first_probes(data_set);
+    order_then_probes(data_set);
+}
+
 gboolean
 stage7(pe_working_set_t * data_set)
 {

Places

File bsc#1117934-0001-Fix-scheduler-cl-5301-respect-order-constraints-when.patch of Package pacemaker (Revision 0af0dce49461b1acff542bea8cb6fdde)

Places