From 4e85d3012d61dcf534a51d4f82b91fce9aef8d0b Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Fri, 6 Dec 2019 11:57:59 -0600

Subject: [PATCH 02/10] Low: scheduler: respect shutdown locks when placing

 active resources

Use new pe_resource_t members to indicate that a resource is locked to a

particular node.

For active resources (i.e. in the transition where the node is scheduled for

shutdown), these are connected by checking each lockable resource for whether

it is running on a single clean node that is shutting down.

When applying constraints, place -INFINITY location constraints for locked

resources on all nodes other than the lock node.

(Inactive resources -- i.e. in later transitions after the node is shut down --

are not yet locked.)

---

 include/crm/pengine/status.h |  2 ++

 pengine/allocate.c           | 86 ++++++++++++++++++++++++++++++++++++++++++++

 2 files changed, 88 insertions(+)

diff --git a/include/crm/pengine/status.h b/include/crm/pengine/status.h

index c6d4bdb..1e8d5bb 100644

--- a/include/crm/pengine/status.h

+++ b/include/crm/pengine/status.h

@@ -347,6 +347,8 @@ struct resource_s {

     pe_working_set_t *cluster;

     pe_node_t *pending_node;    // Node on which pending_task is happening

+    pe_node_t *lock_node;       // Resource is shutdown-locked to this node

+    time_t lock_time;           // When shutdown lock started

 #if ENABLE_VERSIONED_ATTRS

     xmlNode *versioned_parameters;

diff --git a/pengine/allocate.c b/pengine/allocate.c

index 30d29e1..09f9e51 100644

--- a/pengine/allocate.c

+++ b/pengine/allocate.c

@@ -1009,6 +1009,86 @@ rsc_discover_filter(resource_t *rsc, node_t *node)

     }

 }

+static time_t

+shutdown_time(pe_node_t *node, pe_working_set_t *data_set)

+{

+    const char *shutdown = pe_node_attribute_raw(node, XML_CIB_ATTR_SHUTDOWN);

+    time_t result = 0;

+

+    if (shutdown) {

+        errno = 0;

+        result = (time_t) crm_int_helper(shutdown, NULL);

+        if (errno != 0) {

+            result = 0;

+        }

+    }

+    return result? result : get_effective_time(data_set);

+}

+

+static void

+apply_shutdown_lock(pe_resource_t *rsc, pe_working_set_t *data_set)

+{

+    const char *class;

+

+    // Only primitives and (uncloned) groups may be locked

+    if (rsc->variant == pe_group) {

+        for (GList *item = rsc->children; item != NULL;

+             item = item->next) {

+            apply_shutdown_lock((pe_resource_t *) item->data, data_set);

+        }

+    } else if (rsc->variant != pe_native) {

+        return;

+    }

+

+    // Fence devices and remote connections can't be locked

+    class = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS);

+    if ((class == NULL) || !strcmp(class, PCMK_RESOURCE_CLASS_STONITH)

+        || is_rsc_baremetal_remote_node(rsc, data_set)) {

+        return;

+    }

+

+    // Only a resource active on exactly one node can be locked

+    if (pcmk__list_of_1(rsc->running_on)) {

+        pe_node_t *node = rsc->running_on->data;

+

+        if (node->details->shutdown) {

+            if (node->details->unclean) {

+                pe_rsc_debug(rsc, "Not locking %s to unclean %s for shutdown",

+                             rsc->id, node->details->uname);

+            } else {

+                rsc->lock_node = node;

+                rsc->lock_time = shutdown_time(node, data_set);

+            }

+        }

+    }

+

+    if (rsc->lock_node == NULL) {

+        // No lock needed

+        return;

+    }

+

+    if (data_set->shutdown_lock > 0) {

+        time_t lock_expiration = rsc->lock_time + data_set->shutdown_lock;

+

+        pe_rsc_info(rsc, "Locking %s to %s due to shutdown (expires @%lld)",

+                    rsc->id, rsc->lock_node->details->uname,

+                    (long long) lock_expiration);

+    } else {

+        pe_rsc_info(rsc, "Locking %s to %s due to shutdown",

+                    rsc->id, rsc->lock_node->details->uname);

+    }

+

+    // If resource is locked to one node, ban it from all other nodes

+    for (GList *item = data_set->nodes; item != NULL; item = item->next) {

+        pe_node_t *node = item->data;

+

+        if (strcmp(node->details->uname, rsc->lock_node->details->uname)) {

+            resource_location(rsc, node, -INFINITY,

+                              XML_CONFIG_ATTR_SHUTDOWN_LOCK, data_set);

+        }

+    }

+}

+

 /*

  * Count how many valid nodes we have (so we know the maximum number of

  *  colors we can resolve).

@@ -1020,6 +1100,12 @@ stage2(pe_working_set_t * data_set)

 {

     GListPtr gIter = NULL;

+    if (is_set(data_set->flags, pe_flag_shutdown_lock)) {

+        for (gIter = data_set->resources; gIter != NULL; gIter = gIter->next) {

+            apply_shutdown_lock((pe_resource_t *) gIter->data, data_set);

+        }

+    }

+

     for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {

         node_t *node = (node_t *) gIter->data;

-- 

1.8.3.1