/* parse_requeue_args() * IN s - string to parse * OUT flags - flags to set based upon argument * RET 0 on successful parse, -1 otherwise */ extern int parse_requeue_flags(char *s, uint32_t *flags) { char *p, *p0, *z; p0 = p = xstrdup(s); /* search for = */ z = strchr(p, '='); if (!z) { xfree(p0); return -1; } *z = 0; /* validate flags keyword */ if (xstrncasecmp(p, "state", 5)) { xfree(p0); return -1; } ++z; p = z; if (!xstrncasecmp(p, "specialexit", 11) || !xstrncasecmp(p, "se", 2)) { *flags = JOB_SPECIAL_EXIT; xfree(p0); return 0; } xfree(p0); return -1; }
/* * _job_rep - Reports having to do with jobs * IN argc - count of arguments * IN argv - list of arguments */ static void _job_rep (int argc, char **argv) { int error_code = SLURM_SUCCESS; int command_len = strlen(argv[0]); /* For backwards compatibility we just look at the 1st char * by default since Sizes was the original name */ if (!xstrncasecmp(argv[0], "SizesByAccount", MAX(command_len, 1))) { error_code = job_sizes_grouped_by_top_acct( (argc - 1), &argv[1]); } else if (!xstrncasecmp(argv[0], "SizesByWcKey", MAX(command_len, 8))) { error_code = job_sizes_grouped_by_wckey( (argc - 1), &argv[1]); } else if (!xstrncasecmp(argv[0], "SizesByAccountAndWcKey", MAX(command_len, 15))) { error_code = job_sizes_grouped_by_top_acct_and_wckey( (argc - 1), &argv[1]); } else { exit_code = 1; fprintf(stderr, "Not valid report %s\n", argv[0]); fprintf(stderr, "Valid job reports are, "); fprintf(stderr, "\"SizesByAccount, SizesByAccountAndWcKey, "); fprintf(stderr, "and SizesByWckey\"\n"); } if (error_code) { exit_code = 1; } }
/* * scontrol_requeue - requeue a pending or running batch job * IN job_id_str - a job id */ extern void scontrol_requeue(char *job_str) { char *job_id_str; int rc, i; job_array_resp_msg_t *resp = NULL; if (!job_str[0]) { exit_code = 1; return; } if (xstrncasecmp(job_str, "jobid=", 6) == 0) job_str += 6; if (xstrncasecmp(job_str, "job=", 4) == 0) job_str += 4; if (_is_job_id(job_str)) { job_id_str = _next_job_id(); while (job_id_str) { rc = slurm_requeue2(job_id_str, 0, &resp); if (rc != SLURM_SUCCESS) { exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(slurm_get_errno()), job_id_str); } } else if (resp) { for (i = 0; i < resp->job_array_count; i++) { if ((resp->error_code[i] == SLURM_SUCCESS) && (resp->job_array_count == 1)) continue; exit_code = 1; if (quiet_flag == 1) continue; fprintf(stderr, "%s: %s\n", resp->job_array_id[i], slurm_strerror(resp-> error_code[i])); } slurm_free_job_array_resp(resp); resp = NULL; } job_id_str = _next_job_id(); } } else { exit_code = 1; rc = ESLURM_INVALID_JOB_ID; slurm_seterrno(rc); if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc), job_str); } } }
static bool _node_state_equal (int i, const char *str) { int len = strlen (str); if ((xstrncasecmp(node_state_string_compact(i), str, len) == 0) || (xstrncasecmp(node_state_string(i), str, len) == 0)) return (true); return (false); }
static int _set_sort(char *format) { int command_len = strlen(format); if (xstrncasecmp(format, "Name", MAX(command_len, 1)) == 0) { sort_flag = SLURMDB_REPORT_SORT_NAME; } else if (xstrncasecmp(format, "Time", MAX(command_len, 6)) == 0) { sort_flag = SLURMDB_REPORT_SORT_TIME; } else { fprintf (stderr, "unknown timesort format %s", format); return SLURM_ERROR; } return SLURM_SUCCESS; }
/* * scontrol_print_layout - print information about the supplied layout * IN layout_type - print information about the supplied layout */ extern void scontrol_print_layout (int argc, char **argv) { int i = 0, tag_len = 0; char *tag = NULL, *val = NULL; char *layout_type = NULL, *entities = NULL, *type = NULL; uint32_t flags = 0; layout_info_msg_t *layout_info_ptr = NULL; while (i < argc) { tag = argv[i]; tag_len = strlen(tag); val = strchr(argv[i], '='); if (val) { tag_len = val - argv[i]; val++; } else if (argc > i+1) { val = argv[i+1]; i++; } else { val = NULL; } if (xstrncasecmp(tag, "layouts", MAX(tag_len, 3)) == 0) { layout_type = val; } else if (xstrncasecmp(tag, "entity", MAX(tag_len, 3)) == 0) { entities = val; } else if (xstrncasecmp(tag, "type", MAX(tag_len, 3)) == 0) { type = val; } else if (xstrncasecmp(tag, "nolayout", MAX(tag_len, 4)) ==0) { flags |= LAYOUTS_DUMP_NOLAYOUT; } else { exit_code = 1; if (quiet_flag != 1) fprintf (stderr, "invalid option for layouts: %s\n", tag); } i++; } if (slurm_load_layout (layout_type, entities, type, flags, &layout_info_ptr) == SLURM_SUCCESS) { slurm_print_layout_info ( stdout, layout_info_ptr, one_liner ); slurm_free_layout_info_msg (layout_info_ptr); } return; }
int next_saved_game(struct ffblk *ffblk) { struct dirent *dp; int len; memset(ffblk, 0, sizeof *ffblk); if (save_dir == NULL) return (1); while ((dp = readdir(save_dir)) != NULL) { len = NAMLEN(dp); if (len < 4) continue; if (xstrncasecmp(dp->d_name + len - 4, ".SAV", 4) != 0) continue; strncpy(ffblk->ff_name, dp->d_name, sizeof ffblk->ff_name); ffblk->ff_name[sizeof ffblk->ff_name - 1] = 0; return (0); } return (1); }
/* * _cluster_rep - Reports having to do with clusters * IN argc - count of arguments * IN argv - list of arguments */ static void _cluster_rep (int argc, char **argv) { int error_code = SLURM_SUCCESS; if (xstrncasecmp(argv[0], "AccountUtilizationByUser", 1) == 0) { error_code = cluster_account_by_user((argc - 1), &argv[1]); } else if ((xstrncasecmp(argv[0], "UserUtilizationByAccount", 18) == 0) || (xstrncasecmp(argv[0], "UA", 2) == 0)) { error_code = cluster_user_by_account((argc - 1), &argv[1]); } else if ((xstrncasecmp(argv[0], "UserUtilizationByWckey", 18) == 0) || (xstrncasecmp(argv[0], "UW", 2) == 0)) { error_code = cluster_user_by_wckey((argc - 1), &argv[1]); } else if (xstrncasecmp(argv[0], "Utilization", 2) == 0) { error_code = cluster_utilization((argc - 1), &argv[1]); } else if (xstrncasecmp(argv[0], "WCKeyUtilizationByUser", 1) == 0) { error_code = cluster_wckey_by_user((argc - 1), &argv[1]); } else { exit_code = 1; fprintf(stderr, "Not valid report %s\n", argv[0]); fprintf(stderr, "Valid cluster reports are, "); fprintf(stderr, "\"AccountUtilizationByUser\", " "\"UserUtilizationByAccount\", " "\"UserUtilizationByWckey\", \"Utilization\", " "and \"WCKeyUtilizationByUser\"\n"); } if (error_code) { exit_code = 1; } }
static int _set_time_format(char *format) { int command_len = strlen(format); if (xstrncasecmp(format, "SecPer", MAX(command_len, 6)) == 0) { time_format = SLURMDB_REPORT_TIME_SECS_PER; time_format_string = "Seconds/Percentage of Total"; } else if (xstrncasecmp(format, "MinPer", MAX(command_len, 6)) == 0) { time_format = SLURMDB_REPORT_TIME_MINS_PER; time_format_string = "Minutes/Percentage of Total"; } else if (xstrncasecmp(format, "HourPer", MAX(command_len, 6)) == 0) { time_format = SLURMDB_REPORT_TIME_HOURS_PER; time_format_string = "Hours/Percentage of Total"; } else if (xstrncasecmp(format, "Seconds", MAX(command_len, 1)) == 0) { time_format = SLURMDB_REPORT_TIME_SECS; time_format_string = "Seconds"; } else if (xstrncasecmp(format, "Minutes", MAX(command_len, 1)) == 0) { time_format = SLURMDB_REPORT_TIME_MINS; time_format_string = "Minutes"; } else if (xstrncasecmp(format, "Hours", MAX(command_len, 1)) == 0) { time_format = SLURMDB_REPORT_TIME_HOURS; time_format_string = "Hours"; } else if (xstrncasecmp(format, "Percent", MAX(command_len, 1)) == 0) { time_format = SLURMDB_REPORT_TIME_PERCENT; time_format_string = "Percentage of Total"; } else { fprintf (stderr, "unknown time format %s", format); return SLURM_ERROR; } return SLURM_SUCCESS; }
void GetFailStat(struct XFails *Now, char *FName, int rnum) { DEBUG2("->GetFailStat(struct XFails *Now,char *FName,int rnum %d)", rnum); int i; FILE *fin; int32_t count; struct Fdt { char Code[6]; int32_t offset; int16_t size; } Pul; fin = sOpen("FAILS.CDR", "rb", 0); count = 44; fread(&count, sizeof count, 1, fin); // never written to file Swap32bit(count); fread(&Pul, sizeof Pul, 1, fin); Swap32bit(Pul.offset); Swap16bit(Pul.size); i = 0; while (xstrncasecmp(Pul.Code, FName, 4) != 0 && i < count) { fread(&Pul, sizeof Pul, 1, fin); Swap32bit(Pul.offset); Swap16bit(Pul.size); i++; } if (i == count) { fclose(fin); return; } fseek(fin, Pul.offset, SEEK_SET); if (rnum < 0) { // Unmanned portion do { fread(Now, sizeof(struct XFails), 1, fin); Swap32bit(Now->per); // Only need to swap this one since we're checking only that } while (Now->per != rnum); } else { do { fread(Now, sizeof(struct XFails), 1, fin); Swap32bit(Now->per); Swap16bit(Now->code); Swap16bit(Now->val); Swap16bit(Now->xtra); Swap16bit(Now->fail); } while (Now->per <= rnum); }; fclose(fin); DEBUG1("<-GetFailStat()"); }
/* * scontrol_top_job - Move the specified job ID to the top of the queue for * a given user ID, partition, account, and QOS. * IN job_str - a job id */ extern void scontrol_top_job(char *job_id_str) { int rc; if (xstrncasecmp(job_id_str, "jobid=", 6) == 0) job_id_str += 6; if (xstrncasecmp(job_id_str, "job=", 4) == 0) job_id_str += 4; rc = slurm_top_job(job_id_str); if (rc != SLURM_SUCCESS) { exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(slurm_get_errno()), job_id_str); } } }
/* * _parse_state - convert node state name string to numeric value * IN str - state name * OUT states - node_state value corresponding to str * RET 0 or error code */ static int _node_state_id (char *str) { int i; int len = strlen (str); for (i = 0; i < NODE_STATE_END; i++) { if (_node_state_equal (i, str)) return (i); } if (xstrncasecmp("DRAIN", str, len) == 0) return NODE_STATE_DRAIN; if (xstrncasecmp("DRAINED", str, len) == 0) return NODE_STATE_DRAIN | NODE_STATE_IDLE; if (xstrncasecmp("ERROR", str, len) == 0) return NODE_STATE_ERROR; if ((xstrncasecmp("RESV", str, len) == 0) || (xstrncasecmp("RESERVED", str, len) == 0)) return NODE_STATE_RES; if ((xstrncasecmp("PERFCTRS", str, len) == 0) || (xstrncasecmp("NPC", str, len) == 0)) return NODE_STATE_NET; if ((xstrncasecmp("DRAINING", str, len) == 0) || (xstrncasecmp("DRNG", str, len) == 0)) return NODE_STATE_DRAIN | NODE_STATE_ALLOCATED; if (_node_state_equal (NODE_STATE_COMPLETING, str)) return NODE_STATE_COMPLETING; if (xstrncasecmp("NO_RESPOND", str, len) == 0) return NODE_STATE_NO_RESPOND; if (_node_state_equal (NODE_STATE_POWER_SAVE, str)) return NODE_STATE_POWER_SAVE; if (_node_state_equal (NODE_STATE_POWER_UP, str)) return NODE_STATE_POWER_UP; if (_node_state_equal (NODE_STATE_FAIL, str)) return NODE_STATE_FAIL; if (_node_state_equal (NODE_STATE_MAINT, str)) return NODE_STATE_MAINT; if (_node_state_equal (NODE_STATE_REBOOT, str)) return NODE_STATE_REBOOT; return (-1); }
static int _parse_restart_args(int argc, char **argv, uint16_t *stick, char **image_dir) { int i; for (i=0; i< argc; i++) { if (xstrncasecmp(argv[i], "StickToNodes", 5) == 0) { *stick = 1; } else if (xstrncasecmp(argv[i], "ImageDir=", 9) == 0) { *image_dir = &argv[i][9]; } else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Request aborted"); return -1; } } return 0; }
static QUERY(xmsg_validate_uid) { char *uid = *(va_arg(ap, char**)); int *valid = va_arg(ap, int*); if (uid && !xstrncasecmp(uid, "xmsg:", XMSG_UID_DIROFFSET)) { (*valid)++; return -1; } return 0; }
static QUERY(sniff_validate_uid) { char *uid = *(va_arg(ap, char **)); int *valid = va_arg(ap, int *); if (!uid) return 0; if (!xstrncasecmp(uid, "sniff:", 6) && uid[6]) { (*valid)++; return -1; } return 0; }
static int _parse_checkpoint_args(int argc, char **argv, uint16_t *max_wait, char **image_dir) { int i; for (i=0; i< argc; i++) { if (xstrncasecmp(argv[i], "MaxWait=", 8) == 0) { *max_wait = (uint16_t) strtol(&argv[i][8], (char **) NULL, 10); } else if (xstrncasecmp(argv[i], "ImageDir=", 9) == 0) { *image_dir = &argv[i][9]; } else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Request aborted"); return -1; } } return 0; }
/* * _user_rep - Reports having to do with users * IN argc - count of arguments * IN argv - list of arguments */ static void _user_rep (int argc, char **argv) { int error_code = SLURM_SUCCESS; if (xstrncasecmp(argv[0], "Top", 1) == 0) { error_code = user_top((argc - 1), &argv[1]); } else { exit_code = 1; fprintf(stderr, "Not valid report %s\n", argv[0]); fprintf(stderr, "Valid user reports are, "); fprintf(stderr, "\"Top\"\n"); } if (error_code) { exit_code = 1; } }
static int MatchUpItem(const char *text, int loc) { const char *word=MapSynonym(text); int ct=0; if(word==NULL) word=text; while(ct<=GameHeader.NumItems) { if(Items[ct].AutoGet && Items[ct].Location==loc && xstrncasecmp(Items[ct].AutoGet,word,GameHeader.WordLength)==0) return(ct); ct++; } return(-1); }
/* * _resv_rep - Reports having to do with reservations * IN argc - count of arguments * IN argv - list of arguments */ static void _resv_rep (int argc, char **argv) { int error_code = SLURM_SUCCESS; if (xstrncasecmp(argv[0], "Utilization", 1) == 0) { error_code = resv_utilization((argc - 1), &argv[1]); } else { exit_code = 1; fprintf(stderr, "Not valid report %s\n", argv[0]); fprintf(stderr, "Valid reservation reports are, "); fprintf(stderr, "\"Utilization\"\n"); } if (error_code) { exit_code = 1; } }
static int WhichWord(const char *word, const char **list) { int n=1; int ne=1; const char *tp; while(ne<=GameHeader.NumWords) { tp=list[ne]; if(*tp=='*') tp++; else n=ne; if(xstrncasecmp(word,tp,GameHeader.WordLength)==0) return(n); ne++; } return(-1); }
static const char *MapSynonym(const char *word) { int n=1; const char *tp; static char lastword[16]; /* Last non synonym */ while(n<=GameHeader.NumWords) { tp=Nouns[n]; if(*tp=='*') tp++; else strcpy(lastword,tp); if(xstrncasecmp(word,tp,GameHeader.WordLength)==0) return(lastword); n++; } return(NULL); }
extern int sacctmgr_list_account(int argc, char **argv) { int rc = SLURM_SUCCESS; slurmdb_account_cond_t *acct_cond = xmalloc(sizeof(slurmdb_account_cond_t)); List acct_list; int i=0, cond_set=0, prev_set=0; ListIterator itr = NULL; ListIterator itr2 = NULL; slurmdb_account_rec_t *acct = NULL; slurmdb_assoc_rec_t *assoc = NULL; int field_count = 0; print_field_t *field = NULL; List format_list = list_create(slurm_destroy_char); List print_fields_list; /* types are of print_field_t */ acct_cond->with_assocs = with_assoc_flag; 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++; prev_set = _set_cond(&i, argc, argv, acct_cond, format_list); cond_set |= prev_set; } if (exit_code) { slurmdb_destroy_account_cond(acct_cond); FREE_NULL_LIST(format_list); return SLURM_ERROR; } else if (!list_count(format_list)) { slurm_addto_char_list(format_list, "Acc,Des,O"); if (acct_cond->with_assocs) slurm_addto_char_list(format_list, "Cl,ParentN,U,Share,GrpJ,GrpN," "GrpCPUs,GrpMEM,GrpS,GrpWall,GrpCPUMins," "MaxJ,MaxN,MaxCPUs,MaxS,MaxW," "MaxCPUMins,QOS,DefaultQOS"); if (acct_cond->with_coords) slurm_addto_char_list(format_list, "Coord"); } if (!acct_cond->with_assocs && cond_set > 1) { if (!commit_check("You requested options that are only valid " "when querying with the withassoc option.\n" "Are you sure you want to continue?")) { printf("Aborted\n"); FREE_NULL_LIST(format_list); slurmdb_destroy_account_cond(acct_cond); return SLURM_SUCCESS; } } print_fields_list = sacctmgr_process_format_list(format_list); FREE_NULL_LIST(format_list); if (exit_code) { slurmdb_destroy_account_cond(acct_cond); FREE_NULL_LIST(print_fields_list); return SLURM_ERROR; } acct_list = slurmdb_accounts_get(db_conn, acct_cond); slurmdb_destroy_account_cond(acct_cond); if (!acct_list) { exit_code=1; fprintf(stderr, " Problem with query.\n"); FREE_NULL_LIST(print_fields_list); return SLURM_ERROR; } itr = list_iterator_create(acct_list); itr2 = list_iterator_create(print_fields_list); print_fields_header(print_fields_list); field_count = list_count(print_fields_list); while((acct = list_next(itr))) { if (acct->assoc_list) { ListIterator itr3 = list_iterator_create(acct->assoc_list); while((assoc = list_next(itr3))) { int curr_inx = 1; while((field = list_next(itr2))) { switch(field->type) { case PRINT_ACCT: field->print_routine( field, acct->name, (curr_inx == field_count)); break; case PRINT_COORDS: field->print_routine( field, acct->coordinators, (curr_inx == field_count)); break; case PRINT_DESC: field->print_routine( field, acct->description, (curr_inx == field_count)); break; case PRINT_ORG: field->print_routine( field, acct->organization, (curr_inx == field_count)); break; default: sacctmgr_print_assoc_rec( assoc, field, NULL, (curr_inx == field_count)); break; } curr_inx++; } list_iterator_reset(itr2); printf("\n"); } list_iterator_destroy(itr3); } else { int curr_inx = 1; while((field = list_next(itr2))) { switch(field->type) { case PRINT_QOS: field->print_routine( field, NULL, NULL, (curr_inx == field_count)); break; case PRINT_ACCT: field->print_routine( field, acct->name, (curr_inx == field_count)); break; case PRINT_COORDS: field->print_routine( field, acct->coordinators, (curr_inx == field_count)); break; case PRINT_DESC: field->print_routine( field, acct->description, (curr_inx == field_count)); break; case PRINT_ORG: field->print_routine( field, acct->organization, (curr_inx == field_count)); break; default: field->print_routine( field, NULL, (curr_inx == field_count)); break; } curr_inx++; } list_iterator_reset(itr2); printf("\n"); } } list_iterator_destroy(itr2); list_iterator_destroy(itr); FREE_NULL_LIST(acct_list); FREE_NULL_LIST(print_fields_list); return rc; }
/* * binding_key() * * analizuje nazwê klawisza i wpisuje akcjê do odpowiedniej mapy. * * 0/-1. */ static int binding_key(struct binding *b, const char *key, int add) { /* debug("Key: %s\n", key); */ if (!xstrncasecmp(key, ("Alt-"), 4)) { unsigned char ch; #define __key(x, y, z) \ if (!xstrcasecmp(key + 4, (x))) { \ b->key = saprintf("Alt-%s", (x)); \ if (add) { \ ncurses_binding_map_meta[y] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); \ if (z) \ ncurses_binding_map_meta[z] = ncurses_binding_map_meta[y]; \ } \ return 0; \ } __key("Enter", 13, 0); __key("Backspace", KEY_BACKSPACE, 127); __key("Home", KEY_HOME, KEY_FIND); __key("End", KEY_END, KEY_SELECT); __key("Delete", KEY_DC, 0); __key("Insert", KEY_IC, 0); __key("Left", KEY_LEFT, 0); __key("Right", KEY_RIGHT, 0); __key("Up", KEY_UP, 0); __key("Down", KEY_DOWN, 0); __key("PageUp", KEY_PPAGE, 0); __key("PageDown", KEY_NPAGE, 0); #undef __key if (xstrlen(key) != 5) return -1; ch = xtoupper(key[4]); b->key = saprintf(("Alt-%c"), ch); /* XXX Alt-Ó ??? */ if (add) { ncurses_binding_map_meta[ch] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); if (xisalpha(ch)) ncurses_binding_map_meta[xtolower(ch)] = ncurses_binding_map_meta[ch]; } return 0; } if (!xstrncasecmp(key, ("Ctrl-"), 5)) { unsigned char ch; // if (xstrlen(key) != 6) // return -1; #define __key(x, y, z) \ if (!xstrcasecmp(key + 5, (x))) { \ b->key = saprintf("Ctrl-%s", (x)); \ if (add) { \ ncurses_binding_map[y] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); \ if (z) \ ncurses_binding_map[z] = ncurses_binding_map[y]; \ } \ return 0; \ } __key("Enter", KEY_CTRL_ENTER, 0); __key("Escape", KEY_CTRL_ESCAPE, 0); __key("Delete", KEY_CTRL_DC, 0); __key("Backspace", KEY_CTRL_BACKSPACE, 0); __key("Tab", KEY_CTRL_TAB, 0); #undef __key ch = xtoupper(key[5]); b->key = saprintf(("Ctrl-%c"), ch); if (add) { if (xisalpha(ch)) ncurses_binding_map[ch - 64] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); else return -1; } return 0; } if (xtoupper(key[0]) == 'F' && atoi(key + 1)) { int f = atoi(key + 1); if (f < 1 || f > 63) return -1; b->key = saprintf(("F%d"), f); if (add) ncurses_binding_map[KEY_F(f)] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); return 0; } #define __key(x, y, z) \ if (!xstrcasecmp(key, (x))) { \ b->key = xstrdup((x)); \ if (add) { \ ncurses_binding_map[y] = LIST_ADD2(&bindings, xmemdup(b, sizeof(struct binding))); \ if (z) \ ncurses_binding_map[z] = ncurses_binding_map[y]; \ } \ return 0; \ } __key("Enter", 13, 0); __key("Escape", 27, 0); __key("Home", KEY_HOME, KEY_FIND); __key("End", KEY_END, KEY_SELECT); __key("Delete", KEY_DC, 0); __key("Insert", KEY_IC, 0); __key("Backspace", KEY_BACKSPACE, 127); __key("Tab", 9, 0); __key("Left", KEY_LEFT, 0); __key("Right", KEY_RIGHT, 0); __key("Up", KEY_UP, 0); __key("Down", KEY_DOWN, 0); __key("PageUp", KEY_PPAGE, 0); __key("PageDown", KEY_NPAGE, 0); #undef __key return -1; }
/* * scontrol_update_job - update the slurm job configuration per the supplied * arguments * IN argc - count of arguments * IN argv - list of arguments * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_update_job(int argc, char **argv) { bool update_size = false; int i, update_cnt = 0, rc = SLURM_SUCCESS, rc2; char *tag, *val; int taglen, vallen; job_desc_msg_t job_msg; job_array_resp_msg_t *resp = NULL; uint32_t job_uid = NO_VAL; slurm_init_job_desc_msg (&job_msg); for (i = 0; i < argc; i++) { char *add_info = NULL; tag = argv[i]; val = strchr(argv[i], '='); if (val) { taglen = val - argv[i]; if ((taglen > 0) && ((val[-1] == '+') || (val[-1] == '-'))) { add_info = val - 1; taglen--; } val++; vallen = strlen(val); } else if (xstrncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0){ /* "Nice" is the only tag that might not have an equal sign, so it is handled specially. */ job_msg.nice = NICE_OFFSET + 100; update_cnt++; continue; } else if (!val && argv[i + 1]) { tag = argv[i]; taglen = strlen(tag); val = argv[++i]; vallen = strlen(val); } else { exit_code = 1; fprintf (stderr, "Invalid input: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return -1; } if (xstrncasecmp(tag, "JobId", MAX(taglen, 3)) == 0) { job_msg.job_id_str = val; } else if (xstrncasecmp(tag, "AdminComment", MAX(taglen, 3)) == 0) { if (add_info) { if (add_info[0] == '-') { error("Invalid syntax, AdminComment can not be subtracted from."); exit_code = 1; return 0; } job_msg.admin_comment = add_info; /* * Mark as unset so we know we handled this * correctly as there is a check later to make * sure we know we got a +-. */ add_info = NULL; } else job_msg.admin_comment = val; update_cnt++; } else if (xstrncasecmp(tag, "ArrayTaskThrottle", MAX(taglen, 10)) == 0) { int throttle; throttle = strtoll(val, (char **) NULL, 10); if (throttle < 0) { error("Invalid ArrayTaskThrottle value"); exit_code = 1; return 0; } job_msg.array_inx = val; update_cnt++; } else if (xstrncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) { job_msg.comment = val; update_cnt++; } else if (xstrncasecmp(tag, "Clusters", MAX(taglen, 8)) == 0) { job_msg.clusters = val; update_cnt++; } else if (xstrncasecmp(tag, "ClusterFeatures", MAX(taglen, 8)) == 0) { job_msg.cluster_features = val; update_cnt++; } else if (xstrncasecmp(tag, "DelayBoot", MAX(taglen, 5)) == 0) { int time_sec = time_str2secs(val); if (time_sec == NO_VAL) { error("Invalid DelayBoot value"); exit_code = 1; return 0; } job_msg.delay_boot = time_sec; update_cnt++; } else if (xstrncasecmp(tag, "TimeLimit", MAX(taglen, 5)) == 0) { uint32_t job_current_time, time_limit; if (val && ((val[0] == '+') || (val[0] == '-'))) { if (add_info) { error("Invalid syntax, variations of +=- are not accepted."); exit_code = 1; return 0; } add_info = val; val++; } time_limit = time_str2mins(val); if (time_limit == NO_VAL) { error("Invalid TimeLimit value"); exit_code = 1; return 0; } if (add_info) { if (!job_msg.job_id_str) { error("JobId must precede TimeLimit " "increment or decrement"); exit_code = 1; return 0; } job_current_time = _get_job_time(job_msg. job_id_str); if (job_current_time == NO_VAL) { exit_code = 1; return 0; } if (add_info[0] == '+') { time_limit += job_current_time; } else if (time_limit > job_current_time) { error("TimeLimit decrement larger than" " current time limit (%u > %u)", time_limit, job_current_time); exit_code = 1; return 0; } else { time_limit = job_current_time - time_limit; } /* * Mark as unset so we know we handled this * correctly as there is a check later to make * sure we know we got a +-. */ add_info = NULL; } job_msg.time_limit = time_limit; update_cnt++; } else if (xstrncasecmp(tag, "TimeMin", MAX(taglen, 5)) == 0) { int time_min = time_str2mins(val); if ((time_min < 0) && (time_min != INFINITE)) { error("Invalid TimeMin value"); exit_code = 1; return 0; } job_msg.time_min = time_min; update_cnt++; } else if (xstrncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) { if (parse_uint32(val, &job_msg.priority)) { error ("Invalid Priority value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) { long long tmp_nice; tmp_nice = strtoll(val, (char **)NULL, 10); if (llabs(tmp_nice) > (NICE_OFFSET - 3)) { error("Nice value out of range (+/- %u). Value " "ignored", NICE_OFFSET - 3); exit_code = 1; return 0; } job_msg.nice = NICE_OFFSET + tmp_nice; update_cnt++; } else if (!xstrncasecmp(tag, "CPUsPerTask", MAX(taglen, 9))) { if (parse_uint16(val, &job_msg.cpus_per_task)) { error("Invalid CPUsPerTask value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "CpusPerTres", MAX(taglen, 9))) { job_msg.cpus_per_tres = val; update_cnt++; } else if (xstrncasecmp(tag, "NumCPUs", MAX(taglen, 6)) == 0) { int min_cpus, max_cpus=0; if (!get_resource_arg_range(val, "NumCPUs", &min_cpus, &max_cpus, false) || (min_cpus <= 0) || (max_cpus && (max_cpus < min_cpus))) { error ("Invalid NumCPUs value: %s", val); exit_code = 1; return 0; } job_msg.min_cpus = min_cpus; if (max_cpus) job_msg.max_cpus = max_cpus; update_cnt++; } /* ReqProcs was removed in Slurm version 2.1 */ else if ((xstrncasecmp(tag, "NumTasks", MAX(taglen, 8)) == 0) || (xstrncasecmp(tag, "ReqProcs", MAX(taglen, 8)) == 0)) { if (parse_uint32(val, &job_msg.num_tasks)) { error ("Invalid NumTasks value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.requeue)) { error ("Invalid Requeue value: %s", val); exit_code = 1; return 0; } update_cnt++; } /* ReqNodes was replaced by NumNodes in Slurm version 2.1 */ else if ((xstrncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0) || (xstrncasecmp(tag, "NumNodes", MAX(taglen, 8)) == 0)) { int min_nodes, max_nodes, rc; if (xstrcmp(val, "0") == 0) { job_msg.min_nodes = 0; } else if (xstrcasecmp(val, "ALL") == 0) { job_msg.min_nodes = INFINITE; } else { min_nodes = (int) job_msg.min_nodes; max_nodes = (int) job_msg.max_nodes; rc = get_resource_arg_range( val, "requested node count", &min_nodes, &max_nodes, false); if (!rc) return rc; job_msg.min_nodes = (uint32_t) min_nodes; job_msg.max_nodes = (uint32_t) max_nodes; } update_size = true; update_cnt++; } else if (xstrncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.sockets_per_node)) { error ("Invalid ReqSockets value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.cores_per_socket)) { error ("Invalid ReqCores value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) { if (parse_uint16(val, &job_msg.ntasks_per_node)) { error ("Invalid TasksPerNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.threads_per_core)) { error ("Invalid ReqThreads value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinCPUsNode", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.pn_min_cpus)) { error ("Invalid MinCPUsNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinMemoryNode", MAX(taglen, 10)) == 0) { if (parse_uint64(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinMemoryCPU", MAX(taglen, 10)) == 0) { if (parse_uint64(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryCPU value: %s", val); exit_code = 1; return 0; } job_msg.pn_min_memory |= MEM_PER_CPU; update_cnt++; } else if (xstrncasecmp(tag, "MinTmpDiskNode", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.pn_min_tmp_disk)) { error ("Invalid MinTmpDiskNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Partition", MAX(taglen, 2)) == 0) { job_msg.partition = val; update_cnt++; } else if (xstrncasecmp(tag, "QOS", MAX(taglen, 2)) == 0) { job_msg.qos = val; update_cnt++; } else if (xstrncasecmp(tag, "ReservationName", MAX(taglen, 3)) == 0) { job_msg.reservation = val; update_cnt++; } else if (!xstrncasecmp(tag, "Name", MAX(taglen, 2)) || !xstrncasecmp(tag, "JobName", MAX(taglen, 4))) { job_msg.name = val; update_cnt++; } else if (xstrncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) { job_msg.wckey = val; update_cnt++; } else if (xstrncasecmp(tag, "StdOut", MAX(taglen, 6)) == 0) { job_msg.std_out = val; update_cnt++; } else if (xstrncasecmp(tag, "Switches", MAX(taglen, 5)) == 0) { char *sep_char; job_msg.req_switch = (uint32_t) strtol(val, &sep_char, 10); update_cnt++; if (sep_char && sep_char[0] == '@') { job_msg.wait4switch = time_str2mins(sep_char+1) * 60; } } else if (xstrncasecmp(tag, "wait-for-switch", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.wait4switch)) { error ("Invalid wait-for-switch value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "OverSubscribe", MAX(taglen, 2)) || !xstrncasecmp(tag, "Shared", MAX(taglen, 2))) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.shared = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.shared = 0; else if (parse_uint16(val, &job_msg.shared)) { error("Invalid OverSubscribe value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.contiguous = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.contiguous = 0; else if (parse_uint16(val, &job_msg.contiguous)) { error ("Invalid Contiguous value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "CoreSpec", MAX(taglen, 4)) == 0) { if (!xstrcmp(val, "-1") || !xstrcmp(val, "*")) job_msg.core_spec = INFINITE16; else if (parse_uint16(val, &job_msg.core_spec)) { error ("Invalid CoreSpec value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "MemPerTres", MAX(taglen, 5))) { job_msg.mem_per_tres = val; update_cnt++; } else if (xstrncasecmp(tag, "ThreadSpec", MAX(taglen, 4)) == 0) { if (!xstrcmp(val, "-1") || !xstrcmp(val, "*")) job_msg.core_spec = INFINITE16; else if (parse_uint16(val, &job_msg.core_spec)) { error ("Invalid ThreadSpec value: %s", val); exit_code = 1; return 0; } else job_msg.core_spec |= CORE_SPEC_THREAD; update_cnt++; } else if (!xstrncasecmp(tag, "TresBind", MAX(taglen, 5))) { job_msg.tres_bind = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresFreq", MAX(taglen, 5))) { job_msg.tres_freq = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerJob", MAX(taglen, 8))) { job_msg.tres_per_job = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerNode", MAX(taglen, 8))) { /* "gres" replaced by "tres_per_node" in v18.08 */ if (job_msg.tres_per_node) xstrfmtcat(job_msg.tres_per_node, ",%s", val); else job_msg.tres_per_node = xstrdup(val); update_cnt++; } else if (!xstrncasecmp(tag, "TresPerSocket", MAX(taglen, 8))) { job_msg.tres_per_socket = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerTask", MAX(taglen, 8))) { job_msg.tres_per_task = val; update_cnt++; } else if (xstrncasecmp(tag, "ExcNodeList", MAX(taglen, 3)) == 0){ job_msg.exc_nodes = val; update_cnt++; } else if (!xstrncasecmp(tag, "NodeList", MAX(taglen, 8)) || !xstrncasecmp(tag, "ReqNodeList", MAX(taglen, 8))) { job_msg.req_nodes = val; update_size = true; update_cnt++; } else if (xstrncasecmp(tag, "Features", MAX(taglen, 1)) == 0) { job_msg.features = val; update_cnt++; } else if (xstrncasecmp(tag, "Gres", MAX(taglen, 2)) == 0) { /* "gres" replaced by "tres_per_node" in v18.08 */ if (!xstrcasecmp(val, "help") || !xstrcasecmp(val, "list")) { print_gres_help(); } else if (job_msg.tres_per_node) { xstrfmtcat(job_msg.tres_per_node, ",%s", val); } else { job_msg.tres_per_node = xstrdup(val); update_cnt++; } } else if (xstrncasecmp(tag, "Account", MAX(taglen, 1)) == 0) { job_msg.account = val; update_cnt++; } else if (xstrncasecmp(tag, "BurstBuffer", MAX(taglen, 1)) == 0) { job_msg.burst_buffer = val; update_cnt++; } else if (xstrncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) { job_msg.dependency = val; update_cnt++; } else if (xstrncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) { job_msg.licenses = val; update_cnt++; } else if (!xstrncasecmp(tag, "EligibleTime", MAX(taglen, 2)) || !xstrncasecmp(tag, "StartTime", MAX(taglen, 2))) { if ((job_msg.begin_time = parse_time(val, 0))) { if (job_msg.begin_time < time(NULL)) job_msg.begin_time = time(NULL); update_cnt++; } } else if (!xstrncasecmp(tag, "EndTime", MAX(taglen, 2))) { job_msg.end_time = parse_time(val, 0); update_cnt++; } else if (!xstrncasecmp(tag, "Reboot", MAX(taglen, 3))) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.reboot = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.reboot = 0; else if (parse_uint16(val, &job_msg.reboot)) { error ("Invalid reboot value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "UserID", MAX(taglen, 3))) { uid_t user_id = 0; if (uid_from_string(val, &user_id) < 0) { exit_code = 1; fprintf (stderr, "Invalid UserID: %s\n", val); fprintf (stderr, "Request aborted\n"); return 0; } job_uid = (uint32_t) user_id; } else if (!xstrncasecmp(tag, "Deadline", MAX(taglen, 3))) { if ((job_msg.deadline = parse_time(val, 0))) { update_cnt++; } } else { exit_code = 1; fprintf (stderr, "Update of this parameter is not " "supported: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return 0; } if (add_info) { error("Option %s does not accept [+|-]= syntax", tag); exit_code = 1; return 0; } } if (update_cnt == 0) { exit_code = 1; fprintf (stderr, "No changes specified\n"); return 0; } /* If specified, override uid with effective uid provided by * -u <uid> or --uid=<uid> */ if (euid != NO_VAL) job_msg.user_id = euid; if (!job_msg.job_id_str && job_msg.name) { /* Translate name to job ID string */ job_msg.job_id_str = _job_name2id(job_msg.name, job_uid); if (!job_msg.job_id_str) { exit_code = 1; return 0; } } if (!job_msg.job_id_str) { error("No job ID specified"); exit_code = 1; return 0; } if (update_size && !_is_single_job(job_msg.job_id_str)) { exit_code = 1; return 0; } if (_is_job_id(job_msg.job_id_str)) { job_msg.job_id_str = _next_job_id(); while (job_msg.job_id_str) { rc2 = slurm_update_job2(&job_msg, &resp); if (update_size && (rc2 == SLURM_SUCCESS)) { /* See check above for one job ID */ job_msg.job_id = slurm_atoul(job_msg.job_id_str); _update_job_size(job_msg.job_id); } if (rc2 != SLURM_SUCCESS) { rc2 = slurm_get_errno(); rc = MAX(rc, rc2); exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(slurm_get_errno()), job_msg.job_id_str); } } else if (resp) { for (i = 0; i < resp->job_array_count; i++) { if ((resp->error_code[i] == SLURM_SUCCESS) && (resp->job_array_count == 1)) continue; exit_code = 1; if (quiet_flag == 1) continue; fprintf(stderr, "%s: %s\n", resp->job_array_id[i], slurm_strerror(resp-> error_code[i])); } slurm_free_job_array_resp(resp); resp = NULL; } job_msg.job_id_str = _next_job_id(); } } else if (job_msg.job_id_str) { exit_code = 1; rc = ESLURM_INVALID_JOB_ID; slurm_seterrno(rc); if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc), job_msg.job_id_str); } } return rc; }
extern int sacctmgr_modify_account(int argc, char **argv) { int rc = SLURM_SUCCESS; slurmdb_account_cond_t *acct_cond = xmalloc(sizeof(slurmdb_account_cond_t)); slurmdb_account_rec_t *acct = xmalloc(sizeof(slurmdb_account_rec_t)); slurmdb_assoc_rec_t *assoc = xmalloc(sizeof(slurmdb_assoc_rec_t)); int i=0; int cond_set = 0, prev_set = 0, rec_set = 0, set = 0; List ret_list = NULL; slurmdb_init_assoc_rec(assoc, 0); for (i=0; i<argc; i++) { int command_len = strlen(argv[i]); if (!xstrncasecmp(argv[i], "Where", MAX(command_len, 5))) { i++; prev_set = _set_cond(&i, argc, argv, acct_cond, NULL); cond_set |= prev_set; } else if (!xstrncasecmp(argv[i], "Set", MAX(command_len, 3))) { i++; prev_set = _set_rec(&i, argc, argv, NULL, NULL, acct, assoc); rec_set |= prev_set; } else { prev_set = _set_cond(&i, argc, argv, acct_cond, NULL); cond_set |= prev_set; } } if (exit_code) { slurmdb_destroy_account_cond(acct_cond); slurmdb_destroy_account_rec(acct); slurmdb_destroy_assoc_rec(assoc); return SLURM_ERROR; } else if (!rec_set) { exit_code=1; fprintf(stderr, " You didn't give me anything to set\n"); slurmdb_destroy_account_cond(acct_cond); slurmdb_destroy_account_rec(acct); slurmdb_destroy_assoc_rec(assoc); return SLURM_ERROR; } else if (!cond_set) { if (!commit_check("You didn't set any conditions with 'WHERE'.\n" "Are you sure you want to continue?")) { printf("Aborted\n"); slurmdb_destroy_account_cond(acct_cond); slurmdb_destroy_account_rec(acct); slurmdb_destroy_assoc_rec(assoc); return SLURM_SUCCESS; } } // Special case: reset raw usage only if (assoc->usage) { rc = SLURM_ERROR; if (assoc->usage->usage_raw == 0.0) rc = sacctmgr_remove_assoc_usage(acct_cond->assoc_cond); else error("Raw usage can only be set to 0 (zero)"); slurmdb_destroy_account_cond(acct_cond); slurmdb_destroy_account_rec(acct); slurmdb_destroy_assoc_rec(assoc); return rc; } notice_thread_init(); if (rec_set & 1) { // process the account changes if (cond_set == 2) { exit_code=1; fprintf(stderr, " There was a problem with your " "'where' options.\n"); rc = SLURM_ERROR; goto assoc_start; } ret_list = slurmdb_accounts_modify( db_conn, acct_cond, acct); if (ret_list && list_count(ret_list)) { char *object = NULL; ListIterator itr = list_iterator_create(ret_list); printf(" Modified accounts...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); set = 1; } else if (ret_list) { printf(" Nothing modified\n"); rc = SLURM_ERROR; } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } FREE_NULL_LIST(ret_list); } assoc_start: if (rec_set == 3 || rec_set == 2) { // process the association changes if (cond_set == 1 && !acct_cond->assoc_cond->acct_list) { rc = SLURM_ERROR; exit_code=1; fprintf(stderr, " There was a problem with your " "'where' options.\n"); goto assoc_end; } if (assoc->parent_acct) { slurmdb_account_rec_t *acct_rec = sacctmgr_find_account(assoc->parent_acct); if (!acct_rec) { exit_code=1; fprintf(stderr, " Parent Account %s doesn't exist.\n", assoc->parent_acct); rc = SLURM_ERROR; goto assoc_end; } } ret_list = slurmdb_associations_modify( db_conn, acct_cond->assoc_cond, assoc); if (ret_list && list_count(ret_list)) { set = 1; if (assoc->def_qos_id != NO_VAL) set = sacctmgr_check_default_qos( assoc->def_qos_id, acct_cond->assoc_cond); else if (assoc->qos_list) set = sacctmgr_check_default_qos( -1, acct_cond->assoc_cond); if (set) { char *object = NULL; ListIterator itr = list_iterator_create( ret_list); printf(" Modified account associations...\n"); while((object = list_next(itr))) { printf(" %s\n", object); } list_iterator_destroy(itr); set = 1; } } else if (ret_list) { printf(" Nothing modified\n"); rc = SLURM_ERROR; } else { exit_code=1; fprintf(stderr, " Error with request: %s\n", slurm_strerror(errno)); rc = SLURM_ERROR; } FREE_NULL_LIST(ret_list); } assoc_end: notice_thread_fini(); if (set) { if (commit_check("Would you like to commit changes?")) slurmdb_connection_commit(db_conn, 1); else { printf(" Changes Discarded\n"); slurmdb_connection_commit(db_conn, 0); } } slurmdb_destroy_account_cond(acct_cond); slurmdb_destroy_account_rec(acct); slurmdb_destroy_assoc_rec(assoc); return rc; }
/* * scontrol_print_layout - print information about the supplied layout * IN argc - count of arguments * IN argv - list of arguments * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_update_layout (int argc, char **argv) { int rc = 0; int i = 0, tag_len = 0; char *tag = NULL, *val = NULL; update_layout_msg_t msg; char *opt = NULL; opt = xstrdup_printf(" "); memset(&msg, 0, sizeof(update_layout_msg_t)); while (i < argc) { tag = argv[i]; val = strchr(argv[i], '='); if (val) { tag_len = val - argv[i]; val++; } else { exit_code = 1; fprintf (stderr, "invalid option:%s for layouts " "(\"=\" mandatory)\n", tag); goto done; } if (xstrncasecmp(tag, "layouts", MAX(tag_len, 2)) == 0) { msg.layout = val; } else if (xstrncasecmp(tag, "entity", MAX(tag_len, 2)) == 0) { msg.arg = xstrdup_printf("Entity=%s", val); } else { xstrcat(opt, tag); xstrcat(opt, " "); } i++; } if (msg.layout == NULL) { exit_code = 1; fprintf (stderr, "No valid layout name in update command\n"); goto done; } if (msg.arg == NULL) { exit_code = 1; fprintf (stderr, "No valid layout enity in update command\n"); goto done; } if ( strlen(opt) <= 1 ) { exit_code = 1; fprintf (stderr, "No valid updates arguments in update command\n"); goto done; } xstrcat(msg.arg, opt); rc = slurm_update_layout(&msg); done: xfree(msg.arg); xfree(opt); if (rc) { exit_code = 1; return slurm_get_errno (); } else return 0; }
/* * scontrol_hold - perform some job hold/release operation * IN op - hold/release operation * IN job_str - a job ID or job name * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_hold(char *op, char *job_str) { static uint32_t last_job_id = NO_VAL; static job_info_msg_t *jobs = NULL; job_array_resp_msg_t *resp = NULL; int i, rc = SLURM_SUCCESS, rc2; int j; job_desc_msg_t job_msg; uint32_t job_id = 0; char *job_name = NULL; char *job_id_str = NULL; slurm_job_info_t *job_ptr; if (job_str && !xstrncasecmp(job_str, "JobID=", 6)) job_str += 6; if (job_str && !xstrncasecmp(job_str, "Job=", 4)) job_str += 4; slurm_init_job_desc_msg (&job_msg); if ((xstrncasecmp(op, "holdu", 5) == 0) || (xstrncasecmp(op, "uhold", 5) == 0)) { job_msg.priority = 0; job_msg.alloc_sid = ALLOC_SID_USER_HOLD; } else if (xstrncasecmp(op, "hold", 4) == 0) { job_msg.priority = 0; job_msg.alloc_sid = 0; } else job_msg.priority = INFINITE; if (_is_job_id(job_str)) { while ((job_msg.job_id_str = _next_job_id())) { rc2 = slurm_update_job2(&job_msg, &resp); if (rc2 != SLURM_SUCCESS) { rc2 = slurm_get_errno(); rc = MAX(rc, rc2); exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc2), job_msg.job_id_str); } } else if (resp) { for (i = 0; i < resp->job_array_count; i++) { if ((resp->error_code[i]==SLURM_SUCCESS) && (resp->job_array_count == 1)) continue; exit_code = 1; if (quiet_flag == 1) continue; fprintf(stderr, "%s: %s\n", resp->job_array_id[i], slurm_strerror(resp-> error_code[i])); } slurm_free_job_array_resp(resp); resp = NULL; } job_msg.job_id_str = _next_job_id(); } return rc; } else if (job_str) { if (!xstrncasecmp(job_str, "Name=", 5)) { job_str += 5; job_id = 0; job_name = job_str; last_job_id = NO_VAL; } else { exit_code = 1; rc = ESLURM_INVALID_JOB_ID; slurm_seterrno(rc); if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc), job_str); } return rc; } } else { last_job_id = NO_VAL; /* Refresh cache on next call */ return 0; } if (last_job_id != job_id) { if (scontrol_load_job(&jobs, job_id)) { if (quiet_flag == -1) slurm_perror ("slurm_load_job error"); return 1; } last_job_id = job_id; } /* set current user, needed e.g., for AllowGroups checks */ for (i = 0, job_ptr = jobs->job_array; i < jobs->record_count; i++, job_ptr++) { if (xstrcmp(job_name, job_ptr->name)) continue; if (!IS_JOB_PENDING(job_ptr)) { if (job_ptr->array_task_id != NO_VAL) continue; slurm_seterrno(ESLURM_JOB_NOT_PENDING); rc = MAX(rc, ESLURM_JOB_NOT_PENDING); } if (job_ptr->array_task_str) { xstrfmtcat(job_id_str, "%u_%s", job_ptr->array_job_id, job_ptr->array_task_str); } else if (job_ptr->array_task_id != NO_VAL) { xstrfmtcat(job_id_str, "%u_%u", job_ptr->array_job_id, job_ptr->array_task_id); } else { xstrfmtcat(job_id_str, "%u", job_ptr->job_id); } job_msg.job_id_str = job_id_str; rc2 = slurm_update_job2(&job_msg, &resp); if (rc2 != SLURM_SUCCESS) { rc2 = slurm_get_errno(); rc = MAX(rc, rc2); exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc2), job_msg.job_id_str); } } else if (resp) { for (j = 0; j < resp->job_array_count; j++) { if ((resp->error_code[j] == SLURM_SUCCESS) && (resp->job_array_count == 1)) continue; exit_code = 1; if (quiet_flag == 1) continue; fprintf(stderr, "%s: %s\n", resp->job_array_id[j], slurm_strerror(resp->error_code[j])); } slurm_free_job_array_resp(resp); resp = NULL; } xfree(job_id_str); } return rc; }
/* sacctmgr_list_tres() */ int sacctmgr_list_tres(int argc, char **argv) { List tres_list; ListIterator itr; ListIterator itr2; List format_list = list_create(slurm_destroy_char); List print_fields_list; slurmdb_tres_cond_t *tres_cond = xmalloc(sizeof(slurmdb_tres_cond_t)); slurmdb_tres_rec_t *tres; int field_count, i; print_field_t *field; 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, tres_cond, format_list); } if (exit_code) { slurmdb_destroy_tres_cond(tres_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, "Type,Name%15,ID"); } tres_list = slurmdb_tres_get(db_conn, tres_cond); slurmdb_destroy_tres_cond(tres_cond); if (!tres_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(tres_list); itr2 = list_iterator_create(print_fields_list); print_fields_header(print_fields_list); field_count = list_count(print_fields_list); /* For each tres prints the data structure members */ while ((tres = list_next(itr))) { while ((field = list_next(itr2))) { switch (field->type) { case PRINT_NAME: field->print_routine(field, tres->name, field_count); break; case PRINT_ID: field->print_routine(field, tres->id, field_count); break; case PRINT_TYPE: field->print_routine(field, tres->type, field_count); break; } } list_iterator_reset(itr2); printf("\n"); } list_iterator_destroy(itr); list_iterator_destroy(itr2); FREE_NULL_LIST(tres_list); FREE_NULL_LIST(print_fields_list); return 0; }
static int _set_cond(int *start, int argc, char **argv, slurmdb_tres_cond_t *tres_cond, List format_list) { int i; int set = 0; int end = 0; int command_len = 0; if (!tres_cond) { exit_code=1; fprintf(stderr, "No tres_cond given"); return -1; } for (i=(*start); i<argc; i++) { end = parse_option_end(argv[i]); if (!end) command_len=strlen(argv[i]); else { command_len=end-1; if (argv[i][end] == '=') { end++; } } if (!xstrncasecmp(argv[i], "Set", MAX(command_len, 3))) { i--; break; } else if (!end && !xstrncasecmp(argv[i], "WithDeleted", MAX(command_len, 5))) { tres_cond->with_deleted = 1; } else if (!end && !xstrncasecmp(argv[i], "where", MAX(command_len, 5))) { continue; } else if (!end || !xstrncasecmp(argv[i], "Type", MAX(command_len, 2))) { if (!tres_cond->type_list) { tres_cond->type_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list( tres_cond->type_list, argv[i]+end)) set = 1; } else if (!xstrncasecmp(argv[i], "Names", MAX(command_len, 1))) { if (!tres_cond->name_list) { tres_cond->name_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list(tres_cond->name_list, argv[i]+end)) set = 1; } else if (!xstrncasecmp(argv[i], "Format", MAX(command_len, 1))) { if (format_list) slurm_addto_char_list(format_list, argv[i]+end); } else if (!xstrncasecmp(argv[i], "Ids", MAX(command_len, 1))) { if (!tres_cond->id_list) { tres_cond->id_list = list_create(slurm_destroy_char); } if (slurm_addto_char_list(tres_cond->id_list, argv[i]+end)) set = 1; } else { exit_code=1; fprintf(stderr, " Unknown condition: %s\n" " Use keyword 'set' to modify value\n", argv[i]); } } (*start) = i; if (set) return 1; return 0; }
/* * scontrol_checkpoint - perform some checkpoint/resume operation * IN op - checkpoint operation * IN job_step_id_str - either a job name (for all steps of the given job) or * a step name: "<jid>.<step_id>" * IN argc - argument count * IN argv - arguments of the operation * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_checkpoint(char *op, char *job_step_id_str, int argc, char **argv) { int rc = SLURM_SUCCESS; uint32_t job_id = 0, step_id = 0; char *next_str; uint32_t ckpt_errno; char *ckpt_strerror = NULL; int oplen = strlen(op); uint16_t max_wait = CKPT_WAIT, stick = 0; char *image_dir = NULL; if (job_step_id_str) { job_id = (uint32_t) strtol (job_step_id_str, &next_str, 10); if (next_str[0] == '.') { step_id = (uint32_t) strtol (&next_str[1], &next_str, 10); } else step_id = NO_VAL; if (next_str[0] != '\0') { fprintf(stderr, "Invalid job step name\n"); return 0; } } else { fprintf(stderr, "Invalid job step name\n"); return 0; } if (xstrncasecmp(op, "able", MAX(oplen, 1)) == 0) { time_t start_time; rc = slurm_checkpoint_able (job_id, step_id, &start_time); if (rc == SLURM_SUCCESS) { if (start_time) { char time_str[32]; slurm_make_time_str(&start_time, time_str, sizeof(time_str)); printf("Began at %s\n", time_str); } else printf("Yes\n"); } else if (slurm_get_errno() == ESLURM_DISABLED) { printf("No\n"); rc = SLURM_SUCCESS; /* not real error */ } } else if (xstrncasecmp(op, "complete", MAX(oplen, 2)) == 0) { /* Undocumented option used for testing purposes */ static uint32_t error_code = 1; char error_msg[64]; sprintf(error_msg, "test error message %d", error_code); rc = slurm_checkpoint_complete(job_id, step_id, (time_t) 0, error_code++, error_msg); } else if (xstrncasecmp(op, "disable", MAX(oplen, 1)) == 0) rc = slurm_checkpoint_disable (job_id, step_id); else if (xstrncasecmp(op, "enable", MAX(oplen, 2)) == 0) rc = slurm_checkpoint_enable (job_id, step_id); else if (xstrncasecmp(op, "create", MAX(oplen, 2)) == 0) { if (_parse_checkpoint_args(argc, argv, &max_wait, &image_dir)){ return 0; } rc = slurm_checkpoint_create (job_id, step_id, max_wait, image_dir); } else if (xstrncasecmp(op, "requeue", MAX(oplen, 2)) == 0) { if (_parse_checkpoint_args(argc, argv, &max_wait, &image_dir)){ return 0; } rc = slurm_checkpoint_requeue (job_id, max_wait, image_dir); } else if (xstrncasecmp(op, "vacate", MAX(oplen, 2)) == 0) { if (_parse_checkpoint_args(argc, argv, &max_wait, &image_dir)){ return 0; } rc = slurm_checkpoint_vacate (job_id, step_id, max_wait, image_dir); } else if (xstrncasecmp(op, "restart", MAX(oplen, 2)) == 0) { if (_parse_restart_args(argc, argv, &stick, &image_dir)) { return 0; } rc = slurm_checkpoint_restart (job_id, step_id, stick, image_dir); } else if (xstrncasecmp(op, "error", MAX(oplen, 2)) == 0) { rc = slurm_checkpoint_error (job_id, step_id, &ckpt_errno, &ckpt_strerror); if (rc == SLURM_SUCCESS) { printf("error(%u): %s\n", ckpt_errno, ckpt_strerror); free(ckpt_strerror); } } else { fprintf (stderr, "Invalid checkpoint operation: %s\n", op); return 0; } return rc; }