File pacemaker-pengine-messages-assigning-resources-... of Package pacemaker

Overview Repositories Revisions Requests Users Attributes Meta

File pacemaker-pengine-messages-assigning-resources-to-nodes.patch of Package pacemaker (Revision 0e051afa0cc7159c73d2a3fcc79577e4)

Currently displaying revision 0e051afa0cc7159c73d2a3fcc79577e4 , Show latest

commit c3f3cc04133cdf8f21167740951a033d81de6c61
Author: Ken Gaillot <kgaillot@redhat.com>
Date:   Tue Oct 17 16:37:41 2017 -0500

Log: pengine: improve messages when assigning resources to nodes
    
    Most significantly, native_choose_node() was off by one when counting
    equal-weighted nodes, so no message would be logged when there were two.
    
    This also refactors for efficiency and readability.
    
    The only behavioral change is that when comparing the chosen node against
    allowed nodes of equal weight, allowed nodes that can't run resources won't be
    counted.

Index: pacemaker-1.1.16+20170320.77ea74d/pengine/clone.c
===================================================================
--- pacemaker-1.1.16+20170320.77ea74d.orig/pengine/clone.c
+++ pacemaker-1.1.16+20170320.77ea74d/pengine/clone.c
@@ -379,7 +379,8 @@ can_run_instance(resource_t * rsc, node_
         pe_rsc_trace(rsc, "%s cannot run on %s: Parent node weight doesn't allow it.",
                      rsc->id, node->details->uname);
     } else if (local_node->count < clone_data->clone_node_max) {
-        pe_rsc_trace(rsc, "%s can run on %s: %d", rsc->id, node->details->uname, local_node->count);
+        pe_rsc_trace(rsc, "%s can run on %s (already running %d)",
+                     rsc->id, node->details->uname, local_node->count);
         return local_node;
 
     } else {
@@ -402,7 +403,9 @@ color_instance(resource_t * rsc, node_t
     GHashTable *backup = NULL;
 
     CRM_ASSERT(rsc);
-    pe_rsc_trace(rsc, "Processing %s %d", rsc->id, all_coloc);
+    pe_rsc_trace(rsc, "Checking allocation of %s (preferring %s, using %s parent colocations)",
+                 rsc->id, (prefer? prefer->details->uname: "none"),
+                 (all_coloc? "all" : "some"));
 
     if (is_not_set(rsc->flags, pe_rsc_provisional)) {
         return rsc->fns->location(rsc, NULL, FALSE);
Index: pacemaker-1.1.16+20170320.77ea74d/pengine/native.c
===================================================================
--- pacemaker-1.1.16+20170320.77ea74d.orig/pengine/native.c
+++ pacemaker-1.1.16+20170320.77ea74d/pengine/native.c
@@ -82,98 +82,106 @@ gboolean (*rsc_action_matrix[RSC_ROLE_MA
 static gboolean
 native_choose_node(resource_t * rsc, node_t * prefer, pe_working_set_t * data_set)
 {
-    /*
-       1. Sort by weight
-       2. color.chosen_node = the node (of those with the highest wieght)
-       with the fewest resources
-       3. remove color.chosen_node from all other colors
-     */
     GListPtr nodes = NULL;
     node_t *chosen = NULL;
-
-    int lpc = 0;
-    int multiple = 0;
+    node_t *best = NULL;
+    int multiple = 1;
     int length = 0;
     gboolean result = FALSE;
 
     process_utilization(rsc, &prefer, data_set);
 
-    length = g_hash_table_size(rsc->allowed_nodes);
-
     if (is_not_set(rsc->flags, pe_rsc_provisional)) {
         return rsc->allocated_to ? TRUE : FALSE;
     }
 
-    if(rsc->allowed_nodes) {
+    // Sort allowed nodes by weight
+    if (rsc->allowed_nodes) {
+        length = g_hash_table_size(rsc->allowed_nodes);
+    }
+    if (length > 0) {
         nodes = g_hash_table_get_values(rsc->allowed_nodes);
-        nodes = g_list_sort_with_data(nodes, sort_node_weight, g_list_nth_data(rsc->running_on, 0));
+        nodes = g_list_sort_with_data(nodes, sort_node_weight,
+                                      g_list_nth_data(rsc->running_on, 0));
+
+        // First node in sorted list has the best score
+        best = g_list_nth_data(nodes, 0);
     }
-    if (prefer) {
-        node_t *best = g_list_nth_data(nodes, 0);
 
+    if (prefer && nodes) {
         chosen = g_hash_table_lookup(rsc->allowed_nodes, prefer->details->id);
-        if (chosen && chosen->weight >= 0
-            && chosen->weight >= best->weight /* Possible alternative: (chosen->weight >= INFINITY || best->weight < INFINITY) */
-            && can_run_resources(chosen)) {
-            pe_rsc_trace(rsc,
-                         "Using preferred node %s for %s instead of choosing from %d candidates",
-                         chosen->details->uname, rsc->id, length);
-        } else if (chosen && chosen->weight < 0) {
-            pe_rsc_trace(rsc, "Preferred node %s for %s was unavailable", chosen->details->uname,
-                         rsc->id);
+
+        if (chosen == NULL) {
+            pe_rsc_trace(rsc, "Preferred node %s for %s was unknown",
+                         prefer->details->uname, rsc->id);
+
+        /* Favor the preferred node as long as its weight is at least as good as
+         * the best allowed node's.
+         *
+         * An alternative would be to favor the preferred node even if the best
+         * node is better, when the best node's weight is less than INFINITY.
+         */
+        } else if ((chosen->weight < 0) || (chosen->weight < best->weight)) {
+            pe_rsc_trace(rsc, "Preferred node %s for %s was unsuitable",
+                         chosen->details->uname, rsc->id);
             chosen = NULL;
-        } else if (chosen && can_run_resources(chosen)) {
-            pe_rsc_trace(rsc, "Preferred node %s for %s was unsuitable", chosen->details->uname,
-                         rsc->id);
+
+        } else if (!can_run_resources(chosen)) {
+            pe_rsc_trace(rsc, "Preferred node %s for %s was unavailable",
+                         chosen->details->uname, rsc->id);
             chosen = NULL;
+
         } else {
-            pe_rsc_trace(rsc, "Preferred node %s for %s was unknown", prefer->details->uname,
-                         rsc->id);
+            pe_rsc_trace(rsc,
+                         "Chose preferred node %s for %s (ignoring %d candidates)",
+                         chosen->details->uname, rsc->id, length);
         }
     }
 
-    if (chosen == NULL && rsc->allowed_nodes) {
+    if ((chosen == NULL) && nodes) {
+        /* Either there is no preferred node, or the preferred node is not
+         * available, but there are other nodes allowed to run the resource.
+         */
 
-        chosen = g_list_nth_data(nodes, 0);
+        chosen = best;
         pe_rsc_trace(rsc, "Chose node %s for %s from %d candidates",
                      chosen ? chosen->details->uname : "<none>", rsc->id, length);
 
         if (chosen && chosen->weight > 0 && can_run_resources(chosen)) {
+            /* If the resource is already running on a node, prefer that node if
+             * it is just as good as the chosen node.
+             */
             node_t *running = g_list_nth_data(rsc->running_on, 0);
 
-            if (running && can_run_resources(running) == FALSE) {
+            if (running && (can_run_resources(running) == FALSE)) {
                 pe_rsc_trace(rsc, "Current node for %s (%s) can't run resources",
                              rsc->id, running->details->uname);
-                running = NULL;
-            }
-
-            for (lpc = 1; lpc < length && running; lpc++) {
-                node_t *tmp = g_list_nth_data(nodes, lpc);
-
-                if (tmp->weight == chosen->weight) {
-                    multiple++;
+            } else if (running) {
+                for (GList *iter = nodes->next; iter; iter = iter->next) {
+                    node_t *tmp = (node_t *) iter->data;
+
+                    if (tmp->weight != chosen->weight) {
+                        // The nodes are sorted by weight, so no more are equal
+                        break;
+                    }
                     if (tmp->details == running->details) {
-                        /* prefer the existing node if scores are equal */
+                        // Scores are equal, so prefer the current node
                         chosen = tmp;
                     }
+                    multiple++;
                 }
             }
         }
     }
 
     if (multiple > 1) {
-        int log_level = LOG_INFO;
         static char score[33];
+        int log_level = (chosen->weight >= INFINITY)? LOG_WARNING : LOG_INFO;
 
         score2char_stack(chosen->weight, score, sizeof(score));
-
-        if (chosen->weight >= INFINITY) {
-            log_level = LOG_WARNING;
-        }
-
-        do_crm_log(log_level, "%d nodes with equal score (%s) for"
-                   " running %s resources.  Chose %s.",
-                   multiple, score, rsc->id, chosen->details->uname);
+        do_crm_log(log_level,
+                   "Chose node %s for %s from %d nodes with score %s",
+                   chosen->details->uname, rsc->id, multiple, score);
     }
 
     result = native_assign_node(rsc, nodes, chosen, FALSE);

Places

File pacemaker-pengine-messages-assigning-resources-to-nodes.patch of Package pacemaker (Revision 0e051afa0cc7159c73d2a3fcc79577e4)

Places