xmlNode *
do_calculations(pe_working_set_t *data_set, xmlNode *xml_input, ha_time_t *now)
{
int rsc_log_level = LOG_NOTICE;
/* pe_debug_on(); */
set_working_set_defaults(data_set);
data_set->input = xml_input;
data_set->now = now;
if(data_set->now == NULL) {
data_set->now = new_ha_date(TRUE);
}
#if MEMCHECK_STAGE_SETUP
check_and_exit(-1);
#endif
crm_debug_5("unpack constraints");
stage0(data_set);
#if MEMCHECK_STAGE_0
check_and_exit(0);
#endif
slist_iter(rsc, resource_t, data_set->resources, lpc,
if(is_set(rsc->flags, pe_rsc_orphan)
&& rsc->role == RSC_ROLE_STOPPED) {
continue;
}
rsc->fns->print(rsc, NULL, pe_print_log, &rsc_log_level);
);
/*
* Unpack everything
* At the end you'll have:
* - A list of nodes
* - A list of resources (each with any dependencies on other resources)
* - A list of constraints between resources and nodes
* - A list of constraints between start/stop actions
* - A list of nodes that need to be stonith'd
* - A list of nodes that need to be shutdown
* - A list of the possible stop/start actions (without dependencies)
*/
gboolean
cluster_status(pe_working_set_t *data_set)
{
xmlNode * config = get_object_root(
XML_CIB_TAG_CRMCONFIG, data_set->input);
xmlNode * cib_nodes = get_object_root(
XML_CIB_TAG_NODES, data_set->input);
xmlNode * cib_resources = get_object_root(
XML_CIB_TAG_RESOURCES, data_set->input);
xmlNode * cib_status = get_object_root(
XML_CIB_TAG_STATUS, data_set->input);
const char *value = crm_element_value(
data_set->input, XML_ATTR_HAVE_QUORUM);
crm_debug_3("Beginning unpack");
/* reset remaining global variables */
if(data_set->input == NULL) {
return FALSE;
}
if(data_set->now == NULL) {
data_set->now = new_ha_date(TRUE);
}
if(data_set->input != NULL
&& crm_element_value(data_set->input, XML_ATTR_DC_UUID) != NULL) {
/* this should always be present */
data_set->dc_uuid = crm_element_value_copy(
data_set->input, XML_ATTR_DC_UUID);
}
clear_bit_inplace(data_set->flags, pe_flag_have_quorum);
if(crm_is_true(value)) {
set_bit_inplace(data_set->flags, pe_flag_have_quorum);
}
data_set->op_defaults = get_object_root(XML_CIB_TAG_OPCONFIG, data_set->input);
data_set->rsc_defaults = get_object_root(XML_CIB_TAG_RSCCONFIG, data_set->input);
unpack_config(config, data_set);
if(is_set(data_set->flags, pe_flag_have_quorum) == FALSE
&& data_set->no_quorum_policy != no_quorum_ignore) {
crm_warn("We do not have quorum"
" - fencing and resource management disabled");
}
unpack_nodes(cib_nodes, data_set);
unpack_resources(cib_resources, data_set);
unpack_status(cib_status, data_set);
return TRUE;
}
ha_time_t *
parse_time(char **time_str, ha_time_t * a_time, gboolean with_offset)
{
ha_time_t *new_time = a_time;
tzset();
if (a_time == NULL) {
new_time = new_ha_date(FALSE);
}
CRM_CHECK(new_time != NULL, return NULL);
CRM_CHECK(new_time->has != NULL, free_ha_date(new_time);
return NULL);
/* reset the time fields */
new_time->hours = 0;
new_time->minutes = 0;
new_time->seconds = 0;
crm_trace("Get hours...");
new_time->has->hours = FALSE;
if (parse_int(time_str, 2, 24, &new_time->hours)) {
new_time->has->hours = TRUE;
}
crm_trace("Get minutes...");
new_time->has->minutes = FALSE;
if (parse_int(time_str, 2, 60, &new_time->minutes)) {
new_time->has->minutes = TRUE;
}
crm_trace("Get seconds...");
new_time->has->seconds = FALSE;
if (parse_int(time_str, 2, 60, &new_time->seconds)) {
new_time->has->seconds = TRUE;
}
if (with_offset) {
crm_trace("Get offset...");
while (isspace((int)(*time_str)[0])) {
(*time_str)++;
}
new_time->offset = parse_time_offset(time_str);
normalize_time(new_time);
}
return new_time;
}
ha_time_t *
parse_xml_duration(ha_time_t * start, xmlNode * duration_spec)
{
ha_time_t *end = NULL;
const char *value = NULL;
end = new_ha_date(FALSE);
ha_set_time(end, start, TRUE);
update_field("years", add_years);
update_field("months", add_months);
update_field("weeks", add_weeks);
update_field("days", add_days);
update_field("hours", add_hours);
update_field("minutes", add_minutes);
update_field("seconds", add_seconds);
return end;
}
int
main(int argc, char **argv)
{
xmlNode *cib_object = NULL;
xmlNode *status = NULL;
int argerr = 0;
int flag;
int option_index = 0;
pe_working_set_t data_set;
cib_t *cib_conn = NULL;
int rc = cib_ok;
gboolean xml_stdin = FALSE;
const char *xml_tag = NULL;
const char *xml_file = NULL;
const char *xml_string = NULL;
g_log_set_handler(NULL,
G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL
| G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE
| G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG
| G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL, cl_glib_msg_handler, NULL);
/* and for good measure... - this enum is a bit field (!) */
g_log_set_always_fatal((GLogLevelFlags) 0); /*value out of range */
crm_log_init_quiet(NULL, LOG_ERR, FALSE, TRUE, argc, argv);
crm_set_options(NULL, "[modifiers] data_source", long_options,
"Check a (complete) confiuration for syntax and common conceptual errors."
"\n\nChecks the well-formedness of an XML configuration, its conformance to the configured DTD/schema and for the presence of common misconfigurations."
"\n\nIt reports two classes of problems, errors and warnings."
" Errors must be fixed before the cluster will work properly."
" However, it is left up to the administrator to decide if the warnings should also be fixed.");
while (1) {
flag = crm_get_option(argc, argv, &option_index);
if (flag == -1)
break;
switch (flag) {
#ifdef HAVE_GETOPT_H
case 0:
printf("option %s", long_options[option_index].name);
if (optarg)
printf(" with arg %s", optarg);
printf("\n");
break;
#endif
case 'X':
crm_debug_2("Option %c => %s", flag, optarg);
xml_string = crm_strdup(optarg);
break;
case 'x':
crm_debug_2("Option %c => %s", flag, optarg);
xml_file = crm_strdup(optarg);
break;
case 'p':
xml_stdin = TRUE;
break;
case 'S':
cib_save = crm_strdup(optarg);
break;
case 'V':
alter_debug(DEBUG_INC);
break;
case 'L':
USE_LIVE_CIB = TRUE;
break;
case '$':
case '?':
crm_help(flag, LSB_EXIT_OK);
break;
default:
fprintf(stderr, "Option -%c is not yet supported\n", flag);
++argerr;
break;
}
}
if (optind < argc) {
printf("non-option ARGV-elements: ");
while (optind < argc) {
printf("%s ", argv[optind++]);
}
printf("\n");
}
if (optind > argc) {
++argerr;
}
if (argerr) {
crm_err("%d errors in option parsing", argerr);
crm_help(flag, LSB_EXIT_GENERIC);
}
crm_info("=#=#=#=#= Getting XML =#=#=#=#=");
if (USE_LIVE_CIB) {
cib_conn = cib_new();
rc = cib_conn->cmds->signon(cib_conn, crm_system_name, cib_command);
}
if (USE_LIVE_CIB) {
if (rc == cib_ok) {
int options = cib_scope_local | cib_sync_call;
crm_info("Reading XML from: live cluster");
rc = cib_conn->cmds->query(cib_conn, NULL, &cib_object, options);
}
if (rc != cib_ok) {
fprintf(stderr, "Live CIB query failed: %s\n", cib_error2string(rc));
return 3;
}
if (cib_object == NULL) {
fprintf(stderr, "Live CIB query failed: empty result\n");
return 3;
}
} else if (xml_file != NULL) {
cib_object = filename2xml(xml_file);
if (cib_object == NULL) {
fprintf(stderr, "Couldn't parse input file: %s\n", xml_file);
return 4;
}
} else if (xml_string != NULL) {
cib_object = string2xml(xml_string);
if (cib_object == NULL) {
fprintf(stderr, "Couldn't parse input string: %s\n", xml_string);
return 4;
}
} else if (xml_stdin) {
cib_object = stdin2xml();
if (cib_object == NULL) {
fprintf(stderr, "Couldn't parse input from STDIN.\n");
return 4;
}
} else {
fprintf(stderr, "No configuration source specified."
" Use --help for usage information.\n");
return 5;
}
xml_tag = crm_element_name(cib_object);
if (safe_str_neq(xml_tag, XML_TAG_CIB)) {
fprintf(stderr,
"This tool can only check complete configurations (ie. those starting with <cib>).\n");
return 6;
}
if (cib_save != NULL) {
write_xml_file(cib_object, cib_save, FALSE);
}
status = get_object_root(XML_CIB_TAG_STATUS, cib_object);
if (status == NULL) {
create_xml_node(cib_object, XML_CIB_TAG_STATUS);
}
if (validate_xml(cib_object, NULL, FALSE) == FALSE) {
crm_config_err("CIB did not pass DTD/schema validation");
free_xml(cib_object);
cib_object = NULL;
} else if (cli_config_update(&cib_object, NULL, FALSE) == FALSE) {
crm_config_error = TRUE;
free_xml(cib_object);
cib_object = NULL;
fprintf(stderr, "The cluster will NOT be able to use this configuration.\n");
fprintf(stderr, "Please manually update the configuration to conform to the %s syntax.\n",
LATEST_SCHEMA_VERSION);
}
set_working_set_defaults(&data_set);
if (cib_object == NULL) {
} else if (USE_LIVE_CIB) {
/* we will always have a status section and can do a full simulation */
do_calculations(&data_set, cib_object, NULL);
cleanup_alloc_calculations(&data_set);
} else {
data_set.now = new_ha_date(TRUE);
data_set.input = cib_object;
stage0(&data_set);
cleanup_alloc_calculations(&data_set);
}
if (crm_config_error) {
fprintf(stderr, "Errors found during check: config not valid\n");
if (crm_log_level < LOG_WARNING) {
fprintf(stderr, " -V may provide more details\n");
}
rc = 2;
} else if (crm_config_warning) {
fprintf(stderr, "Warnings found during check: config may not be valid\n");
if (crm_log_level < LOG_WARNING) {
fprintf(stderr, " Use -V for more details\n");
}
rc = 1;
}
if (USE_LIVE_CIB) {
cib_conn->cmds->signoff(cib_conn);
cib_delete(cib_conn);
}
return rc;
}
xmlNode *
do_calculations(pe_working_set_t * data_set, xmlNode * xml_input, ha_time_t * now)
{
GListPtr gIter = NULL;
int rsc_log_level = LOG_INFO;
/* pe_debug_on(); */
CRM_ASSERT(xml_input || is_set(data_set->flags, pe_flag_have_status));
if (is_set(data_set->flags, pe_flag_have_status) == FALSE) {
set_working_set_defaults(data_set);
data_set->input = xml_input;
data_set->now = now;
if (data_set->now == NULL) {
data_set->now = new_ha_date(TRUE);
}
} else {
crm_trace("Already have status - reusing");
}
crm_trace("Calculate cluster status");
stage0(data_set);
gIter = data_set->resources;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *rsc = (resource_t *) gIter->data;
if (is_set(rsc->flags, pe_rsc_orphan) && rsc->role == RSC_ROLE_STOPPED) {
continue;
}
rsc->fns->print(rsc, NULL, pe_print_log, &rsc_log_level);
}
crm_trace("Applying placement constraints");
stage2(data_set);
crm_trace("Create internal constraints");
stage3(data_set);
crm_trace("Check actions");
stage4(data_set);
crm_trace("Allocate resources");
stage5(data_set);
crm_trace("Processing fencing and shutdown cases");
stage6(data_set);
crm_trace("Applying ordering constraints");
stage7(data_set);
crm_trace("Create transition graph");
stage8(data_set);
crm_trace("=#=#=#=#= Summary =#=#=#=#=");
crm_trace("\t========= Set %d (Un-runnable) =========", -1);
if (get_crm_log_level() >= LOG_TRACE) {
gIter = data_set->actions;
for (; gIter != NULL; gIter = gIter->next) {
action_t *action = (action_t *) gIter->data;
if (is_set(action->flags, pe_action_optional) == FALSE
&& is_set(action->flags, pe_action_runnable) == FALSE
&& is_set(action->flags, pe_action_pseudo) == FALSE) {
log_action(LOG_TRACE, "\t", action, TRUE);
}
}
}
return data_set->graph;
}
int
main(int argc, char **argv)
{
int argerr = 0;
int flag;
int index = 0;
int print_options = 0;
char *input_s = NULL;
char *mutable_s = NULL;
crm_log_cli_init("iso8601");
crm_set_options(NULL, "command [output modifier] ", long_options,
"Display and parse ISO8601 dates and times");
if (argc < 2) {
argerr++;
}
while (1) {
flag = crm_get_option(argc, argv, &index);
if (flag == -1)
break;
switch (flag) {
case 'V':
crm_bump_log_level();
break;
case '?':
case '$':
crm_help(flag, 0);
break;
case 'n':
command = flag;
break;
case 'd':
case 'p':
case 'D':
command = flag;
input_s = strdup(optarg);
break;
case 'W':
print_options |= ha_date_weeks;
break;
case 'O':
print_options |= ha_date_ordinal;
break;
case 'L':
print_options |= ha_log_local;
break;
}
}
if (input_s == NULL && command != 'n') {
crm_help('?', 1);
}
mutable_s = input_s;
if (command == 'd') {
ha_time_t *date_time = parse_date(&mutable_s);
if (date_time == NULL) {
fprintf(stderr, "Invalid date/time specified: %s\n", input_s);
crm_help('?', 1);
}
log_date(-1, "parsed", date_time, print_options | ha_log_date | ha_log_time);
} else if (command == 'p') {
ha_time_period_t *interval = parse_time_period(&mutable_s);
if (interval == NULL) {
fprintf(stderr, "Invalid interval specified: %s\n", input_s);
crm_help('?', 1);
}
log_time_period(-1, interval, print_options | ha_log_date | ha_log_time);
} else if (command == 'D') {
ha_time_t *duration = parse_time_duration(&mutable_s);
if (duration == NULL) {
fprintf(stderr, "Invalid duration specified: %s\n", input_s);
crm_help('?', 1);
}
log_date(-1, "Duration", duration,
print_options | ha_log_date | ha_log_time | ha_log_local);
} else if (command == 'n') {
ha_time_t *now = new_ha_date(TRUE);
if (now == NULL) {
fprintf(stderr, "Internal error: couldnt determin 'now' !\n");
crm_help('?', 1);
}
log_date(-1, "Current date/time", now, print_options | ha_log_date | ha_log_time);
}
return 0;
}
