/*
* Append a RFC 5424 formatted timestamp to buffer buf, expand as needed
*
*/
void _xrfc5424timecat(char **buf, bool msec)
{
char p[64] = "";
char z[12] = "";
struct timeval tv;
struct tm tm;
if (gettimeofday(&tv, NULL) == -1)
fprintf(stderr, "gettimeofday() failed\n");
if (!slurm_localtime_r(&tv.tv_sec, &tm))
fprintf(stderr, "localtime_r() failed\n");
if (strftime(p, sizeof(p), "%Y-%m-%dT%T", &tm) == 0)
fprintf(stderr, "strftime() returned 0\n");
/* The strftime %z format creates timezone offsets of the form
* (+/-)hhmm, whereas the RFC 5424 format is (+/-)hh:mm. So
* shift the minutes one step back and insert the semicolon.
*/
if (strftime(z, sizeof(z), "%z", &tm) == 0)
fprintf(stderr, "strftime() returned 0\n");
z[5] = z[4];
z[4] = z[3];
z[3] = ':';
if (msec)
_xstrfmtcat(buf, "%s.%3.3d%s", p, (int)(tv.tv_usec / 1000), z);
else
_xstrfmtcat(buf, "%s%s", p, z);
}
/* This is a variation of slurm_make_time_str() in src/common/parse_time.h
* This version uses ISO8601 format by default. */
static void _make_time_str (time_t *time, char *string, int size)
{
struct tm time_tm;
slurm_localtime_r(time, &time_tm);
if ( *time == (time_t) 0 ) {
snprintf(string, size, "Unknown");
} else {
#if USE_ISO8601
/* Format YYYY-MM-DDTHH:MM:SS, ISO8601 standard format,
* NOTE: This is expected to break Maui, Moab and LSF
* schedulers management of SLURM. */
snprintf(string, size,
"%4.4u-%2.2u-%2.2uT%2.2u:%2.2u:%2.2u",
(time_tm.tm_year + 1900), (time_tm.tm_mon+1),
time_tm.tm_mday, time_tm.tm_hour, time_tm.tm_min,
time_tm.tm_sec);
#else
/* Format MM/DD-HH:MM:SS */
snprintf(string, size,
"%2.2u/%2.2u-%2.2u:%2.2u:%2.2u",
(time_tm.tm_mon+1), time_tm.tm_mday,
time_tm.tm_hour, time_tm.tm_min, time_tm.tm_sec);
#endif
}
}
/*
* append strftime of fmt to buffer buf, expand buf as needed
*
*/
void _xstrftimecat(char **buf, const char *fmt)
{
char p[256]; /* output truncated to 256 chars */
time_t t;
struct tm tm;
const char default_fmt[] = "%m/%d/%Y %H:%M:%S %Z";
#ifdef DISABLE_LOCALTIME
static int disabled=0;
if (!buf) disabled=1;
if (disabled) return;
#endif
if (fmt == NULL)
fmt = default_fmt;
if (time(&t) == (time_t) -1)
fprintf(stderr, "time() failed\n");
if (!slurm_localtime_r(&t, &tm))
fprintf(stderr, "localtime_r() failed\n");
strftime(p, sizeof(p), fmt, &tm);
_xstrcat(buf, p);
}
static char *_make_archive_name(time_t period_start, time_t period_end,
char *cluster_name, char *arch_dir,
char *arch_type, uint32_t archive_period)
{
struct tm time_tm;
char start_char[32];
char end_char[32];
slurm_localtime_r((time_t *)&period_start, &time_tm);
time_tm.tm_sec = 0;
time_tm.tm_min = 0;
/* set up the start time based off the period we are purging */
if (SLURMDB_PURGE_IN_HOURS(archive_period)) {
} else if (SLURMDB_PURGE_IN_DAYS(archive_period)) {
time_tm.tm_hour = 0;
} else {
time_tm.tm_hour = 0;
time_tm.tm_mday = 1;
}
snprintf(start_char, sizeof(start_char),
"%4.4u-%2.2u-%2.2u"
"T%2.2u:%2.2u:%2.2u",
(time_tm.tm_year + 1900),
(time_tm.tm_mon+1),
time_tm.tm_mday,
time_tm.tm_hour,
time_tm.tm_min,
time_tm.tm_sec);
slurm_localtime_r((time_t *)&period_end, &time_tm);
snprintf(end_char, sizeof(end_char),
"%4.4u-%2.2u-%2.2u"
"T%2.2u:%2.2u:%2.2u",
(time_tm.tm_year + 1900),
(time_tm.tm_mon+1),
time_tm.tm_mday,
time_tm.tm_hour,
time_tm.tm_min,
time_tm.tm_sec);
/* write the buffer to file */
return xstrdup_printf("%s/%s_%s_archive_%s_%s",
arch_dir, cluster_name, arch_type,
start_char, end_char);
}
extern char *slurm_ctime2_r(const time_t *timep, char *time_str)
{
struct tm newtime;
slurm_localtime_r(timep, &newtime);
strftime(time_str, 25, "%a %b %d %T %Y", &newtime);
return time_str;
}
/* Write the current local time into the provided buffer. Returns the
* number of characters written into the buffer. */
static size_t _make_timestamp(char *timestamp_buf, size_t max,
const char *timestamp_fmt)
{
time_t timestamp_t = time(NULL);
struct tm timestamp_tm;
if (!slurm_localtime_r(×tamp_t, ×tamp_tm)) {
fprintf(stderr, "localtime_r() failed\n");
return 0;
}
return strftime(timestamp_buf, max, timestamp_fmt, ×tamp_tm);
}
extern time_t archive_setup_end_time(time_t last_submit, uint32_t purge)
{
struct tm time_tm;
int16_t units;
if (purge == NO_VAL) {
error("Invalid purge set");
return 0;
}
units = SLURMDB_PURGE_GET_UNITS(purge);
if (units < 0) {
error("invalid units from purge '%d'", units);
return 0;
}
/* use slurm_localtime to avoid any daylight savings issues */
if (!slurm_localtime_r(&last_submit, &time_tm)) {
error("Couldn't get localtime from first "
"suspend start %ld", (long)last_submit);
return 0;
}
time_tm.tm_sec = 0;
time_tm.tm_min = 0;
if (SLURMDB_PURGE_IN_HOURS(purge))
time_tm.tm_hour -= units;
else if (SLURMDB_PURGE_IN_DAYS(purge)) {
time_tm.tm_hour = 0;
time_tm.tm_mday -= units;
} else if (SLURMDB_PURGE_IN_MONTHS(purge)) {
time_tm.tm_hour = 0;
time_tm.tm_mday = 1;
time_tm.tm_mon -= units;
} else {
errno = EINVAL;
error("No known unit given for purge, "
"we are guessing mistake and returning error");
return 0;
}
time_tm.tm_isdst = -1;
return (slurm_mktime(&time_tm) - 1);
}
/*
* Append a ISO 8601 formatted timestamp to buffer buf, expand as needed
*/
void _xiso8601timecat(char **buf, bool msec)
{
char p[64] = "";
struct timeval tv;
struct tm tm;
if (gettimeofday(&tv, NULL) == -1)
fprintf(stderr, "gettimeofday() failed\n");
if (!slurm_localtime_r(&tv.tv_sec, &tm))
fprintf(stderr, "localtime_r() failed\n");
if (strftime(p, sizeof(p), "%Y-%m-%dT%T", &tm) == 0)
fprintf(stderr, "strftime() returned 0\n");
if (msec)
_xstrfmtcat(buf, "%s.%3.3d", p, (int)(tv.tv_usec / 1000));
else
_xstrfmtcat(buf, "%s", p);
}
/*
* slurm_diff_tv_str - build a string showing the time difference between two
* times
* IN tv1 - start of event
* IN tv2 - end of event
* OUT tv_str - place to put delta time in format "usec=%ld"
* IN len_tv_str - size of tv_str in bytes
* IN from - where the function was called form
*/
extern void slurm_diff_tv_str(struct timeval *tv1, struct timeval *tv2,
char *tv_str, int len_tv_str, const char *from,
long limit, long *delta_t)
{
char p[64] = "";
struct tm tm;
int debug_limit = limit;
(*delta_t) = (tv2->tv_sec - tv1->tv_sec) * 1000000;
(*delta_t) += tv2->tv_usec;
(*delta_t) -= tv1->tv_usec;
snprintf(tv_str, len_tv_str, "usec=%ld", *delta_t);
if (from) {
if (!limit) {
/* NOTE: The slurmctld scheduler's default run time
* limit is 4 seconds, but that would not typically
* be reached. See "max_sched_time=" logic in
* src/slurmctld/job_scheduler.c */
limit = 3000000;
debug_limit = 1000000;
}
if ((*delta_t > debug_limit) || (*delta_t > limit)) {
if (!slurm_localtime_r(&tv1->tv_sec, &tm))
error("localtime_r(): %m");
if (strftime(p, sizeof(p), "%T", &tm) == 0)
error("strftime(): %m");
if (*delta_t > limit) {
verbose("Warning: Note very large processing "
"time from %s: %s began=%s.%3.3d",
from, tv_str, p,
(int)(tv1->tv_usec / 1000));
} else { /* Log anything over 1 second here */
debug("Note large processing time from %s: "
"%s began=%s.%3.3d",
from, tv_str, p,
(int)(tv1->tv_usec / 1000));
}
}
}
}
static int _first_job_roll_up(mysql_conn_t *mysql_conn, time_t first_start)
{
int rc = SLURM_SUCCESS;
char *query;
struct tm start_tm;
time_t month_start;
/* set up the month period */
if (!slurm_localtime_r(&first_start, &start_tm)) {
error("mktime for start failed for rollup\n");
return SLURM_ERROR;
}
// Go to the last day of the previous month for rollup start
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday = 0;
start_tm.tm_isdst = -1;
month_start = slurm_mktime(&start_tm);
query = xstrdup_printf("UPDATE \"%s_%s\" SET hourly_rollup = %ld, "
"daily_rollup = %ld, monthly_rollup = %ld",
mysql_conn->cluster_name, last_ran_table,
month_start, month_start, month_start);
if (debug_flags & DEBUG_FLAG_DB_QUERY)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
if (rc != SLURM_SUCCESS)
error("%s Failed to rollup at the end of previous month",
__func__);
xfree(query);
return rc;
}
static char *_make_archive_name(time_t period_start, time_t period_end,
char *cluster_name, char *arch_dir,
char *arch_type, uint32_t archive_period)
{
struct tm time_tm;
char start_char[32];
char end_char[32];
char name[PATH_MAX];
char fullname[PATH_MAX];
struct stat buf;
uint32_t num = 2;
uint32_t size_left = PATH_MAX - 1;
uint32_t size;
slurm_localtime_r((time_t *)&period_start, &time_tm);
time_tm.tm_sec = 0;
time_tm.tm_min = 0;
/* set up the start time based off the period we are purging */
if (SLURMDB_PURGE_IN_HOURS(archive_period)) {
} else if (SLURMDB_PURGE_IN_DAYS(archive_period)) {
time_tm.tm_hour = 0;
} else {
time_tm.tm_hour = 0;
time_tm.tm_mday = 1;
}
snprintf(start_char, sizeof(start_char),
"%4.4u-%2.2u-%2.2u"
"T%2.2u:%2.2u:%2.2u",
(time_tm.tm_year + 1900),
(time_tm.tm_mon+1),
time_tm.tm_mday,
time_tm.tm_hour,
time_tm.tm_min,
time_tm.tm_sec);
slurm_localtime_r((time_t *)&period_end, &time_tm);
snprintf(end_char, sizeof(end_char),
"%4.4u-%2.2u-%2.2u"
"T%2.2u:%2.2u:%2.2u",
(time_tm.tm_year + 1900),
(time_tm.tm_mon+1),
time_tm.tm_mday,
time_tm.tm_hour,
time_tm.tm_min,
time_tm.tm_sec);
size = snprintf(name, size_left, "%s/%s_%s_archive_%s_%s",
arch_dir, cluster_name, arch_type,
start_char, end_char);
if (size >= size_left) {
fatal("%s: file name would be larger than the max allowed file length of %u bytes, cannot archive file. This should never happen.",
__func__, PATH_MAX);
}
size_left -= size;
/* If the file already exists, generate a new file name. */
strncpy(fullname, name, PATH_MAX);
while (!stat(fullname, &buf)) {
size = snprintf(fullname, size_left, "%s.%u", name, num++);
if (size >= size_left) {
error("%s: file name would be larger than the max allowed file lenght of %u bytes, cannot archive file. This should never happen.",
__func__, PATH_MAX);
return NULL;
}
}
return xstrdup(fullname);
}
/*
* set_usage_information - set time and table information for getting usage
*
* OUT usage_table: which usage table to query
* IN type: usage type to get
* IN/OUT usage_start: start time
* IN/OUT usage_end: end time
* RET: error code
*/
extern int set_usage_information(char **usage_table,
slurmdbd_msg_type_t type,
time_t *usage_start, time_t *usage_end)
{
time_t start = (*usage_start), end = (*usage_end);
time_t my_time = time(NULL);
struct tm start_tm;
struct tm end_tm;
char *my_usage_table = (*usage_table);
/* Default is going to be the last day */
if (!end) {
if (!slurm_localtime_r(&my_time, &end_tm)) {
error("Couldn't get localtime from end %ld",
my_time);
return SLURM_ERROR;
}
end_tm.tm_hour = 0;
} else {
if (!slurm_localtime_r(&end, &end_tm)) {
error("Couldn't get localtime from user end %ld",
end);
return SLURM_ERROR;
}
}
end_tm.tm_sec = 0;
end_tm.tm_min = 0;
end = slurm_mktime(&end_tm);
if (!start) {
if (!slurm_localtime_r(&my_time, &start_tm)) {
error("Couldn't get localtime from start %ld",
my_time);
return SLURM_ERROR;
}
start_tm.tm_hour = 0;
start_tm.tm_mday--;
} else {
if (!slurm_localtime_r(&start, &start_tm)) {
error("Couldn't get localtime from user start %ld",
start);
return SLURM_ERROR;
}
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start = slurm_mktime(&start_tm);
if (end-start < 3600) {
end = start + 3600;
if (!slurm_localtime_r(&end, &end_tm)) {
error("2 Couldn't get localtime from user end %ld",
end);
return SLURM_ERROR;
}
}
/* check to see if we are off day boundaries or on month
* boundaries other wise use the day table.
*/
//info("%d %d %d", start_tm.tm_hour, end_tm.tm_hour, end-start);
if (start_tm.tm_hour || end_tm.tm_hour || (end-start < 86400)
|| (end > my_time)) {
switch (type) {
case DBD_GET_ASSOC_USAGE:
my_usage_table = assoc_hour_table;
break;
case DBD_GET_WCKEY_USAGE:
my_usage_table = wckey_hour_table;
break;
case DBD_GET_CLUSTER_USAGE:
my_usage_table = cluster_hour_table;
break;
default:
error("Bad type given for hour usage %d %s", type,
slurmdbd_msg_type_2_str(type, 1));
break;
}
} else if (start_tm.tm_mday == 1 && end_tm.tm_mday == 1
&& (end-start > 86400)) {
switch (type) {
case DBD_GET_ASSOC_USAGE:
my_usage_table = assoc_month_table;
break;
case DBD_GET_WCKEY_USAGE:
my_usage_table = wckey_month_table;
break;
case DBD_GET_CLUSTER_USAGE:
my_usage_table = cluster_month_table;
break;
default:
error("Bad type given for month usage %d %s", type,
slurmdbd_msg_type_2_str(type, 1));
break;
}
}
(*usage_start) = start;
(*usage_end) = end;
(*usage_table) = my_usage_table;
return SLURM_SUCCESS;
}
/* _rollup_handler - Process rollup duties */
static void *_rollup_handler(void *db_conn)
{
time_t start_time = time(NULL);
time_t next_time;
/* int sigarray[] = {SIGUSR1, 0}; */
struct tm tm;
rollup_stats_t rollup_stats;
int i;
(void) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
(void) pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
if (!slurm_localtime_r(&start_time, &tm)) {
fatal("Couldn't get localtime for rollup handler %ld",
(long)start_time);
return NULL;
}
while (1) {
if (!db_conn)
break;
/* run the roll up */
memset(&rollup_stats, 0, sizeof(rollup_stats_t));
slurm_mutex_lock(&rollup_lock);
running_rollup = 1;
debug2("running rollup at %s", slurm_ctime2(&start_time));
acct_storage_g_roll_usage(db_conn, 0, 0, 1, &rollup_stats);
acct_storage_g_commit(db_conn, 1);
running_rollup = 0;
slurm_mutex_unlock(&rollup_lock);
slurm_mutex_lock(&rpc_mutex);
for (i = 0; i < ROLLUP_COUNT; i++) {
if (rollup_stats.rollup_time[i] == 0)
continue;
rpc_stats.rollup_count[i]++;
rpc_stats.rollup_time[i] +=
rollup_stats.rollup_time[i];
rpc_stats.rollup_max_time[i] =
MAX(rpc_stats.rollup_max_time[i],
rollup_stats.rollup_time[i]);
}
slurm_mutex_unlock(&rpc_mutex);
/* get the time now we have rolled usage */
start_time = time(NULL);
if (!slurm_localtime_r(&start_time, &tm)) {
fatal("Couldn't get localtime for rollup handler %ld",
(long)start_time);
return NULL;
}
/* sleep until the next hour */
tm.tm_sec = 0;
tm.tm_min = 0;
tm.tm_hour++;
tm.tm_isdst = -1;
next_time = slurm_mktime(&tm);
sleep((next_time - start_time));
start_time = next_time;
/* Just in case some new uids were added to the system
pick them up here. */
assoc_mgr_set_missing_uids();
/* repeat ;) */
}
return NULL;
}
/* sacctmgr_list_reservation()
*/
int sacctmgr_list_reservation(int argc, char **argv)
{
List reservation_list;
ListIterator itr;
ListIterator itr2;
List format_list;
List print_fields_list;
slurmdb_reservation_cond_t *reservation_cond =
xmalloc(sizeof(slurmdb_reservation_cond_t));
slurmdb_reservation_rec_t *reservation;
int field_count, i;
print_field_t *field;
char *tmp_char;
/* If we don't have any arguments make sure we set up the
* time correctly for just the past day. */
if (argc == 0) {
struct tm start_tm;
reservation_cond->time_start = time(NULL);
if (!slurm_localtime_r(&reservation_cond->time_start,
&start_tm)) {
fprintf(stderr,
" Couldn't get localtime from %ld",
(long)reservation_cond->time_start);
slurmdb_destroy_reservation_cond(reservation_cond);
exit_code = 1;
return 0;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday--;
reservation_cond->time_start = slurm_mktime(&start_tm);
}
format_list = list_create(slurm_destroy_char);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!xstrncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !xstrncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
_set_cond(&i, argc, argv, reservation_cond, format_list);
}
if (reservation_cond->nodes && !reservation_cond->cluster_list) {
char *cluster_name = slurm_get_cluster_name();
char *warning = xstrdup_printf(
"If requesting nodes you must also request the cluster.\nWould you like to use the local cluster of '%s'?",
cluster_name);
if (!commit_check(warning)) {
exit_code = 1;
} else {
reservation_cond->cluster_list =
list_create(slurm_destroy_char);
list_append(reservation_cond->cluster_list,
cluster_name);
cluster_name = NULL;
}
xfree(warning);
xfree(cluster_name);
}
if (exit_code) {
slurmdb_destroy_reservation_cond(reservation_cond);
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
if (!list_count(format_list)) {
/* Append to the format list the fields
* we want to print, these are the data structure
* members of the type returned by slurmdbd
*/
slurm_addto_char_list(format_list,
"Cluster,Name%15,TRES%30,"
"TimeStart,TimeEnd,Unused");
}
reservation_list = slurmdb_reservations_get(
db_conn, reservation_cond);
slurmdb_destroy_reservation_cond(reservation_cond);
if (!reservation_list) {
exit_code=1;
fprintf(stderr, " Problem with query.\n");
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
/* Process the format list creating a list of
* print field_t structures
*/
print_fields_list = sacctmgr_process_format_list(format_list);
FREE_NULL_LIST(format_list);
itr = list_iterator_create(reservation_list);
itr2 = list_iterator_create(print_fields_list);
print_fields_header(print_fields_list);
field_count = list_count(print_fields_list);
/* For each reservation prints the data structure members
*/
while ((reservation = list_next(itr))) {
while ((field = list_next(itr2))) {
switch (field->type) {
case PRINT_ASSOC_NAME:
field->print_routine(
field,
reservation->assocs,
field_count);
break;
case PRINT_CLUSTER:
field->print_routine(
field,
reservation->cluster,
field_count);
break;
case PRINT_FLAGS:
tmp_char = reservation_flags_string(
reservation->flags);
field->print_routine(
field,
tmp_char,
field_count);
xfree(tmp_char);
break;
case PRINT_ID:
field->print_routine(field,
reservation->id,
field_count);
break;
case PRINT_NAME:
field->print_routine(field,
reservation->name,
field_count);
break;
case PRINT_NODENAME:
field->print_routine(
field,
reservation->nodes,
field_count);
break;
case PRINT_NODEINX:
field->print_routine(
field,
reservation->node_inx,
field_count);
break;
case PRINT_TIMEEND:
field->print_routine(
field,
reservation->time_end,
field_count);
break;
case PRINT_TIMESTART:
field->print_routine(
field,
reservation->time_start,
field_count);
break;
case PRINT_TRES:
sacctmgr_initialize_g_tres_list();
tmp_char = slurmdb_make_tres_string_from_simple(
reservation->tres_str, g_tres_list,
NO_VAL, CONVERT_NUM_UNIT_EXACT,
0, NULL);
field->print_routine(field,
tmp_char,
field_count);
xfree(tmp_char);
break;
case PRINT_UNUSED:
field->print_routine(
field,
reservation->unused_wall,
field_count);
break;
}
}
list_iterator_reset(itr2);
printf("\n");
}
list_iterator_destroy(itr);
list_iterator_destroy(itr2);
FREE_NULL_LIST(reservation_list);
FREE_NULL_LIST(print_fields_list);
return 0;
}
extern int as_mysql_nonhour_rollup(mysql_conn_t *mysql_conn,
bool run_month,
char *cluster_name,
time_t start, time_t end,
uint16_t archive_data)
{
/* can't just add 86400 since daylight savings starts and ends every
* once in a while
*/
int rc = SLURM_SUCCESS;
struct tm start_tm;
time_t curr_start = start;
time_t curr_end;
time_t now = time(NULL);
char *query = NULL;
uint16_t track_wckey = slurm_get_track_wckey();
char *unit_name;
while (curr_start < end) {
if (!slurm_localtime_r(&curr_start, &start_tm)) {
error("Couldn't get localtime from start %ld",
curr_start);
return SLURM_ERROR;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_isdst = -1;
if (run_month) {
unit_name = "month";
start_tm.tm_mday = 1;
start_tm.tm_mon++;
} else {
unit_name = "day";
start_tm.tm_mday++;
}
curr_end = slurm_mktime(&start_tm);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn,
"curr %s is now %ld-%ld",
unit_name, curr_start, curr_end);
/* info("start %s", slurm_ctime2(&curr_start)); */
/* info("end %s", slurm_ctime2(&curr_end)); */
query = xstrdup_printf(
"insert into \"%s_%s\" (creation_time, mod_time, id, "
"id_tres, time_start, alloc_secs) "
"select %ld, %ld, id, id_tres, "
"%ld, @ASUM:=SUM(alloc_secs) from \"%s_%s\" where "
"(time_start < %ld && time_start >= %ld) "
"group by id, id_tres on duplicate key update "
"mod_time=%ld, alloc_secs=@ASUM;",
cluster_name,
run_month ? assoc_month_table : assoc_day_table,
now, now, curr_start,
cluster_name,
run_month ? assoc_day_table : assoc_hour_table,
curr_end, curr_start, now);
/* We group on deleted here so if there are no entries
we don't get an error, just nothing is returned.
Else we get a bunch of NULL's
*/
xstrfmtcat(query,
"insert into \"%s_%s\" (creation_time, "
"mod_time, time_start, id_tres, count, "
"alloc_secs, down_secs, pdown_secs, "
"idle_secs, over_secs, resv_secs) "
"select %ld, %ld, "
"%ld, id_tres, @CPU:=MAX(count), "
"@ASUM:=SUM(alloc_secs), "
"@DSUM:=SUM(down_secs), "
"@PDSUM:=SUM(pdown_secs), "
"@ISUM:=SUM(idle_secs), "
"@OSUM:=SUM(over_secs), "
"@RSUM:=SUM(resv_secs) from \"%s_%s\" where "
"(time_start < %ld && time_start >= %ld) "
"group by deleted, id_tres "
"on duplicate key update "
"mod_time=%ld, count=@CPU, "
"alloc_secs=@ASUM, down_secs=@DSUM, "
"pdown_secs=@PDSUM, idle_secs=@ISUM, "
"over_secs=@OSUM, resv_secs=@RSUM;",
cluster_name,
run_month ? cluster_month_table : cluster_day_table,
now, now, curr_start,
cluster_name,
run_month ? cluster_day_table : cluster_hour_table,
curr_end, curr_start, now);
if (track_wckey) {
xstrfmtcat(query,
"insert into \"%s_%s\" (creation_time, "
"mod_time, id, id_tres, time_start, "
"alloc_secs) "
"select %ld, %ld, "
"id, id_tres, %ld, @ASUM:=SUM(alloc_secs) "
"from \"%s_%s\" where (time_start < %ld && "
"time_start >= %ld) group by id, id_tres "
"on duplicate key update "
"mod_time=%ld, alloc_secs=@ASUM;",
cluster_name,
run_month ? wckey_month_table :
wckey_day_table,
now, now, curr_start,
cluster_name,
run_month ? wckey_day_table :
wckey_hour_table,
curr_end, curr_start, now);
}
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn->conn, "query\n%s", query);
rc = mysql_db_query(mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
error("Couldn't add %s rollup", unit_name);
return SLURM_ERROR;
}
curr_start = curr_end;
}
/* info("stop start %s", slurm_ctime2(&curr_start)); */
/* info("stop end %s", slurm_ctime2(&curr_end)); */
/* go check to see if we archive and purge */
rc = _process_purge(mysql_conn, cluster_name, archive_data,
run_month ? SLURMDB_PURGE_MONTHS :
SLURMDB_PURGE_DAYS);
return rc;
}
/* sacctmgr_list_reservation()
*/
int sacctmgr_list_reservation(int argc, char **argv)
{
List reservation_list;
ListIterator itr;
ListIterator itr2;
List format_list = list_create(slurm_destroy_char);
List print_fields_list;
slurmdb_reservation_cond_t *reservation_cond =
xmalloc(sizeof(slurmdb_reservation_cond_t));
slurmdb_reservation_rec_t *reservation;
int field_count, i;
print_field_t *field;
char *tmp_char;
/* If we don't have any arguments make sure we set up the
time correctly for just the past day.
*/
if (argc == 0) {
struct tm start_tm;
reservation_cond->time_start = time(NULL);
if (!slurm_localtime_r(&reservation_cond->time_start,
&start_tm)) {
fprintf(stderr,
" Couldn't get localtime from %ld",
(long)reservation_cond->time_start);
exit_code = 1;
return 0;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday--;
start_tm.tm_isdst = -1;
reservation_cond->time_start = slurm_mktime(&start_tm);
}
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
_set_cond(&i, argc, argv, reservation_cond, format_list);
}
if (exit_code) {
slurmdb_destroy_reservation_cond(reservation_cond);
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
if (!list_count(format_list)) {
/* Append to the format list the fields
* we want to print, these are the data structure
* members of the type returned by slurmdbd
*/
slurm_addto_char_list(format_list,
"Cluster,Name%15,TRES%30,"
"TimeStart,TimeEnd");
}
reservation_list = acct_storage_g_get_reservations(
db_conn, my_uid, reservation_cond);
slurmdb_destroy_reservation_cond(reservation_cond);
if (!reservation_list) {
exit_code=1;
fprintf(stderr, " Problem with query.\n");
FREE_NULL_LIST(format_list);
return SLURM_ERROR;
}
/* Process the format list creating a list of
* print field_t structures
*/
print_fields_list = sacctmgr_process_format_list(format_list);
FREE_NULL_LIST(format_list);
itr = list_iterator_create(reservation_list);
itr2 = list_iterator_create(print_fields_list);
print_fields_header(print_fields_list);
field_count = list_count(print_fields_list);
/* For each reservation prints the data structure members
*/
while ((reservation = list_next(itr))) {
while ((field = list_next(itr2))) {
switch (field->type) {
case PRINT_ASSOC_NAME:
field->print_routine(
field,
reservation->assocs,
field_count);
break;
case PRINT_CLUSTER:
field->print_routine(
field,
reservation->cluster,
field_count);
break;
case PRINT_FLAGS:
tmp_char = reservation_flags_string(
reservation->flags);
field->print_routine(
field,
tmp_char,
field_count);
xfree(tmp_char);
break;
case PRINT_ID:
field->print_routine(field,
reservation->id,
field_count);
break;
case PRINT_NAME:
field->print_routine(field,
reservation->name,
field_count);
break;
case PRINT_NODENAME:
field->print_routine(
field,
reservation->nodes,
field_count);
break;
case PRINT_TIMEEND:
field->print_routine(
field,
reservation->time_end,
field_count);
break;
case PRINT_TIMESTART:
field->print_routine(
field,
reservation->time_start,
field_count);
break;
case PRINT_TRES:
if (!g_tres_list) {
slurmdb_tres_cond_t tres_cond;
memset(&tres_cond, 0,
sizeof(slurmdb_tres_cond_t));
tres_cond.with_deleted = 1;
g_tres_list = slurmdb_tres_get(
db_conn, &tres_cond);
}
tmp_char = slurmdb_make_tres_string_from_simple(
reservation->tres_str, g_tres_list);
field->print_routine(field,
tmp_char,
field_count);
xfree(tmp_char);
break;
}
}
list_iterator_reset(itr2);
printf("\n");
}
list_iterator_destroy(itr);
list_iterator_destroy(itr2);
FREE_NULL_LIST(reservation_list);
FREE_NULL_LIST(print_fields_list);
return 0;
}
static void *_cluster_rollup_usage(void *arg)
{
local_rollup_t *local_rollup = (local_rollup_t *)arg;
int rc = SLURM_SUCCESS;
char timer_str[128];
mysql_conn_t mysql_conn;
MYSQL_RES *result = NULL;
MYSQL_ROW row;
char *query = NULL;
struct tm start_tm;
struct tm end_tm;
time_t my_time = local_rollup->sent_end;
time_t last_hour = local_rollup->sent_start;
time_t last_day = local_rollup->sent_start;
time_t last_month = local_rollup->sent_start;
time_t hour_start;
time_t hour_end;
time_t day_start;
time_t day_end;
time_t month_start;
time_t month_end;
DEF_TIMERS;
char *update_req_inx[] = {
"hourly_rollup",
"daily_rollup",
"monthly_rollup"
};
enum {
UPDATE_HOUR,
UPDATE_DAY,
UPDATE_MONTH,
UPDATE_COUNT
};
memset(&mysql_conn, 0, sizeof(mysql_conn_t));
mysql_conn.rollback = 1;
mysql_conn.conn = local_rollup->mysql_conn->conn;
slurm_mutex_init(&mysql_conn.lock);
/* Each thread needs it's own connection we can't use the one
* sent from the parent thread. */
rc = check_connection(&mysql_conn);
if (rc != SLURM_SUCCESS)
goto end_it;
if (!local_rollup->sent_start) {
char *tmp = NULL;
int i=0;
xstrfmtcat(tmp, "%s", update_req_inx[i]);
for(i=1; i<UPDATE_COUNT; i++) {
xstrfmtcat(tmp, ", %s", update_req_inx[i]);
}
query = xstrdup_printf("select %s from \"%s_%s\"",
tmp, local_rollup->cluster_name,
last_ran_table);
xfree(tmp);
debug4("%d(%s:%d) query\n%s", mysql_conn.conn,
THIS_FILE, __LINE__, query);
if (!(result = mysql_db_query_ret(&mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
row = mysql_fetch_row(result);
if (row) {
last_hour = slurm_atoul(row[UPDATE_HOUR]);
last_day = slurm_atoul(row[UPDATE_DAY]);
last_month = slurm_atoul(row[UPDATE_MONTH]);
mysql_free_result(result);
} else {
time_t now = time(NULL);
time_t lowest = now;
mysql_free_result(result);
query = xstrdup_printf(
"select time_start from \"%s_%s\" "
"where node_name='' order by "
"time_start asc limit 1;",
local_rollup->cluster_name, event_table);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn.conn, "query\n%s", query);
if (!(result = mysql_db_query_ret(
&mysql_conn, query, 0))) {
xfree(query);
rc = SLURM_ERROR;
goto end_it;
}
xfree(query);
if ((row = mysql_fetch_row(result))) {
time_t check = slurm_atoul(row[0]);
if (check < lowest)
lowest = check;
}
mysql_free_result(result);
/* If we don't have any events like adding a
* cluster this will not work correctly, so we
* will insert now as a starting point.
*/
query = xstrdup_printf(
"insert into \"%s_%s\" "
"(hourly_rollup, daily_rollup, monthly_rollup) "
"values (%ld, %ld, %ld);",
local_rollup->cluster_name, last_ran_table,
lowest, lowest, lowest);
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn.conn, "query\n%s", query);
rc = mysql_db_query(&mysql_conn, query);
xfree(query);
if (rc != SLURM_SUCCESS) {
rc = SLURM_ERROR;
goto end_it;
}
if (lowest == now) {
debug("Cluster %s not registered, "
"not doing rollup",
local_rollup->cluster_name);
rc = SLURM_SUCCESS;
goto end_it;
}
last_hour = last_day = last_month = lowest;
}
}
if (!my_time)
my_time = time(NULL);
/* test month gap */
/* last_hour = 1212299999; */
/* last_day = 1212217200; */
/* last_month = 1212217200; */
/* my_time = 1212307200; */
/* last_hour = 1211475599; */
/* last_day = 1211475599; */
/* last_month = 1211475599; */
// last_hour = 1211403599;
// last_hour = 1206946800;
// last_day = 1207033199;
// last_day = 1197033199;
// last_month = 1204358399;
if (!slurm_localtime_r(&last_hour, &start_tm)) {
error("Couldn't get localtime from hour start %ld", last_hour);
rc = SLURM_ERROR;
goto end_it;
}
if (!slurm_localtime_r(&my_time, &end_tm)) {
error("Couldn't get localtime from hour end %ld", my_time);
rc = SLURM_ERROR;
goto end_it;
}
/* Below and anywhere in a rollup plugin when dealing with
* epoch times we need to set the tm_isdst = -1 so we don't
* have to worry about the time changes. Not setting it to -1
* will cause problems in the day and month with the date change.
*/
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_isdst = -1;
hour_start = slurm_mktime(&start_tm);
end_tm.tm_sec = 0;
end_tm.tm_min = 0;
end_tm.tm_isdst = -1;
hour_end = slurm_mktime(&end_tm);
/* info("hour start %s", slurm_ctime2(&hour_start)); */
/* info("hour end %s", slurm_ctime2(&hour_end)); */
/* info("diff is %d", hour_end-hour_start); */
slurm_mutex_lock(&rollup_lock);
global_last_rollup = hour_end;
slurm_mutex_unlock(&rollup_lock);
/* set up the day period */
if (!slurm_localtime_r(&last_day, &start_tm)) {
error("Couldn't get localtime from day %ld", last_day);
rc = SLURM_ERROR;
goto end_it;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_isdst = -1;
day_start = slurm_mktime(&start_tm);
end_tm.tm_hour = 0;
end_tm.tm_isdst = -1;
day_end = slurm_mktime(&end_tm);
/* info("day start %s", slurm_ctime2(&day_start)); */
/* info("day end %s", slurm_ctime2(&day_end)); */
/* info("diff is %d", day_end-day_start); */
/* set up the month period */
if (!slurm_localtime_r(&last_month, &start_tm)) {
error("Couldn't get localtime from month %ld", last_month);
rc = SLURM_ERROR;
goto end_it;
}
start_tm.tm_sec = 0;
start_tm.tm_min = 0;
start_tm.tm_hour = 0;
start_tm.tm_mday = 1;
start_tm.tm_isdst = -1;
month_start = slurm_mktime(&start_tm);
end_tm.tm_sec = 0;
end_tm.tm_min = 0;
end_tm.tm_hour = 0;
end_tm.tm_mday = 1;
end_tm.tm_isdst = -1;
month_end = slurm_mktime(&end_tm);
/* info("month start %s", slurm_ctime2(&month_start)); */
/* info("month end %s", slurm_ctime2(&month_end)); */
/* info("diff is %d", month_end-month_start); */
if ((hour_end - hour_start) > 0) {
START_TIMER;
rc = as_mysql_hourly_rollup(&mysql_conn,
local_rollup->cluster_name,
hour_start,
hour_end,
local_rollup->archive_data);
snprintf(timer_str, sizeof(timer_str),
"hourly_rollup for %s", local_rollup->cluster_name);
END_TIMER3(timer_str, 5000000);
if (rc != SLURM_SUCCESS)
goto end_it;
}
if ((day_end - day_start) > 0) {
START_TIMER;
rc = as_mysql_nonhour_rollup(&mysql_conn, 0,
local_rollup->cluster_name,
day_start,
day_end,
local_rollup->archive_data);
snprintf(timer_str, sizeof(timer_str),
"daily_rollup for %s", local_rollup->cluster_name);
END_TIMER3(timer_str, 5000000);
if (rc != SLURM_SUCCESS)
goto end_it;
}
if ((month_end - month_start) > 0) {
START_TIMER;
rc = as_mysql_nonhour_rollup(&mysql_conn, 1,
local_rollup->cluster_name,
month_start,
month_end,
local_rollup->archive_data);
snprintf(timer_str, sizeof(timer_str),
"monthly_rollup for %s", local_rollup->cluster_name);
END_TIMER3(timer_str, 5000000);
if (rc != SLURM_SUCCESS)
goto end_it;
}
if ((hour_end - hour_start) > 0) {
/* If we have a sent_end do not update the last_run_table */
if (!local_rollup->sent_end)
query = xstrdup_printf(
"update \"%s_%s\" set hourly_rollup=%ld",
local_rollup->cluster_name,
last_ran_table, hour_end);
} else
debug2("No need to roll cluster %s this hour %ld <= %ld",
local_rollup->cluster_name, hour_end, hour_start);
if ((day_end - day_start) > 0) {
if (query && !local_rollup->sent_end)
xstrfmtcat(query, ", daily_rollup=%ld", day_end);
else if (!local_rollup->sent_end)
query = xstrdup_printf(
"update \"%s_%s\" set daily_rollup=%ld",
local_rollup->cluster_name,
last_ran_table, day_end);
} else
debug2("No need to roll cluster %s this day %ld <= %ld",
local_rollup->cluster_name, day_end, day_start);
if ((month_end - month_start) > 0) {
if (query && !local_rollup->sent_end)
xstrfmtcat(query, ", monthly_rollup=%ld", month_end);
else if (!local_rollup->sent_end)
query = xstrdup_printf(
"update \"%s_%s\" set monthly_rollup=%ld",
local_rollup->cluster_name,
last_ran_table, month_end);
} else
debug2("No need to roll cluster %s this month %ld <= %ld",
local_rollup->cluster_name, month_end, month_start);
if (query) {
if (debug_flags & DEBUG_FLAG_DB_USAGE)
DB_DEBUG(mysql_conn.conn, "query\n%s", query);
rc = mysql_db_query(&mysql_conn, query);
xfree(query);
}
end_it:
if (rc == SLURM_SUCCESS) {
if (mysql_db_commit(&mysql_conn)) {
error("Couldn't commit rollup of cluster %s",
local_rollup->cluster_name);
rc = SLURM_ERROR;
}
} else {
error("Cluster %s rollup failed", local_rollup->cluster_name);
if (mysql_db_rollback(&mysql_conn))
error("rollback failed");
}
mysql_db_close_db_connection(&mysql_conn);
slurm_mutex_destroy(&mysql_conn.lock);
slurm_mutex_lock(local_rollup->rolledup_lock);
(*local_rollup->rolledup)++;
if ((rc != SLURM_SUCCESS) && ((*local_rollup->rc) == SLURM_SUCCESS))
(*local_rollup->rc) = rc;
pthread_cond_signal(local_rollup->rolledup_cond);
slurm_mutex_unlock(local_rollup->rolledup_lock);
xfree(local_rollup);
return NULL;
}
