pacemaker  2.0.3-4b1f869f0f
Scalable High-Availability cluster resource manager
common.c
Go to the documentation of this file.
1 /*
2  * Copyright 2004-2018 Andrew Beekhof <andrew@beekhof.net>
3  *
4  * This source code is licensed under the GNU Lesser General Public License
5  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
6  */
7 
8 #include <crm_internal.h>
9 #include <crm/crm.h>
10 #include <crm/msg_xml.h>
11 #include <crm/common/xml.h>
12 #include <crm/common/util.h>
13 
14 #include <glib.h>
15 
16 #include <crm/pengine/internal.h>
17 
18 gboolean was_processing_error = FALSE;
19 gboolean was_processing_warning = FALSE;
20 
21 static gboolean
22 check_health(const char *value)
23 {
24  if (safe_str_eq(value, "none")) {
25  return TRUE;
26 
27  } else if (safe_str_eq(value, "custom")) {
28  return TRUE;
29 
30  } else if (safe_str_eq(value, "only-green")) {
31  return TRUE;
32 
33  } else if (safe_str_eq(value, "progressive")) {
34  return TRUE;
35 
36  } else if (safe_str_eq(value, "migrate-on-red")) {
37  return TRUE;
38  }
39  return FALSE;
40 }
41 
42 static gboolean
43 check_stonith_action(const char *value)
44 {
45  if (safe_str_eq(value, "reboot")) {
46  return TRUE;
47 
48  } else if (safe_str_eq(value, "poweroff")) {
49  return TRUE;
50 
51  } else if (safe_str_eq(value, "off")) {
52  return TRUE;
53  }
54  return FALSE;
55 }
56 
57 static gboolean
58 check_placement_strategy(const char *value)
59 {
60  if (safe_str_eq(value, "default")) {
61  return TRUE;
62 
63  } else if (safe_str_eq(value, "utilization")) {
64  return TRUE;
65 
66  } else if (safe_str_eq(value, "minimal")) {
67  return TRUE;
68 
69  } else if (safe_str_eq(value, "balanced")) {
70  return TRUE;
71  }
72  return FALSE;
73 }
74 
75 /* *INDENT-OFF* */
76 static pe_cluster_option pe_opts[] = {
77  /* name, old-name, validate, default, description */
78  { "no-quorum-policy", NULL, "enum", "stop, freeze, ignore, suicide", "stop", &check_quorum,
79  "What to do when the cluster does not have quorum", NULL },
80  { "symmetric-cluster", NULL, "boolean", NULL, "true", &check_boolean,
81  "All resources can run anywhere by default", NULL },
82  { "maintenance-mode", NULL, "boolean", NULL, "false", &check_boolean,
83  "Should the cluster monitor resources and start/stop them as required", NULL },
84  { "start-failure-is-fatal", NULL, "boolean", NULL, "true", &check_boolean, "Always treat start failures as fatal",
85  "When set to TRUE, the cluster will immediately ban a resource from a node if it fails to start there. When FALSE, the cluster will instead check the resource's fail count against its migration-threshold." },
86  { "enable-startup-probes", NULL, "boolean", NULL, "true", &check_boolean,
87  "Should the cluster check for active resources during startup", NULL },
88 
89  /* Stonith Options */
90  { "stonith-enabled", NULL, "boolean", NULL, "true", &check_boolean,
91  "Failed nodes are STONITH'd", NULL },
92  { "stonith-action", NULL, "enum", "reboot, off, poweroff", "reboot", &check_stonith_action,
93  "Action to send to STONITH device ('poweroff' is a deprecated alias for 'off')", NULL },
94  { "stonith-timeout", NULL, "time", NULL, "60s", &check_timer,
95  "How long to wait for the STONITH action (reboot,on,off) to complete", NULL },
96  { XML_ATTR_HAVE_WATCHDOG, NULL, "boolean", NULL, "false", &check_boolean,
97  "Enable watchdog integration", "Set automatically by the cluster if SBD is detected. User configured values are ignored." },
98  { "concurrent-fencing", NULL, "boolean", NULL,
99 #ifdef DEFAULT_CONCURRENT_FENCING_TRUE
100  "true",
101 #else
102  "false",
103 #endif
104  &check_boolean,
105  "Allow performing fencing operations in parallel", NULL },
106  { "startup-fencing", NULL, "boolean", NULL, "true", &check_boolean,
107  "STONITH unseen nodes", "Advanced Use Only! Not using the default is very unsafe!" },
108 
109  /* Timeouts etc */
110  { "cluster-delay", NULL, "time", NULL, "60s", &check_time,
111  "Round trip delay over the network (excluding action execution)",
112  "The \"correct\" value will depend on the speed and load of your network and cluster nodes." },
113  { "batch-limit", NULL, "integer", NULL, "0", &check_number,
114  "The number of jobs that the TE is allowed to execute in parallel",
115  "The \"correct\" value will depend on the speed and load of your network and cluster nodes." },
116  { "migration-limit", NULL, "integer", NULL, "-1", &check_number,
117  "The number of migration jobs that the TE is allowed to execute in parallel on a node"},
118 
119  /* Orphans and stopping */
120  { "stop-all-resources", NULL, "boolean", NULL, "false", &check_boolean,
121  "Should the cluster stop all active resources", NULL },
122  { "stop-orphan-resources", NULL, "boolean", NULL, "true", &check_boolean,
123  "Should deleted resources be stopped", NULL },
124  { "stop-orphan-actions", NULL, "boolean", NULL, "true", &check_boolean,
125  "Should deleted actions be cancelled", NULL },
126  { "remove-after-stop", NULL, "boolean", NULL, "false", &check_boolean,
127  "Remove resources from the executor after they are stopped",
128  "Always set this to false. Other values are, at best, poorly tested and potentially dangerous." },
129 /* { "", "", , "0", "", NULL }, */
130 
131  /* Storing inputs */
132  {
133  "pe-error-series-max", NULL, "integer", NULL, "-1", &check_number,
134  "The number of scheduler inputs resulting in ERRORs to save",
135  "Zero to disable, -1 to store unlimited"
136  },
137  {
138  "pe-warn-series-max", NULL, "integer", NULL, "5000", &check_number,
139  "The number of scheduler inputs resulting in WARNINGs to save",
140  "Zero to disable, -1 to store unlimited"
141  },
142  {
143  "pe-input-series-max", NULL, "integer", NULL, "4000", &check_number,
144  "The number of other scheduler inputs to save",
145  "Zero to disable, -1 to store unlimited"
146  },
147 
148  /* Node health */
149  { "node-health-strategy", NULL, "enum", "none, migrate-on-red, only-green, progressive, custom", "none", &check_health,
150  "The strategy combining node attributes to determine overall node health.",
151  "Requires external entities to create node attributes (named with the prefix '#health') with values: 'red', 'yellow' or 'green'."},
152  { "node-health-base", NULL, "integer", NULL, "0", &check_number,
153  "The base score assigned to a node",
154  "Only used when node-health-strategy is set to progressive." },
155  { "node-health-green", NULL, "integer", NULL, "0", &check_number,
156  "The score 'green' translates to in rsc_location constraints",
157  "Only used when node-health-strategy is set to custom or progressive." },
158  { "node-health-yellow", NULL, "integer", NULL, "0", &check_number,
159  "The score 'yellow' translates to in rsc_location constraints",
160  "Only used when node-health-strategy is set to custom or progressive." },
161  { "node-health-red", NULL, "integer", NULL, "-INFINITY", &check_number,
162  "The score 'red' translates to in rsc_location constraints",
163  "Only used when node-health-strategy is set to custom or progressive." },
164 
165  /*Placement Strategy*/
166  { "placement-strategy", NULL, "enum", "default, utilization, minimal, balanced", "default", &check_placement_strategy,
167  "The strategy to determine resource placement", NULL},
168 };
169 /* *INDENT-ON* */
170 
171 void
173 {
174  config_metadata("pacemaker-schedulerd", "1.0", "scheduler properties",
175  "Cluster properties used by Pacemaker's scheduler,"
176  " formerly known as pengine",
177  pe_opts, DIMOF(pe_opts));
178 }
179 
180 void
181 verify_pe_options(GHashTable * options)
182 {
183  verify_all_options(options, pe_opts, DIMOF(pe_opts));
184 }
185 
186 const char *
187 pe_pref(GHashTable * options, const char *name)
188 {
189  return get_cluster_pref(options, pe_opts, DIMOF(pe_opts), name);
190 }
191 
192 const char *
194 {
195  const char *result = "<unknown>";
196 
197  switch (fail) {
198  case action_fail_ignore:
199  result = "ignore";
200  break;
201  case action_fail_block:
202  result = "block";
203  break;
204  case action_fail_recover:
205  result = "recover";
206  break;
207  case action_fail_migrate:
208  result = "migrate";
209  break;
210  case action_fail_stop:
211  result = "stop";
212  break;
213  case action_fail_fence:
214  result = "fence";
215  break;
216  case action_fail_standby:
217  result = "standby";
218  break;
220  result = "restart-container";
221  break;
223  result = "reset-remote";
224  break;
225  }
226  return result;
227 }
228 
229 enum action_tasks
230 text2task(const char *task)
231 {
232  if (safe_str_eq(task, CRMD_ACTION_STOP)) {
233  return stop_rsc;
234  } else if (safe_str_eq(task, CRMD_ACTION_STOPPED)) {
235  return stopped_rsc;
236  } else if (safe_str_eq(task, CRMD_ACTION_START)) {
237  return start_rsc;
238  } else if (safe_str_eq(task, CRMD_ACTION_STARTED)) {
239  return started_rsc;
240  } else if (safe_str_eq(task, CRM_OP_SHUTDOWN)) {
241  return shutdown_crm;
242  } else if (safe_str_eq(task, CRM_OP_FENCE)) {
243  return stonith_node;
244  } else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
245  return monitor_rsc;
246  } else if (safe_str_eq(task, CRMD_ACTION_NOTIFY)) {
247  return action_notify;
248  } else if (safe_str_eq(task, CRMD_ACTION_NOTIFIED)) {
249  return action_notified;
250  } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
251  return action_promote;
252  } else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
253  return action_demote;
254  } else if (safe_str_eq(task, CRMD_ACTION_PROMOTED)) {
255  return action_promoted;
256  } else if (safe_str_eq(task, CRMD_ACTION_DEMOTED)) {
257  return action_demoted;
258  }
259 #if SUPPORT_TRACING
260  if (safe_str_eq(task, CRMD_ACTION_CANCEL)) {
261  return no_action;
262  } else if (safe_str_eq(task, CRMD_ACTION_DELETE)) {
263  return no_action;
264  } else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
265  return no_action;
266  } else if (safe_str_eq(task, CRM_OP_PROBED)) {
267  return no_action;
268  } else if (safe_str_eq(task, CRM_OP_LRM_REFRESH)) {
269  return no_action;
270  } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE)) {
271  return no_action;
272  } else if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
273  return no_action;
274  }
275  crm_trace("Unsupported action: %s", task);
276 #endif
277 
278  return no_action;
279 }
280 
281 const char *
283 {
284  const char *result = "<unknown>";
285 
286  switch (task) {
287  case no_action:
288  result = "no_action";
289  break;
290  case stop_rsc:
291  result = CRMD_ACTION_STOP;
292  break;
293  case stopped_rsc:
294  result = CRMD_ACTION_STOPPED;
295  break;
296  case start_rsc:
297  result = CRMD_ACTION_START;
298  break;
299  case started_rsc:
300  result = CRMD_ACTION_STARTED;
301  break;
302  case shutdown_crm:
303  result = CRM_OP_SHUTDOWN;
304  break;
305  case stonith_node:
306  result = CRM_OP_FENCE;
307  break;
308  case monitor_rsc:
309  result = CRMD_ACTION_STATUS;
310  break;
311  case action_notify:
312  result = CRMD_ACTION_NOTIFY;
313  break;
314  case action_notified:
315  result = CRMD_ACTION_NOTIFIED;
316  break;
317  case action_promote:
318  result = CRMD_ACTION_PROMOTE;
319  break;
320  case action_promoted:
321  result = CRMD_ACTION_PROMOTED;
322  break;
323  case action_demote:
324  result = CRMD_ACTION_DEMOTE;
325  break;
326  case action_demoted:
327  result = CRMD_ACTION_DEMOTED;
328  break;
329  }
330 
331  return result;
332 }
333 
334 const char *
336 {
337  switch (role) {
338  case RSC_ROLE_UNKNOWN:
339  return RSC_ROLE_UNKNOWN_S;
340  case RSC_ROLE_STOPPED:
341  return RSC_ROLE_STOPPED_S;
342  case RSC_ROLE_STARTED:
343  return RSC_ROLE_STARTED_S;
344  case RSC_ROLE_SLAVE:
345  return RSC_ROLE_SLAVE_S;
346  case RSC_ROLE_MASTER:
347  return RSC_ROLE_MASTER_S;
348  }
350  CRM_CHECK(role < RSC_ROLE_MAX, return RSC_ROLE_UNKNOWN_S);
351  // coverity[dead_error_line]
352  return RSC_ROLE_UNKNOWN_S;
353 }
354 
355 enum rsc_role_e
356 text2role(const char *role)
357 {
358  CRM_ASSERT(role != NULL);
359  if (safe_str_eq(role, RSC_ROLE_STOPPED_S)) {
360  return RSC_ROLE_STOPPED;
361  } else if (safe_str_eq(role, RSC_ROLE_STARTED_S)) {
362  return RSC_ROLE_STARTED;
363  } else if (safe_str_eq(role, RSC_ROLE_SLAVE_S)) {
364  return RSC_ROLE_SLAVE;
365  } else if (safe_str_eq(role, RSC_ROLE_MASTER_S)) {
366  return RSC_ROLE_MASTER;
367  } else if (safe_str_eq(role, RSC_ROLE_UNKNOWN_S)) {
368  return RSC_ROLE_UNKNOWN;
369  }
370  crm_err("Unknown role: %s", role);
371  return RSC_ROLE_UNKNOWN;
372 }
373 
374 int
375 merge_weights(int w1, int w2)
376 {
377  int result = w1 + w2;
378 
379  if (w1 <= -INFINITY || w2 <= -INFINITY) {
380  if (w1 >= INFINITY || w2 >= INFINITY) {
381  crm_trace("-INFINITY + INFINITY == -INFINITY");
382  }
383  return -INFINITY;
384 
385  } else if (w1 >= INFINITY || w2 >= INFINITY) {
386  return INFINITY;
387  }
388 
389  /* detect wrap-around */
390  if (result > 0) {
391  if (w1 <= 0 && w2 < 0) {
392  result = -INFINITY;
393  }
394 
395  } else if (w1 > 0 && w2 > 0) {
396  result = INFINITY;
397  }
398 
399  /* detect +/- INFINITY */
400  if (result >= INFINITY) {
401  result = INFINITY;
402 
403  } else if (result <= -INFINITY) {
404  result = -INFINITY;
405  }
406 
407  crm_trace("%d + %d = %d", w1, w2, result);
408  return result;
409 }
410 
411 void
412 add_hash_param(GHashTable * hash, const char *name, const char *value)
413 {
414  CRM_CHECK(hash != NULL, return);
415 
416  crm_trace("adding: name=%s value=%s", crm_str(name), crm_str(value));
417  if (name == NULL || value == NULL) {
418  return;
419 
420  } else if (safe_str_eq(value, "#default")) {
421  return;
422 
423  } else if (g_hash_table_lookup(hash, name) == NULL) {
424  g_hash_table_insert(hash, strdup(name), strdup(value));
425  }
426 }
427 
428 const char *
429 pe_node_attribute_calculated(const pe_node_t *node, const char *name,
430  const resource_t *rsc)
431 {
432  const char *source;
433 
434  if(node == NULL) {
435  return NULL;
436 
437  } else if(rsc == NULL) {
438  return g_hash_table_lookup(node->details->attrs, name);
439  }
440 
441  source = g_hash_table_lookup(rsc->meta, XML_RSC_ATTR_TARGET);
442  if(source == NULL || safe_str_eq("host", source) == FALSE) {
443  return g_hash_table_lookup(node->details->attrs, name);
444  }
445 
446  /* Use attributes set for the containers location
447  * instead of for the container itself
448  *
449  * Useful when the container is using the host's local
450  * storage
451  */
452 
453  CRM_ASSERT(node->details->remote_rsc);
455 
456  if(node->details->remote_rsc->container->running_on) {
458  pe_rsc_trace(rsc, "%s: Looking for %s on the container host %s", rsc->id, name, host->details->uname);
459  return g_hash_table_lookup(host->details->attrs, name);
460  }
461 
462  pe_rsc_trace(rsc, "%s: Not looking for %s on the container host: %s is inactive",
463  rsc->id, name, node->details->remote_rsc->container->id);
464  return NULL;
465 }
466 
467 const char *
468 pe_node_attribute_raw(pe_node_t *node, const char *name)
469 {
470  if(node == NULL) {
471  return NULL;
472  }
473  return g_hash_table_lookup(node->details->attrs, name);
474 }
RSC_ROLE_STARTED_S
#define RSC_ROLE_STARTED_S
Definition: common.h:98
INFINITY
#define INFINITY
Definition: crm.h:95
action_fail_response
action_fail_response
Definition: common.h:36
merge_weights
int merge_weights(int w1, int w2)
Definition: common.c:375
CRMD_ACTION_DEMOTED
#define CRMD_ACTION_DEMOTED
Definition: crm.h:180
CRMD_ACTION_PROMOTED
#define CRMD_ACTION_PROMOTED
Definition: crm.h:178
action_fail_standby
Definition: common.h:42
pe_node_attribute_raw
const char * pe_node_attribute_raw(pe_node_t *node, const char *name)
Definition: common.c:468
msg_xml.h
RSC_ROLE_STOPPED
Definition: common.h:88
CRMD_ACTION_STARTED
#define CRMD_ACTION_STARTED
Definition: crm.h:172
action_demote
Definition: common.h:68
action_fail_stop
Definition: common.h:41
pe_node_shared_s::remote_rsc
pe_resource_t * remote_rsc
Definition: pe_types.h:207
RSC_ROLE_MASTER
Definition: common.h:91
CRMD_ACTION_NOTIFY
#define CRMD_ACTION_NOTIFY
Definition: crm.h:182
started_rsc
Definition: common.h:63
CRMD_ACTION_DELETE
#define CRMD_ACTION_DELETE
Definition: crm.h:164
pe_resource_s::id
char * id
Definition: pe_types.h:292
rsc_role_e
rsc_role_e
Definition: common.h:86
stop_rsc
Definition: common.h:60
CRMD_ACTION_STOPPED
#define CRMD_ACTION_STOPPED
Definition: crm.h:175
fail2text
const char * fail2text(enum action_fail_response fail)
Definition: common.c:193
CRM_CHECK
#define CRM_CHECK(expr, failure_action)
Definition: logging.h:157
task2text
const char * task2text(enum action_tasks task)
Definition: common.c:282
pe_node_s::details
struct pe_node_shared_s * details
Definition: pe_types.h:220
stopped_rsc
Definition: common.h:61
action_fail_recover
Definition: common.h:38
crm_err
#define crm_err(fmt, args...)
Definition: logging.h:241
internal.h
crm_trace
#define crm_trace(fmt, args...)
Definition: logging.h:247
pe_resource_s::meta
GHashTable * meta
Definition: pe_types.h:344
CRM_OP_PROBED
#define CRM_OP_PROBED
Definition: crm.h:149
safe_str_eq
#define safe_str_eq(a, b)
Definition: util.h:61
action_notify
Definition: common.h:64
was_processing_error
gboolean was_processing_error
Definition: common.c:18
pe_resource_s::running_on
GListPtr running_on
Definition: pe_types.h:337
xml.h
Wrappers for and extensions to libxml2.
CRMD_ACTION_CANCEL
#define CRMD_ACTION_CANCEL
Definition: crm.h:165
CRM_OP_SHUTDOWN
#define CRM_OP_SHUTDOWN
Definition: crm.h:140
add_hash_param
void add_hash_param(GHashTable *hash, const char *name, const char *value)
Definition: common.c:412
text2role
enum rsc_role_e text2role(const char *role)
Definition: common.c:356
action_fail_block
Definition: common.h:40
RSC_ROLE_SLAVE
Definition: common.h:90
CRM_OP_LRM_REFRESH
#define CRM_OP_LRM_REFRESH
Definition: crm.h:145
action_notified
Definition: common.h:65
action_fail_fence
Definition: common.h:43
check_number
gboolean check_number(const char *value)
Definition: utils.c:102
CRMD_ACTION_MIGRATED
#define CRMD_ACTION_MIGRATED
Definition: crm.h:169
action_fail_migrate
Definition: common.h:39
action_fail_reset_remote
Definition: common.h:52
CRMD_ACTION_START
#define CRMD_ACTION_START
Definition: crm.h:171
RSC_ROLE_UNKNOWN
Definition: common.h:87
DIMOF
#define DIMOF(a)
Definition: crm.h:57
CRMD_ACTION_MIGRATE
#define CRMD_ACTION_MIGRATE
Definition: crm.h:168
action_demoted
Definition: common.h:69
RSC_ROLE_MASTER_S
#define RSC_ROLE_MASTER_S
Definition: common.h:100
CRMD_ACTION_STOP
#define CRMD_ACTION_STOP
Definition: crm.h:174
role2text
const char * role2text(enum rsc_role_e role)
Definition: common.c:335
config_metadata
void config_metadata(const char *name, const char *version, const char *desc_short, const char *desc_long, pe_cluster_option *option_list, int len)
Definition: utils.c:344
shutdown_crm
Definition: common.h:70
action_fail_restart_container
Definition: common.h:44
crm_ais_host_s::uname
char uname[MAX_NAME]
Definition: internal.h:24
action_promoted
Definition: common.h:67
check_time
gboolean check_time(const char *value)
Definition: utils.c:73
was_processing_warning
gboolean was_processing_warning
Definition: common.c:19
RSC_ROLE_MAX
#define RSC_ROLE_MAX
Definition: common.h:94
check_quorum
gboolean check_quorum(const char *value)
Definition: utils.c:132
pe_pref
const char * pe_pref(GHashTable *options, const char *name)
Definition: common.c:187
check_boolean
gboolean check_boolean(const char *value)
Definition: utils.c:91
verify_pe_options
void verify_pe_options(GHashTable *options)
Definition: common.c:181
CRMD_ACTION_NOTIFIED
#define CRMD_ACTION_NOTIFIED
Definition: crm.h:183
pe_cluster_option_s
Definition: crm_internal.h:87
pe_resource_s::container
pe_resource_t * container
Definition: pe_types.h:351
CRM_OP_FENCE
#define CRM_OP_FENCE
Definition: crm.h:141
pe_node_attribute_calculated
const char * pe_node_attribute_calculated(const pe_node_t *node, const char *name, const resource_t *rsc)
Definition: common.c:429
RSC_ROLE_SLAVE_S
#define RSC_ROLE_SLAVE_S
Definition: common.h:99
RSC_ROLE_STOPPED_S
#define RSC_ROLE_STOPPED_S
Definition: common.h:97
host
AIS_Host host
Definition: internal.h:84
crm_str
#define crm_str(x)
Definition: logging.h:267
action_promote
Definition: common.h:66
RSC_ROLE_UNKNOWN_S
#define RSC_ROLE_UNKNOWN_S
Definition: common.h:96
get_cluster_pref
const char * get_cluster_pref(GHashTable *options, pe_cluster_option *option_list, int len, const char *name)
Definition: utils.c:325
pe_rsc_trace
#define pe_rsc_trace(rsc, fmt, args...)
Definition: internal.h:19
CRM_ASSERT
#define CRM_ASSERT(expr)
Definition: results.h:42
start_rsc
Definition: common.h:62
CRMD_ACTION_DEMOTE
#define CRMD_ACTION_DEMOTE
Definition: crm.h:179
check_timer
gboolean check_timer(const char *value)
Definition: utils.c:82
action_fail_ignore
Definition: common.h:37
CRMD_ACTION_STATUS
#define CRMD_ACTION_STATUS
Definition: crm.h:185
pe_metadata
void pe_metadata(void)
Definition: common.c:172
text2task
enum action_tasks text2task(const char *task)
Definition: common.c:230
pe_resource_s
Definition: pe_types.h:291
XML_ATTR_HAVE_WATCHDOG
#define XML_ATTR_HAVE_WATCHDOG
Definition: msg_xml.h:86
RSC_ROLE_STARTED
Definition: common.h:89
stonith_node
Definition: common.h:71
crm_internal.h
action_tasks
action_tasks
Definition: common.h:57
util.h
Utility functions.
pe_node_s
Definition: pe_types.h:216
monitor_rsc
Definition: common.h:59
crm.h
A dumping ground.
verify_all_options
void verify_all_options(GHashTable *options, pe_cluster_option *option_list, int len)
Definition: utils.c:379
CRMD_ACTION_PROMOTE
#define CRMD_ACTION_PROMOTE
Definition: crm.h:177
no_action
Definition: common.h:58
pe_node_shared_s::attrs
GHashTable * attrs
Definition: pe_types.h:211
XML_RSC_ATTR_TARGET
#define XML_RSC_ATTR_TARGET
Definition: msg_xml.h:182