PageRenderTime 66ms CodeModel.GetById 31ms RepoModel.GetById 1ms app.codeStats 0ms

/src/sacctmgr/common.c

https://github.com/cfenoy/slurm
C | 1578 lines | 1323 code | 201 blank | 54 comment | 525 complexity | e8f2e4f9f3364d10826f0dafebd4091b MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0 
    

  1. /*****************************************************************************\
    2. 

  2.  *  common.c - definitions for functions common to all modules in sacctmgr.
    3. 

  3.  *****************************************************************************
    4. 

  4.  *  Copyright (C) 2008 Lawrence Livermore National Security.
    5. 

  5.  *  Copyright (C) 2002-2007 The Regents of the University of California.
    6. 

  6.  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
    7. 

  7.  *  Written by Danny Auble <da@llnl.gov>
    8. 

  8.  *  CODE-OCEC-09-009. All rights reserved.
    9. 

  9.  *
    10. 

  10.  *  This file is part of SLURM, a resource management program.
    11. 

  11.  *  For details, see <http://www.schedmd.com/slurmdocs/>.
    12. 

  12.  *  Please also read the included file: DISCLAIMER.
    13. 

  13.  *
    14. 

  14.  *  SLURM is free software; you can redistribute it and/or modify it under
    15. 

  15.  *  the terms of the GNU General Public License as published by the Free
    16. 

  16.  *  Software Foundation; either version 2 of the License, or (at your option)
    17. 

  17.  *  any later version.
    18. 

  18.  *
    19. 

  19.  *  In addition, as a special exception, the copyright holders give permission
    20. 

  20.  *  to link the code of portions of this program with the OpenSSL library under
    21. 

  21.  *  certain conditions as described in each individual source file, and
    22. 

  22.  *  distribute linked combinations including the two. You must obey the GNU
    23. 

  23.  *  General Public License in all respects for all of the code used other than
    24. 

  24.  *  OpenSSL. If you modify file(s) with this exception, you may extend this
    25. 

  25.  *  exception to your version of the file(s), but you are not obligated to do
    26. 

  26.  *  so. If you do not wish to do so, delete this exception statement from your
    27. 

  27.  *  version.  If you delete this exception statement from all source files in
    28. 

  28.  *  the program, then also delete it here.
    29. 

  29.  *
    30. 

  30.  *  SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
    31. 

  31.  *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    32. 

  32.  *  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    33. 

  33.  *  details.
    34. 

  34.  *
    35. 

  35.  *  You should have received a copy of the GNU General Public License along
    36. 

  36.  *  with SLURM; if not, write to the Free Software Foundation, Inc.,
    37. 

  37.  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
    38. 

  38. \*****************************************************************************/
    39. 

  39. 

  40. #include "src/sacctmgr/sacctmgr.h"
    41. 

  41. #include "src/common/slurmdbd_defs.h"
    42. 

  42. #include "src/common/slurm_auth.h"
    43. 

  43. 

  44. #include <unistd.h>
    45. 

  45. #include <termios.h>
    46. 

  46. 

  47. #define FORMAT_STRING_SIZE 32
    48. 

  48. 

  49. static pthread_t lock_warning_thread;
    50. 

  50. 

  51. static void *_print_lock_warn(void *no_data)
    52. 

  52. {
    53. 

  53. 	sleep(5);
    54. 

  54. 	printf(" Database is busy or waiting for lock from other user.\n");
    55. 

  55. 

  56. 	return NULL;
    57. 

  57. }
    58. 

  58. 

  59. static void _nonblock(int state)
    60. 

  60. {
    61. 

  61. 	struct termios ttystate;
    62. 

  62. 

  63. 	//get the terminal state
    64. 

  64. 	tcgetattr(STDIN_FILENO, &ttystate);
    65. 

  65. 

  66. 	switch(state) {
    67. 

  67. 	case 1:
    68. 

  68. 		//turn off canonical mode
    69. 

  69. 		ttystate.c_lflag &= ~ICANON;
    70. 

  70. 		//minimum of number input read.
    71. 

  71. 		ttystate.c_cc[VMIN] = 1;
    72. 

  72. 		break;
    73. 

  73. 	default:
    74. 

  74. 		//turn on canonical mode
    75. 

  75. 		ttystate.c_lflag |= ICANON;
    76. 

  76. 	}
    77. 

  77. 	//set the terminal attributes.
    78. 

  78. 	tcsetattr(STDIN_FILENO, TCSANOW, &ttystate);
    79. 

  79. 

  80. }
    81. 

  81. 

  82. extern int parse_option_end(char *option)
    83. 

  83. {
    84. 

  84. 	int end = 0;
    85. 

  85. 

  86. 	if (!option)
    87. 

  87. 		return 0;
    88. 

  88. 

  89. 	while(option[end]) {
    90. 

  90. 		if ((option[end] == '=')
    91. 

  91. 		   || (option[end] == '+' && option[end+1] == '=')
    92. 

  92. 		   || (option[end] == '-' && option[end+1] == '='))
    93. 

  93. 			break;
    94. 

  94. 		end++;
    95. 

  95. 	}
    96. 

  96. 

  97. 	if (!option[end])
    98. 

  98. 		return 0;
    99. 

  99. 

  100. 	end++;
    101. 

  101. 	return end;
    102. 

  102. }
    103. 

  103. 

  104. /* you need to xfree whatever is sent from here */
    105. 

  105. extern char *strip_quotes(char *option, int *increased, bool make_lower)
    106. 

  106. {
    107. 

  107. 	int end = 0;
    108. 

  108. 	int i=0, start=0;
    109. 

  109. 	char *meat = NULL;
    110. 

  110. 	char quote_c = '\0';
    111. 

  111. 	int quote = 0;
    112. 

  112. 

  113. 	if (!option)
    114. 

  114. 		return NULL;
    115. 

  115. 

  116. 	/* first strip off the ("|')'s */
    117. 

  117. 	if (option[i] == '\"' || option[i] == '\'') {
    118. 

  118. 		quote_c = option[i];
    119. 

  119. 		quote = 1;
    120. 

  120. 		i++;
    121. 

  121. 	}
    122. 

  122. 	start = i;
    123. 

  123. 

  124. 	while(option[i]) {
    125. 

  125. 		if (quote && option[i] == quote_c) {
    126. 

  126. 			end++;
    127. 

  127. 			break;
    128. 

  128. 		} else if (option[i] == '\"' || option[i] == '\'')
    129. 

  129. 			option[i] = '`';
    130. 

  130. 		else if (make_lower) {
    131. 

  131. 			char lower = tolower(option[i]);
    132. 

  132. 			if (lower != option[i])
    133. 

  133. 				option[i] = lower;
    134. 

  134. 		}
    135. 

  135. 

  136. 		i++;
    137. 

  137. 	}
    138. 

  138. 	end += i;
    139. 

  139. 

  140. 	meat = xmalloc((i-start)+1);
    141. 

  141. 	memcpy(meat, option+start, (i-start));
    142. 

  142. 

  143. 	if (increased)
    144. 

  144. 		(*increased) += end;
    145. 

  145. 

  146. 	return meat;
    147. 

  147. }
    148. 

  148. 

  149. static print_field_t *_get_print_field(char *object)
    150. 

  150. {
    151. 

  151. 	/* This should be kept in alpha order to avoid picking the
    152. 

  152. 	   wrong field name.
    153. 

  153. 	*/
    154. 

  154. 	print_field_t *field = xmalloc(sizeof(print_field_t));
    155. 

  155. 	char *tmp_char = NULL;
    156. 

  156. 	int command_len, field_len = 0;
    157. 

  157. 

  158. 	if((tmp_char = strstr(object, "\%"))) {
    159. 

  159. 		field_len = atoi(tmp_char+1);
    160. 

  160. 		tmp_char[0] = '\0';
    161. 

  161. 	}
    162. 

  162. 	command_len = strlen(object);
    163. 

  163. 

  164. 	if (!strncasecmp("Account", object, MAX(command_len, 3))
    165. 

  165. 	    || !strncasecmp("Acct", object, MAX(command_len, 4))) {
    166. 

  166. 		field->type = PRINT_ACCT;
    167. 

  167. 		field->name = xstrdup("Account");
    168. 

  168. 		if (tree_display)
    169. 

  169. 			field->len = -20;
    170. 

  170. 		else
    171. 

  171. 			field->len = 10;
    172. 

  172. 		field->print_routine = print_fields_str;
    173. 

  173. 	} else if (!strncasecmp("ActionRaw", object, MAX(command_len, 7))) {
    174. 

  174. 		field->type = PRINT_ACTIONRAW;
    175. 

  175. 		field->name = xstrdup("ActionRaw");
    176. 

  176. 		field->len = 10;
    177. 

  177. 		field->print_routine = print_fields_uint;
    178. 

  178. 	} else if (!strncasecmp("Action", object, MAX(command_len, 4))) {
    179. 

  179. 		field->type = PRINT_ACTION;
    180. 

  180. 		field->name = xstrdup("Action");
    181. 

  181. 		field->len = 20;
    182. 

  182. 		field->print_routine = print_fields_str;
    183. 

  183. 	} else if (!strncasecmp("Actor", object, MAX(command_len, 4))) {
    184. 

  184. 		field->type = PRINT_ACTOR;
    185. 

  185. 		field->name = xstrdup("Actor");
    186. 

  186. 		field->len = 10;
    187. 

  187. 		field->print_routine = print_fields_str;
    188. 

  188. 	} else if (!strncasecmp("AdminLevel", object, MAX(command_len, 2))) {
    189. 

  189. 		field->type = PRINT_ADMIN;
    190. 

  190. 		field->name = xstrdup("Admin");
    191. 

  191. 		field->len = 9;
    192. 

  192. 		field->print_routine = print_fields_str;
    193. 

  193. 	} else if (!strncasecmp("Classification", object,
    194. 

  194. 				MAX(command_len, 3))) {
    195. 

  195. 		field->type = PRINT_CPUS;
    196. 

  196. 		field->name = xstrdup("Class");
    197. 

  197. 		field->len = 9;
    198. 

  198. 		field->print_routine = print_fields_str;
    199. 

  199. 	} else if (!strncasecmp("ClusterNodes", object, MAX(command_len, 8))
    200. 

  200. 		   || !strncasecmp("NodeNames", object, MAX(command_len, 8))) {
    201. 

  201. 		field->type = PRINT_CLUSTER_NODES;
    202. 

  202. 		field->name = xstrdup("Cluster Nodes");
    203. 

  203. 		field->len = 20;
    204. 

  204. 		field->print_routine = print_fields_str;
    205. 

  205. 	} else if (!strncasecmp("Cluster", object, MAX(command_len, 2))) {
    206. 

  206. 		field->type = PRINT_CLUSTER;
    207. 

  207. 		field->name = xstrdup("Cluster");
    208. 

  208. 		field->len = 10;
    209. 

  209. 		field->print_routine = print_fields_str;
    210. 

  210. 	} else if (!strncasecmp("Coordinators", object, MAX(command_len, 2))) {
    211. 

  211. 		field->type = PRINT_COORDS;
    212. 

  212. 		field->name = xstrdup("Coord Accounts");
    213. 

  213. 		field->len = 20;
    214. 

  214. 		field->print_routine = sacctmgr_print_coord_list;
    215. 

  215. 	} else if (!strncasecmp("ControlHost", object, MAX(command_len, 8))) {
    216. 

  216. 		field->type = PRINT_CHOST;
    217. 

  217. 		field->name = xstrdup("ControlHost");
    218. 

  218. 		field->len = 15;
    219. 

  219. 		field->print_routine = print_fields_str;
    220. 

  220. 	} else if (!strncasecmp("ControlPort", object, MAX(command_len, 8))) {
    221. 

  221. 		field->type = PRINT_CPORT;
    222. 

  222. 		field->name = xstrdup("ControlPort");
    223. 

  223. 		field->len = 12;
    224. 

  224. 		field->print_routine = print_fields_uint;
    225. 

  225. 	} else if (!strncasecmp("CPUCount", object, MAX(command_len, 2))) {
    226. 

  226. 		field->type = PRINT_CPUS;
    227. 

  227. 		field->name = xstrdup("CPUCount");
    228. 

  228. 		field->len = 9;
    229. 

  229. 		field->print_routine = print_fields_str;
    230. 

  230. 	} else if (!strncasecmp("DefaultAccount", object,
    231. 

  231. 				MAX(command_len, 8))) {
    232. 

  232. 		field->type = PRINT_DACCT;
    233. 

  233. 		field->name = xstrdup("Def Acct");
    234. 

  234. 		field->len = 10;
    235. 

  235. 		field->print_routine = print_fields_str;
    236. 

  236. 	} else if (!strncasecmp("DefaultQOS", object, MAX(command_len, 8))) {
    237. 

  237. 		field->type = PRINT_DQOS;
    238. 

  238. 		field->name = xstrdup("Def QOS");
    239. 

  239. 		field->len = 9;
    240. 

  240. 		field->print_routine = print_fields_str;
    241. 

  241. 	} else if (!strncasecmp("DefaultWCKey", object, MAX(command_len, 8))) {
    242. 

  242. 		field->type = PRINT_DWCKEY;
    243. 

  243. 		field->name = xstrdup("Def WCKey");
    244. 

  244. 		field->len = 10;
    245. 

  245. 		field->print_routine = print_fields_str;
    246. 

  246. 	} else if (!strncasecmp("Description", object, MAX(command_len, 3))) {
    247. 

  247. 		field->type = PRINT_DESC;
    248. 

  248. 		field->name = xstrdup("Descr");
    249. 

  249. 		field->len = 20;
    250. 

  250. 		field->print_routine = print_fields_str;
    251. 

  251. 	} else if(!strncasecmp("Duration", object, MAX(command_len, 2))) {
    252. 

  252. 		field->type = PRINT_DURATION;
    253. 

  253. 		field->name = xstrdup("Duration");
    254. 

  254. 		field->len = 13;
    255. 

  255. 		field->print_routine = print_fields_time_from_secs;
    256. 

  256. 	} else if(!strncasecmp("End", object, MAX(command_len, 2))) {
    257. 

  257. 		field->type = PRINT_END;
    258. 

  258. 		field->name = xstrdup("End");
    259. 

  259. 		field->len = 19;
    260. 

  260. 		field->print_routine = print_fields_date;
    261. 

  261. 	} else if(!strncasecmp("EventRaw", object, MAX(command_len, 6))) {
    262. 

  262. 		field->type = PRINT_EVENTRAW;
    263. 

  263. 		field->name = xstrdup("EventRaw");
    264. 

  264. 		field->len = 8;
    265. 

  265. 		field->print_routine = print_fields_uint;
    266. 

  266. 	} else if(!strncasecmp("Event", object, MAX(command_len, 2))) {
    267. 

  267. 		field->type = PRINT_EVENT;
    268. 

  268. 		field->name = xstrdup("Event");
    269. 

  269. 		field->len = 7;
    270. 

  270. 		field->print_routine = print_fields_str;
    271. 

  271. 	} else if (!strncasecmp("Flags", object, MAX(command_len, 2))) {
    272. 

  272. 		field->type = PRINT_FLAGS;
    273. 

  273. 		field->name = xstrdup("Flags");
    274. 

  274. 		field->len = 20;
    275. 

  275. 		field->print_routine = print_fields_str;
    276. 

  276. 	} else if (!strncasecmp("GraceTime", object, MAX(command_len, 3))) {
    277. 

  277. 		field->type = PRINT_GRACE;
    278. 

  278. 		field->name = xstrdup("GraceTime");
    279. 

  279. 		field->len = 10;
    280. 

  280. 		field->print_routine = print_fields_time_from_secs;
    281. 

  281. 	} else if (!strncasecmp("GrpCPUMins", object, MAX(command_len, 7))) {
    282. 

  282. 		field->type = PRINT_GRPCM;
    283. 

  283. 		field->name = xstrdup("GrpCPUMins");
    284. 

  284. 		field->len = 11;
    285. 

  285. 		field->print_routine = print_fields_uint64;
    286. 

  286. 	} else if (!strncasecmp("GrpCPURunMins", object, MAX(command_len, 7))) {
    287. 

  287. 		field->type = PRINT_GRPCRM;
    288. 

  288. 		field->name = xstrdup("GrpCPURunMins");
    289. 

  289. 		field->len = 13;
    290. 

  290. 		field->print_routine = print_fields_uint64;
    291. 

  291. 	} else if (!strncasecmp("GrpCPUs", object, MAX(command_len, 7))) {
    292. 

  292. 		field->type = PRINT_GRPC;
    293. 

  293. 		field->name = xstrdup("GrpCPUs");
    294. 

  294. 		field->len = 8;
    295. 

  295. 		field->print_routine = print_fields_uint;
    296. 

  296. 	} else if (!strncasecmp("GrpJobs", object, MAX(command_len, 4))) {
    297. 

  297. 		field->type = PRINT_GRPJ;
    298. 

  298. 		field->name = xstrdup("GrpJobs");
    299. 

  299. 		field->len = 7;
    300. 

  300. 		field->print_routine = print_fields_uint;
    301. 

  301. 	} else if (!strncasecmp("GrpMemory", object, MAX(command_len, 4))) {
    302. 

  302. 		field->type = PRINT_GRPMEM;
    303. 

  303. 		field->name = xstrdup("GrpMem");
    304. 

  304. 		field->len = 7;
    305. 

  305. 		field->print_routine = print_fields_uint;
    306. 

  306. 	} else if (!strncasecmp("GrpNodes", object, MAX(command_len, 4))) {
    307. 

  307. 		field->type = PRINT_GRPN;
    308. 

  308. 		field->name = xstrdup("GrpNodes");
    309. 

  309. 		field->len = 8;
    310. 

  310. 		field->print_routine = print_fields_uint;
    311. 

  311. 	} else if (!strncasecmp("GrpSubmitJobs", object, MAX(command_len, 4))) {
    312. 

  312. 		field->type = PRINT_GRPS;
    313. 

  313. 		field->name = xstrdup("GrpSubmit");
    314. 

  314. 		field->len = 9;
    315. 

  315. 		field->print_routine = print_fields_uint;
    316. 

  316. 	} else if (!strncasecmp("GrpWall", object, MAX(command_len, 4))) {
    317. 

  317. 		field->type = PRINT_GRPW;
    318. 

  318. 		field->name = xstrdup("GrpWall");
    319. 

  319. 		field->len = 11;
    320. 

  320. 		field->print_routine = print_fields_time;
    321. 

  321. 	} else if (!strncasecmp("ID", object, MAX(command_len, 2))) {
    322. 

  322. 		field->type = PRINT_ID;
    323. 

  323. 		field->name = xstrdup("ID");
    324. 

  324. 		field->len = 6;
    325. 

  325. 		field->print_routine = print_fields_uint;
    326. 

  326. 	} else if (!strncasecmp("Info", object, MAX(command_len, 2))) {
    327. 

  327. 		field->type = PRINT_INFO;
    328. 

  328. 		field->name = xstrdup("Info");
    329. 

  329. 		field->len = 20;
    330. 

  330. 		field->print_routine = print_fields_str;
    331. 

  331. 	} else if (!strncasecmp("LFT", object, MAX(command_len, 1))) {
    332. 

  332. 		field->type = PRINT_LFT;
    333. 

  333. 		field->name = xstrdup("LFT");
    334. 

  334. 		field->len = 6;
    335. 

  335. 		field->print_routine = print_fields_uint;
    336. 

  336. 	} else if (!strncasecmp("MaxCPUMinsPerJob", object,
    337. 

  337. 				MAX(command_len, 7))) {
    338. 

  338. 		field->type = PRINT_MAXCM;
    339. 

  339. 		field->name = xstrdup("MaxCPUMins");
    340. 

  340. 		field->len = 11;
    341. 

  341. 		field->print_routine = print_fields_uint64;
    342. 

  342. 	} else if (!strncasecmp("MaxCPURunMinsPerUser",
    343. 

  343. 				object, MAX(command_len, 7))) {
    344. 

  344. 		field->type = PRINT_MAXCRM;
    345. 

  345. 		field->name = xstrdup("MaxCPURunMinsPU");
    346. 

  346. 		field->len = 15;
    347. 

  347. 		field->print_routine = print_fields_uint64;
    348. 

  348. 	} else if (!strncasecmp("MaxCPUsPerJob", object, MAX(command_len, 7))) {
    349. 

  349. 		field->type = PRINT_MAXC;
    350. 

  350. 		field->name = xstrdup("MaxCPUs");
    351. 

  351. 		field->len = 8;
    352. 

  352. 		field->print_routine = print_fields_uint;
    353. 

  353. 	} else if (!strncasecmp("MaxCPUsPerUser", object,
    354. 

  354. 				MAX(command_len, 11))) {
    355. 

  355. 		field->type = PRINT_MAXCU;
    356. 

  356. 		field->name = xstrdup("MaxCPUsPU");
    357. 

  357. 		field->len = 9;
    358. 

  358. 		field->print_routine = print_fields_uint;
    359. 

  359. 	} else if (!strncasecmp("MaxJobs", object, MAX(command_len, 4))) {
    360. 

  360. 		field->type = PRINT_MAXJ;
    361. 

  361. 		field->name = xstrdup("MaxJobs");
    362. 

  362. 		field->len = 7;
    363. 

  363. 		field->print_routine = print_fields_uint;
    364. 

  364. 	} else if (!strncasecmp("MaxJobsPerUser",
    365. 

  365. 				object, MAX(command_len, 8))) {
    366. 

  366. 		field->type = PRINT_MAXJ; /* used same as MaxJobs */
    367. 

  367. 		field->name = xstrdup("MaxJobsPU");
    368. 

  368. 		field->len = 9;
    369. 

  369. 		field->print_routine = print_fields_uint;
    370. 

  370. 	} else if (!strncasecmp("MaxNodesPerJob", object,
    371. 

  371. 				MAX(command_len, 4))) {
    372. 

  372. 		field->type = PRINT_MAXN;
    373. 

  373. 		field->name = xstrdup("MaxNodes");
    374. 

  374. 		field->len = 8;
    375. 

  375. 		field->print_routine = print_fields_uint;
    376. 

  376. 	} else if (!strncasecmp("MaxNodesPerUser", object,
    377. 

  377. 				MAX(command_len, 12))) {
    378. 

  378. 		field->type = PRINT_MAXNU;
    379. 

  379. 		field->name = xstrdup("MaxNodesPU");
    380. 

  380. 		field->len = 10;
    381. 

  381. 		field->print_routine = print_fields_uint;
    382. 

  382. 	} else if (!strncasecmp("MaxSubmitJobs", object, MAX(command_len, 4))) {
    383. 

  383. 		field->type = PRINT_MAXS;
    384. 

  384. 		field->name = xstrdup("MaxSubmit");
    385. 

  385. 		field->len = 9;
    386. 

  386. 		field->print_routine = print_fields_uint;
    387. 

  387. 	} else if (!strncasecmp("MaxSubmitJobsPerUser",
    388. 

  388. 				object, MAX(command_len, 10))) {
    389. 

  389. 		field->type = PRINT_MAXS; /* used same as MaxSubmitJobs */
    390. 

  390. 		field->name = xstrdup("MaxSubmitPU");
    391. 

  391. 		field->len = 11;
    392. 

  392. 		field->print_routine = print_fields_uint;
    393. 

  393. 	} else if (!strncasecmp("MaxWallDurationPerJob", object,
    394. 

  394. 				MAX(command_len, 4))) {
    395. 

  395. 		field->type = PRINT_MAXW;
    396. 

  396. 		field->name = xstrdup("MaxWall");
    397. 

  397. 		field->len = 11;
    398. 

  398. 		field->print_routine = print_fields_time;
    399. 

  399. 	} else if (!strncasecmp("Name", object, MAX(command_len, 2))) {
    400. 

  400. 		field->type = PRINT_NAME;
    401. 

  401. 		field->name = xstrdup("Name");
    402. 

  402. 		field->len = 10;
    403. 

  403. 		field->print_routine = print_fields_str;
    404. 

  404. 	} else if (!strncasecmp("NodeCount", object, MAX(command_len, 5))) {
    405. 

  405. 		field->type = PRINT_NODECNT;
    406. 

  406. 		field->name = xstrdup("NodeCount");
    407. 

  407. 		field->len = 9;
    408. 

  408. 		field->print_routine = print_fields_uint;
    409. 

  409. 	} else if (!strncasecmp("NodeName", object, MAX(command_len, 5))) {
    410. 

  410. 		field->type = PRINT_NODENAME;
    411. 

  411. 		field->name = xstrdup("NodeName");
    412. 

  412. 		field->len = 20;
    413. 

  413. 		field->print_routine = print_fields_str;
    414. 

  414. 	} else if (!strncasecmp("Organization", object, MAX(command_len, 1))) {
    415. 

  415. 		field->type = PRINT_ORG;
    416. 

  416. 		field->name = xstrdup("Org");
    417. 

  417. 		field->len = 20;
    418. 

  418. 		field->print_routine = print_fields_str;
    419. 

  419. 	} else if (!strncasecmp("ParentID", object, MAX(command_len, 7))) {
    420. 

  420. 		field->type = PRINT_PID;
    421. 

  421. 		field->name = xstrdup("Par ID");
    422. 

  422. 		field->len = 6;
    423. 

  423. 		field->print_routine = print_fields_uint;
    424. 

  424. 	} else if (!strncasecmp("ParentName", object, MAX(command_len, 7))) {
    425. 

  425. 		field->type = PRINT_PNAME;
    426. 

  426. 		field->name = xstrdup("Par Name");
    427. 

  427. 		field->len = 10;
    428. 

  428. 		field->print_routine = print_fields_str;
    429. 

  429. 	} else if (!strncasecmp("Partition", object, MAX(command_len, 4))) {
    430. 

  430. 		field->type = PRINT_PART;
    431. 

  431. 		field->name = xstrdup("Partition");
    432. 

  432. 		field->len = 10;
    433. 

  433. 		field->print_routine = print_fields_str;
    434. 

  434. 	} else if (!strncasecmp("PluginIDSelect", object,
    435. 

  435. 				MAX(command_len, 2))) {
    436. 

  436. 		field->type = PRINT_SELECT;
    437. 

  437. 		field->name = xstrdup("PluginIDSelect");
    438. 

  438. 		field->len = 14;
    439. 

  439. 		field->print_routine = print_fields_uint;
    440. 

  440. 	} else if (!strncasecmp("PreemptMode", object, MAX(command_len, 8))) {
    441. 

  441. 		field->type = PRINT_PREEM;
    442. 

  442. 		field->name = xstrdup("PreemptMode");
    443. 

  443. 		field->len = 11;
    444. 

  444. 		field->print_routine = print_fields_str;
    445. 

  445. 	/* Preempt needs to follow PreemptMode */
    446. 

  446. 	} else if (!strncasecmp("Preempt", object, MAX(command_len, 7))) {
    447. 

  447. 		field->type = PRINT_PREE;
    448. 

  448. 		field->name = xstrdup("Preempt");
    449. 

  449. 		field->len = 10;
    450. 

  450. 		field->print_routine = sacctmgr_print_qos_bitstr;
    451. 

  451. 	} else if (!strncasecmp("Priority", object, MAX(command_len, 3))) {
    452. 

  452. 		field->type = PRINT_PRIO;
    453. 

  453. 		field->name = xstrdup("Priority");
    454. 

  454. 		field->len = 10;
    455. 

  455. 		field->print_routine = print_fields_uint;
    456. 

  456. 	} else if (!strncasecmp("Problem", object, MAX(command_len, 1))) {
    457. 

  457. 		field->type = PRINT_PROBLEM;
    458. 

  458. 		field->name = xstrdup("Problem");
    459. 

  459. 		field->len = 40;
    460. 

  460. 		field->print_routine = print_fields_str;
    461. 

  461. 	} else if (!strncasecmp("QOSLevel", object, MAX(command_len, 3))) {
    462. 

  462. 		field->type = PRINT_QOS;
    463. 

  463. 		field->name = xstrdup("QOS");
    464. 

  464. 		field->len = 20;
    465. 

  465. 		field->print_routine = sacctmgr_print_qos_list;
    466. 

  466. 	} else if (!strncasecmp("QOSRAWLevel", object, MAX(command_len, 4))) {
    467. 

  467. 		field->type = PRINT_QOS_RAW;
    468. 

  468. 		field->name = xstrdup("QOS_RAW");
    469. 

  469. 		field->len = 10;
    470. 

  470. 		field->print_routine = print_fields_char_list;
    471. 

  471. 	} else if (!strncasecmp("RGT", object, MAX(command_len, 1))) {
    472. 

  472. 		field->type = PRINT_RGT;
    473. 

  473. 		field->name = xstrdup("RGT");
    474. 

  474. 		field->len = 6;
    475. 

  475. 		field->print_routine = print_fields_uint;
    476. 

  476. 	} else if (!strncasecmp("RPC", object, MAX(command_len, 1))) {
    477. 

  477. 		field->type = PRINT_RPC_VERSION;
    478. 

  478. 		field->name = xstrdup("RPC");
    479. 

  479. 		field->len = 3;
    480. 

  480. 		field->print_routine = print_fields_uint;
    481. 

  481. 	} else if (!strncasecmp("Share", object, MAX(command_len, 1))
    482. 

  482. 		   || !strncasecmp("FairShare", object, MAX(command_len, 2))) {
    483. 

  483. 		field->type = PRINT_FAIRSHARE;
    484. 

  484. 		field->name = xstrdup("Share");
    485. 

  485. 		field->len = 9;
    486. 

  486. 		field->print_routine = print_fields_uint;
    487. 

  487. 	} else if (!strncasecmp("TimeStamp", object, MAX(command_len, 1))) {
    488. 

  488. 		field->type = PRINT_TS;
    489. 

  489. 		field->name = xstrdup("Time");
    490. 

  490. 		field->len = 19;
    491. 

  491. 		field->print_routine = print_fields_date;
    492. 

  492. 	} else if (!strncasecmp("UsageFactor", object, MAX(command_len, 6))) {
    493. 

  493. 		field->type = PRINT_UF;
    494. 

  494. 		field->name = xstrdup("UsageFactor");
    495. 

  495. 		field->len = 11;
    496. 

  496. 		field->print_routine = print_fields_double;
    497. 

  497. 	} else if (!strncasecmp("UsageThreshold",
    498. 

  498. 				object, MAX(command_len, 6))) {
    499. 

  499. 		field->type = PRINT_UT;
    500. 

  500. 		field->name = xstrdup("UsageThres");
    501. 

  501. 		field->len = 10;
    502. 

  502. 		field->print_routine = print_fields_double;
    503. 

  503. 	} else if (!strncasecmp("User", object, MAX(command_len, 1))) {
    504. 

  504. 		field->type = PRINT_USER;
    505. 

  505. 		field->name = xstrdup("User");
    506. 

  506. 		field->len = 10;
    507. 

  507. 		field->print_routine = print_fields_str;
    508. 

  508. 	} else if (!strncasecmp("WCKeys", object, MAX(command_len, 2))) {
    509. 

  509. 		field->type = PRINT_WCKEYS;
    510. 

  510. 		field->name = xstrdup("WCKeys");
    511. 

  511. 		field->len = 20;
    512. 

  512. 		field->print_routine = print_fields_char_list;
    513. 

  513. 	} else if (!strncasecmp("Where", object, MAX(command_len, 2))) {
    514. 

  514. 		field->type = PRINT_WHERE;
    515. 

  515. 		field->name = xstrdup("Where");
    516. 

  516. 		field->len = 20;
    517. 

  517. 		field->print_routine = print_fields_str;
    518. 

  518. 	} else {
    519. 

  519. 		exit_code=1;
    520. 

  520. 		fprintf(stderr, "Unknown field '%s'\n", object);
    521. 

  521. 		exit(1);
    522. 

  522. 	}
    523. 

  523. 

  524. 	if (field_len)
    525. 

  525. 		field->len = field_len;
    526. 

  526. 	return field;
    527. 

  527. }
    528. 

  528. 

  529. extern int notice_thread_init()
    530. 

  530. {
    531. 

  531. 	pthread_attr_t attr;
    532. 

  532. 

  533. 	slurm_attr_init(&attr);
    534. 

  534. 	if (pthread_create(&lock_warning_thread, &attr,
    535. 

  535. 			   &_print_lock_warn, NULL))
    536. 

  536. 		error ("pthread_create error %m");
    537. 

  537. 	slurm_attr_destroy(&attr);
    538. 

  538. 	return SLURM_SUCCESS;
    539. 

  539. }
    540. 

  540. 

  541. extern int notice_thread_fini()
    542. 

  542. {
    543. 

  543. 	return pthread_cancel(lock_warning_thread);
    544. 

  544. }
    545. 

  545. 

  546. extern int commit_check(char *warning)
    547. 

  547. {
    548. 

  548. 	int ans = 0;
    549. 

  549. 	char c = '\0';
    550. 

  550. 	int fd = fileno(stdin);
    551. 

  551. 	fd_set rfds;
    552. 

  552. 	struct timeval tv;
    553. 

  553. 

  554. 	if (!rollback_flag)
    555. 

  555. 		return 1;
    556. 

  556. 

  557. 	printf("%s (You have 30 seconds to decide)\n", warning);
    558. 

  558. 	_nonblock(1);
    559. 

  559. 	while(c != 'Y' && c != 'y'
    560. 

  560. 	      && c != 'N' && c != 'n'
    561. 

  561. 	      && c != '\n') {
    562. 

  562. 		if (c) {
    563. 

  563. 			printf("Y or N please\n");
    564. 

  564. 		}
    565. 

  565. 		printf("(N/y): ");
    566. 

  566. 		fflush(stdout);
    567. 

  567. 		FD_ZERO(&rfds);
    568. 

  568. 		FD_SET(fd, &rfds);
    569. 

  569. 		/* Wait up to 30 seconds. */
    570. 

  570. 		tv.tv_sec = 30;
    571. 

  571. 		tv.tv_usec = 0;
    572. 

  572. 		if ((ans = select(fd+1, &rfds, NULL, NULL, &tv)) <= 0)
    573. 

  573. 			break;
    574. 

  574. 

  575. 		c = getchar();
    576. 

  576. 		printf("\n");
    577. 

  577. 	}
    578. 

  578. 	_nonblock(0);
    579. 

  579. 	if (ans <= 0)
    580. 

  580. 		printf("timeout\n");
    581. 

  581. 	else if (c == 'Y' || c == 'y')
    582. 

  582. 		return 1;
    583. 

  583. 

  584. 	return 0;
    585. 

  585. }
    586. 

  586. 

  587. extern int sacctmgr_remove_assoc_usage(slurmdb_association_cond_t *assoc_cond)
    588. 

  588. {
    589. 

  589. 	List update_list = NULL;
    590. 

  590. 	List local_assoc_list = NULL;
    591. 

  591. 	List local_cluster_list = NULL;
    592. 

  592. 	ListIterator itr = NULL;
    593. 

  593. 	ListIterator itr2 = NULL;
    594. 

  594. 	ListIterator itr3 = NULL;
    595. 

  595. 	char *account = NULL;
    596. 

  596. 	char *cluster = NULL;
    597. 

  597. 	char *user = NULL;
    598. 

  598. 	slurmdb_association_rec_t* rec = NULL;
    599. 

  599. 	slurmdb_cluster_rec_t* cluster_rec = NULL;
    600. 

  600. 	slurmdb_update_object_t* update_obj = NULL;
    601. 

  601. 	slurmdb_cluster_cond_t cluster_cond;
    602. 

  602. 	int rc = SLURM_SUCCESS;
    603. 

  603. 

  604. 	if (!assoc_cond->cluster_list)
    605. 

  605. 		assoc_cond->cluster_list = list_create(slurm_destroy_char);
    606. 

  606. 

  607. 	if (!list_count(assoc_cond->cluster_list)) {
    608. 

  608. 		char *temp = slurm_get_cluster_name();
    609. 

  609. 		if (temp) {
    610. 

  610. 			printf("No cluster specified, resetting "
    611. 

  611. 			       "on local cluster %s\n", temp);
    612. 

  612. 			list_append(assoc_cond->cluster_list, temp);
    613. 

  613. 		}
    614. 

  614. 		if (!list_count(assoc_cond->cluster_list)) {
    615. 

  615. 			error("A cluster name is required to remove usage");
    616. 

  616. 			return SLURM_ERROR;
    617. 

  617. 		}
    618. 

  618. 	}
    619. 

  619. 

  620. 	if(!commit_check("Would you like to reset usage?")) {
    621. 

  621. 		printf(" Changes Discarded\n");
    622. 

  622. 		return rc;
    623. 

  623. 	}
    624. 

  624. 

  625. 	local_assoc_list = acct_storage_g_get_associations(
    626. 

  626. 		db_conn, my_uid, assoc_cond);
    627. 

  627. 

  628. 	slurmdb_init_cluster_cond(&cluster_cond, 0);
    629. 

  629. 	cluster_cond.cluster_list = assoc_cond->cluster_list;
    630. 

  630. 	local_cluster_list = acct_storage_g_get_clusters(
    631. 

  631. 		db_conn, my_uid, &cluster_cond);
    632. 

  632. 

  633. 	itr = list_iterator_create(assoc_cond->cluster_list);
    634. 

  634. 	itr2 = list_iterator_create(assoc_cond->acct_list);
    635. 

  635. 	if (assoc_cond->user_list && list_count(assoc_cond->user_list))
    636. 

  636. 		itr3 = list_iterator_create(assoc_cond->user_list);
    637. 

  637. 	while((cluster = list_next(itr))) {
    638. 

  638. 		cluster_rec = sacctmgr_find_cluster_from_list(
    639. 

  639. 			local_cluster_list, cluster);
    640. 

  640. 		if (!cluster_rec) {
    641. 

  641. 			error("Failed to find cluster %s in database",
    642. 

  642. 			      cluster);
    643. 

  643. 			rc = SLURM_ERROR;
    644. 

  644. 			goto end_it;
    645. 

  645. 		}
    646. 

  646. 

  647. 		update_list = list_create(slurmdb_destroy_update_object);
    648. 

  648. 		update_obj = xmalloc(sizeof(slurmdb_update_object_t));
    649. 

  649. 		update_obj->type = SLURMDB_REMOVE_ASSOC_USAGE;
    650. 

  650. 		update_obj->objects = list_create(NULL);
    651. 

  651. 

  652. 		if (itr3) {
    653. 

  653. 			while ((user = list_next(itr3))) {
    654. 

  654. 				while ((account = list_next(itr2))) {
    655. 

  655. 					rec = sacctmgr_find_association_from_list(
    656. 

  656. 						local_assoc_list,
    657. 

  657. 						user, account, cluster, "*");
    658. 

  658. 					if (!rec) {
    659. 

  659. 						error("Failed to find "
    660. 

  660. 						      "cluster %s "
    661. 

  661. 						      "account %s user "
    662. 

  662. 						      "%s association "
    663. 

  663. 						      "in database",
    664. 

  664. 						      cluster, account,
    665. 

  665. 						      user);
    666. 

  666. 						rc = SLURM_ERROR;
    667. 

  667. 						goto end_it;
    668. 

  668. 					}
    669. 

  669. 					list_append(update_obj->objects, rec);
    670. 

  670. 				}
    671. 

  671. 				list_iterator_reset(itr2);
    672. 

  672. 			}
    673. 

  673. 			list_iterator_reset(itr3);
    674. 

  674. 		} else {
    675. 

  675. 			while ((account = list_next(itr2))) {
    676. 

  676. 				rec = sacctmgr_find_association_from_list(
    677. 

  677. 					local_assoc_list,
    678. 

  678. 					NULL, account, cluster, "*");
    679. 

  679. 				if (!rec) {
    680. 

  680. 					error("Failed to find cluster %s "
    681. 

  681. 					      "account %s association in "
    682. 

  682. 					      "database",
    683. 

  683. 					      cluster, account);
    684. 

  684. 					rc = SLURM_ERROR;
    685. 

  685. 					goto end_it;
    686. 

  686. 				}
    687. 

  687. 				list_append(update_obj->objects, rec);
    688. 

  688. 			}
    689. 

  689. 			list_iterator_reset(itr2);
    690. 

  690. 		}
    691. 

  691. 

  692. 		if (list_count(update_obj->objects)) {
    693. 

  693. 			list_append(update_list, update_obj);
    694. 

  694. 			rc = slurmdb_send_accounting_update(
    695. 

  695. 				update_list, cluster,
    696. 

  696. 				cluster_rec->control_host,
    697. 

  697. 				cluster_rec->control_port,
    698. 

  698. 				cluster_rec->rpc_version);
    699. 

  699. 		}
    700. 

  700. 		list_destroy(update_list);
    701. 

  701. 	}
    702. 

  702. end_it:
    703. 

  703. 	list_iterator_destroy(itr);
    704. 

  704. 	list_iterator_destroy(itr2);
    705. 

  705. 	if (itr3)
    706. 

  706. 		list_iterator_destroy(itr3);
    707. 

  707. 

  708. 	list_destroy(local_assoc_list);
    709. 

  709. 	list_destroy(local_cluster_list);
    710. 

  710. 

  711. 	return rc;
    712. 

  712. }
    713. 

  713. 

  714. extern slurmdb_association_rec_t *sacctmgr_find_account_base_assoc(
    715. 

  715. 	char *account, char *cluster)
    716. 

  716. {
    717. 

  717. 	slurmdb_association_rec_t *assoc = NULL;
    718. 

  718. 	char *temp = "root";
    719. 

  719. 	slurmdb_association_cond_t assoc_cond;
    720. 

  720. 	List assoc_list = NULL;
    721. 

  721. 

  722. 	if (!cluster)
    723. 

  723. 		return NULL;
    724. 

  724. 

  725. 	if (account)
    726. 

  726. 		temp = account;
    727. 

  727. 

  728. 	memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
    729. 

  729. 	assoc_cond.acct_list = list_create(NULL);
    730. 

  730. 	list_append(assoc_cond.cluster_list, temp);
    731. 

  731. 	assoc_cond.cluster_list = list_create(NULL);
    732. 

  732. 	list_append(assoc_cond.cluster_list, cluster);
    733. 

  733. 	assoc_cond.user_list = list_create(NULL);
    734. 

  734. 	list_append(assoc_cond.user_list, "");
    735. 

  735. 

  736. 	assoc_list = acct_storage_g_get_associations(db_conn, my_uid,
    737. 

  737. 						     &assoc_cond);
    738. 

  738. 

  739. 	list_destroy(assoc_cond.acct_list);
    740. 

  740. 	list_destroy(assoc_cond.cluster_list);
    741. 

  741. 	list_destroy(assoc_cond.user_list);
    742. 

  742. 

  743. 	if (assoc_list)
    744. 

  744. 		assoc = list_pop(assoc_list);
    745. 

  745. 

  746. 	list_destroy(assoc_list);
    747. 

  747. 

  748. 	return assoc;
    749. 

  749. }
    750. 

  750. 

  751. extern slurmdb_association_rec_t *sacctmgr_find_root_assoc(char *cluster)
    752. 

  752. {
    753. 

  753. 	return sacctmgr_find_account_base_assoc(NULL, cluster);
    754. 

  754. }
    755. 

  755. 

  756. extern slurmdb_user_rec_t *sacctmgr_find_user(char *name)
    757. 

  757. {
    758. 

  758. 	slurmdb_user_rec_t *user = NULL;
    759. 

  759. 	slurmdb_user_cond_t user_cond;
    760. 

  760. 	slurmdb_association_cond_t assoc_cond;
    761. 

  761. 	List user_list = NULL;
    762. 

  762. 

  763. 	if (!name)
    764. 

  764. 		return NULL;
    765. 

  765. 

  766. 	memset(&user_cond, 0, sizeof(slurmdb_user_cond_t));
    767. 

  767. 	memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
    768. 

  768. 	assoc_cond.user_list = list_create(NULL);
    769. 

  769. 	list_append(assoc_cond.user_list, name);
    770. 

  770. 	user_cond.assoc_cond = &assoc_cond;
    771. 

  771. 

  772. 	user_list = acct_storage_g_get_users(db_conn, my_uid,
    773. 

  773. 					     &user_cond);
    774. 

  774. 

  775. 	list_destroy(assoc_cond.user_list);
    776. 

  776. 

  777. 	if (user_list)
    778. 

  778. 		user = list_pop(user_list);
    779. 

  779. 

  780. 	list_destroy(user_list);
    781. 

  781. 

  782. 	return user;
    783. 

  783. }
    784. 

  784. 

  785. extern slurmdb_account_rec_t *sacctmgr_find_account(char *name)
    786. 

  786. {
    787. 

  787. 	slurmdb_account_rec_t *account = NULL;
    788. 

  788. 	slurmdb_account_cond_t account_cond;
    789. 

  789. 	slurmdb_association_cond_t assoc_cond;
    790. 

  790. 	List account_list = NULL;
    791. 

  791. 

  792. 	if (!name)
    793. 

  793. 		return NULL;
    794. 

  794. 

  795. 	memset(&account_cond, 0, sizeof(slurmdb_account_cond_t));
    796. 

  796. 	memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
    797. 

  797. 	assoc_cond.acct_list = list_create(NULL);
    798. 

  798. 	list_append(assoc_cond.acct_list, name);
    799. 

  799. 	account_cond.assoc_cond = &assoc_cond;
    800. 

  800. 

  801. 	account_list = acct_storage_g_get_accounts(db_conn, my_uid,
    802. 

  802. 						   &account_cond);
    803. 

  803. 

  804. 	list_destroy(assoc_cond.acct_list);
    805. 

  805. 

  806. 	if (account_list)
    807. 

  807. 		account = list_pop(account_list);
    808. 

  808. 

  809. 	list_destroy(account_list);
    810. 

  810. 

  811. 	return account;
    812. 

  812. }
    813. 

  813. 

  814. extern slurmdb_cluster_rec_t *sacctmgr_find_cluster(char *name)
    815. 

  815. {
    816. 

  816. 	slurmdb_cluster_rec_t *cluster = NULL;
    817. 

  817. 	slurmdb_cluster_cond_t cluster_cond;
    818. 

  818. 	List cluster_list = NULL;
    819. 

  819. 

  820. 	if (!name)
    821. 

  821. 		return NULL;
    822. 

  822. 

  823. 	slurmdb_init_cluster_cond(&cluster_cond, 0);
    824. 

  824. 	cluster_cond.cluster_list = list_create(NULL);
    825. 

  825. 	list_append(cluster_cond.cluster_list, name);
    826. 

  826. 

  827. 	cluster_list = acct_storage_g_get_clusters(db_conn, my_uid,
    828. 

  828. 						   &cluster_cond);
    829. 

  829. 

  830. 	list_destroy(cluster_cond.cluster_list);
    831. 

  831. 

  832. 	if (cluster_list)
    833. 

  833. 		cluster = list_pop(cluster_list);
    834. 

  834. 

  835. 	list_destroy(cluster_list);
    836. 

  836. 

  837. 	return cluster;
    838. 

  838. }
    839. 

  839. 

  840. extern slurmdb_association_rec_t *sacctmgr_find_association_from_list(
    841. 

  841. 	List assoc_list, char *user, char *account,
    842. 

  842. 	char *cluster, char *partition)
    843. 

  843. {
    844. 

  844. 	ListIterator itr = NULL;
    845. 

  845. 	slurmdb_association_rec_t * assoc = NULL;
    846. 

  846. 

  847. 	if (!assoc_list)
    848. 

  848. 		return NULL;
    849. 

  849. 

  850. 	itr = list_iterator_create(assoc_list);
    851. 

  851. 	while((assoc = list_next(itr))) {
    852. 

  852. 		if (((!user && assoc->user)
    853. 

  853. 		     || (user && (!assoc->user
    854. 

  854. 				  || strcasecmp(user, assoc->user))))
    855. 

  855. 		    || (account && (!assoc->acct
    856. 

  856. 				    || strcasecmp(account, assoc->acct)))
    857. 

  857. 		    || ((!cluster && assoc->cluster)
    858. 

  858. 			|| (cluster && (!assoc->cluster
    859. 

  859. 					|| strcasecmp(cluster,
    860. 

  860. 						      assoc->cluster)))))
    861. 

  861. 			continue;
    862. 

  862. 		else if (partition) {
    863. 

  863. 			if (partition[0] != '*'
    864. 

  864. 			    && (!assoc->partition
    865. 

  865. 				|| strcasecmp(partition, assoc->partition)))
    866. 

  866. 				continue;
    867. 

  867. 		} else if (assoc->partition)
    868. 

  868. 			continue;
    869. 

  869. 

  870. 		break;
    871. 

  871. 	}
    872. 

  872. 	list_iterator_destroy(itr);
    873. 

  873. 

  874. 	return assoc;
    875. 

  875. }
    876. 

  876. 

  877. extern slurmdb_association_rec_t *sacctmgr_find_account_base_assoc_from_list(
    878. 

  878. 	List assoc_list, char *account, char *cluster)
    879. 

  879. {
    880. 

  880. 	ListIterator itr = NULL;
    881. 

  881. 	slurmdb_association_rec_t *assoc = NULL;
    882. 

  882. 	char *temp = "root";
    883. 

  883. 

  884. 	if (!cluster || !assoc_list)
    885. 

  885. 		return NULL;
    886. 

  886. 

  887. 	if (account)
    888. 

  888. 		temp = account;
    889. 

  889. 	/* info("looking for %s %s in %d", account, cluster, */
    890. 

  890. /* 	     list_count(assoc_list)); */
    891. 

  891. 	itr = list_iterator_create(assoc_list);
    892. 

  892. 	while((assoc = list_next(itr))) {
    893. 

  893. 		/* info("is it %s %s %s", assoc->user, assoc->acct, assoc->cluster); */
    894. 

  894. 		if (assoc->user
    895. 

  895. 		    || strcasecmp(temp, assoc->acct)
    896. 

  896. 		    || strcasecmp(cluster, assoc->cluster))
    897. 

  897. 			continue;
    898. 

  898. 		/* 	info("found it"); */
    899. 

  899. 		break;
    900. 

  900. 	}
    901. 

  901. 	list_iterator_destroy(itr);
    902. 

  902. 

  903. 	return assoc;
    904. 

  904. }
    905. 

  905. 

  906. extern slurmdb_qos_rec_t *sacctmgr_find_qos_from_list(
    907. 

  907. 	List qos_list, char *name)
    908. 

  908. {
    909. 

  909. 	ListIterator itr = NULL;
    910. 

  910. 	slurmdb_qos_rec_t *qos = NULL;
    911. 

  911. 	char *working_name = NULL;
    912. 

  912. 

  913. 	if (!name || !qos_list)
    914. 

  914. 		return NULL;
    915. 

  915. 

  916. 	if (name[0] == '+' || name[0] == '-')
    917. 

  917. 		working_name = name+1;
    918. 

  918. 	else
    919. 

  919. 		working_name = name;
    920. 

  920. 

  921. 	itr = list_iterator_create(qos_list);
    922. 

  922. 	while((qos = list_next(itr))) {
    923. 

  923. 		if (!strcasecmp(working_name, qos->name))
    924. 

  924. 			break;
    925. 

  925. 	}
    926. 

  926. 	list_iterator_destroy(itr);
    927. 

  927. 

  928. 	return qos;
    929. 

  929. 

  930. }
    931. 

  931. 

  932. extern slurmdb_user_rec_t *sacctmgr_find_user_from_list(
    933. 

  933. 	List user_list, char *name)
    934. 

  934. {
    935. 

  935. 	ListIterator itr = NULL;
    936. 

  936. 	slurmdb_user_rec_t *user = NULL;
    937. 

  937. 

  938. 	if (!name || !user_list)
    939. 

  939. 		return NULL;
    940. 

  940. 

  941. 	itr = list_iterator_create(user_list);
    942. 

  942. 	while((user = list_next(itr))) {
    943. 

  943. 		if (!strcasecmp(name, user->name))
    944. 

  944. 			break;
    945. 

  945. 	}
    946. 

  946. 	list_iterator_destroy(itr);
    947. 

  947. 

  948. 	return user;
    949. 

  949. 

  950. }
    951. 

  951. 

  952. extern slurmdb_account_rec_t *sacctmgr_find_account_from_list(
    953. 

  953. 	List acct_list, char *name)
    954. 

  954. {
    955. 

  955. 	ListIterator itr = NULL;
    956. 

  956. 	slurmdb_account_rec_t *account = NULL;
    957. 

  957. 

  958. 	if (!name || !acct_list)
    959. 

  959. 		return NULL;
    960. 

  960. 

  961. 	itr = list_iterator_create(acct_list);
    962. 

  962. 	while((account = list_next(itr))) {
    963. 

  963. 		if (!strcasecmp(name, account->name))
    964. 

  964. 			break;
    965. 

  965. 	}
    966. 

  966. 	list_iterator_destroy(itr);
    967. 

  967. 

  968. 	return account;
    969. 

  969. 

  970. }
    971. 

  971. 

  972. extern slurmdb_cluster_rec_t *sacctmgr_find_cluster_from_list(
    973. 

  973. 	List cluster_list, char *name)
    974. 

  974. {
    975. 

  975. 	ListIterator itr = NULL;
    976. 

  976. 	slurmdb_cluster_rec_t *cluster = NULL;
    977. 

  977. 

  978. 	if (!name || !cluster_list)
    979. 

  979. 		return NULL;
    980. 

  980. 

  981. 	itr = list_iterator_create(cluster_list);
    982. 

  982. 	while((cluster = list_next(itr))) {
    983. 

  983. 		if (!strcasecmp(name, cluster->name))
    984. 

  984. 			break;
    985. 

  985. 	}
    986. 

  986. 	list_iterator_destroy(itr);
    987. 

  987. 

  988. 	return cluster;
    989. 

  989. }
    990. 

  990. 

  991. extern slurmdb_wckey_rec_t *sacctmgr_find_wckey_from_list(
    992. 

  992. 	List wckey_list, char *user, char *name, char *cluster)
    993. 

  993. {
    994. 

  994. 	ListIterator itr = NULL;
    995. 

  995. 	slurmdb_wckey_rec_t * wckey = NULL;
    996. 

  996. 

  997. 	if (!wckey_list)
    998. 

  998. 		return NULL;
    999. 

  999. 

  1000. 	itr = list_iterator_create(wckey_list);
    1001. 

  1001. 	while((wckey = list_next(itr))) {
    1002. 

  1002. 		if (((!user && wckey->user)
    1003. 

  1003. 		     || (user && (!wckey->user
    1004. 

  1004. 				  || strcasecmp(user, wckey->user))))
    1005. 

  1005. 		    || (name && (!wckey->name
    1006. 

  1006. 				 || strcasecmp(name, wckey->name)))
    1007. 

  1007. 		    || ((!cluster && wckey->cluster)
    1008. 

  1008. 			|| (cluster && (!wckey->cluster
    1009. 

  1009. 					|| strcasecmp(cluster,
    1010. 

  1010. 						      wckey->cluster)))))
    1011. 

  1011. 			continue;
    1012. 

  1012. 		break;
    1013. 

  1013. 	}
    1014. 

  1014. 	list_iterator_destroy(itr);
    1015. 

  1015. 

  1016. 	return wckey;
    1017. 

  1017. }
    1018. 

  1018. 

  1019. extern int get_uint(char *in_value, uint32_t *out_value, char *type)
    1020. 

  1020. {
    1021. 

  1021. 	char *ptr = NULL, *meat = NULL;
    1022. 

  1022. 	long num;
    1023. 

  1023. 

  1024. 	if (!(meat = strip_quotes(in_value, NULL, 1))) {
    1025. 

  1025. 		error("Problem with strip_quotes");
    1026. 

  1026. 		return SLURM_ERROR;
    1027. 

  1027. 	}
    1028. 

  1028. 	num = strtol(meat, &ptr, 10);
    1029. 

  1029. 	if ((num == 0) && ptr && ptr[0]) {
    1030. 

  1030. 		error("Invalid value for %s (%s)", type, meat);
    1031. 

  1031. 		xfree(meat);
    1032. 

  1032. 		return SLURM_ERROR;
    1033. 

  1033. 	}
    1034. 

  1034. 	xfree(meat);
    1035. 

  1035. 

  1036. 	if (num < 0)
    1037. 

  1037. 		*out_value = INFINITE;		/* flag to clear */
    1038. 

  1038. 	else
    1039. 

  1039. 		*out_value = (uint32_t) num;
    1040. 

  1040. 	return SLURM_SUCCESS;
    1041. 

  1041. }
    1042. 

  1042. 

  1043. extern int get_uint16(char *in_value, uint16_t *out_value, char *type)
    1044. 

  1044. {
    1045. 

  1045. 	char *ptr = NULL, *meat = NULL;
    1046. 

  1046. 	long num;
    1047. 

  1047. 

  1048. 	if (!(meat = strip_quotes(in_value, NULL, 1))) {
    1049. 

  1049. 		error("Problem with strip_quotes");
    1050. 

  1050. 		return SLURM_ERROR;
    1051. 

  1051. 	}
    1052. 

  1052. 

  1053. 	num = strtol(meat, &ptr, 10);
    1054. 

  1054. 	if ((num == 0) && ptr && ptr[0]) {
    1055. 

  1055. 		error("Invalid value for %s (%s)", type, meat);
    1056. 

  1056. 		xfree(meat);
    1057. 

  1057. 		return SLURM_ERROR;
    1058. 

  1058. 	}
    1059. 

  1059. 	xfree(meat);
    1060. 

  1060. 

  1061. 	if (num < 0)
    1062. 

  1062. 		*out_value = (uint16_t) INFINITE; /* flag to clear */
    1063. 

  1063. 	else
    1064. 

  1064. 		*out_value = (uint16_t) num;
    1065. 

  1065. 	return SLURM_SUCCESS;
    1066. 

  1066. }
    1067. 

  1067. 

  1068. extern int get_uint64(char *in_value, uint64_t *out_value, char *type)
    1069. 

  1069. {
    1070. 

  1070. 	char *ptr = NULL, *meat = NULL;
    1071. 

  1071. 	long long num;
    1072. 

  1072. 

  1073. 	if (!(meat = strip_quotes(in_value, NULL, 1))) {
    1074. 

  1074. 		error("Problem with strip_quotes");
    1075. 

  1075. 		return SLURM_ERROR;
    1076. 

  1076. 	}
    1077. 

  1077. 

  1078. 	num = strtoll(meat, &ptr, 10);
    1079. 

  1079. 	if ((num == 0) && ptr && ptr[0]) {
    1080. 

  1080. 		error("Invalid value for %s (%s)", type, meat);
    1081. 

  1081. 		xfree(meat);
    1082. 

  1082. 		return SLURM_ERROR;
    1083. 

  1083. 	}
    1084. 

  1084. 	xfree(meat);
    1085. 

  1085. 

  1086. 	if (num < 0)
    1087. 

  1087. 		*out_value = INFINITE;		/* flag to clear */
    1088. 

  1088. 	else
    1089. 

  1089. 		*out_value = (uint64_t) num;
    1090. 

  1090. 	return SLURM_SUCCESS;
    1091. 

  1091. }
    1092. 

  1092. 

  1093. extern int get_double(char *in_value, double *out_value, char *type)
    1094. 

  1094. {
    1095. 

  1095. 	char *ptr = NULL, *meat = NULL;
    1096. 

  1096. 	double num;
    1097. 

  1097. 

  1098. 	if (!(meat = strip_quotes(in_value, NULL, 1))) {
    1099. 

  1099. 		error("Problem with strip_quotes");
    1100. 

  1100. 		return SLURM_ERROR;
    1101. 

  1101. 	}
    1102. 

  1102. 	num = strtod(meat, &ptr);
    1103. 

  1103. 	if ((num == 0) && ptr && ptr[0]) {
    1104. 

  1104. 		error("Invalid value for %s (%s)", type, meat);
    1105. 

  1105. 		xfree(meat);
    1106. 

  1106. 		return SLURM_ERROR;
    1107. 

  1107. 	}
    1108. 

  1108. 	xfree(meat);
    1109. 

  1109. 

  1110. 	if (num < 0)
    1111. 

  1111. 		*out_value = (double) INFINITE;		/* flag to clear */
    1112. 

  1112. 	else
    1113. 

  1113. 		*out_value = (double) num;
    1114. 

  1114. 	return SLURM_SUCCESS;
    1115. 

  1115. }
    1116. 

  1116. 

  1117. extern int addto_action_char_list(List char_list, char *names)
    1118. 

  1118. {
    1119. 

  1119. 	int i=0, start=0;
    1120. 

  1120. 	char *name = NULL, *tmp_char = NULL;
    1121. 

  1121. 	ListIterator itr = NULL;
    1122. 

  1122. 	char quote_c = '\0';
    1123. 

  1123. 	int quote = 0;
    1124. 

  1124. 	uint32_t id=0;
    1125. 

  1125. 	int count = 0;
    1126. 

  1126. 

  1127. 	if (!char_list) {
    1128. 

  1128. 		error("No list was given to fill in");
    1129. 

  1129. 		return 0;
    1130. 

  1130. 	}
    1131. 

  1131. 

  1132. 	itr = list_iterator_create(char_list);
    1133. 

  1133. 	if (names) {
    1134. 

  1134. 		if (names[i] == '\"' || names[i] == '\'') {
    1135. 

  1135. 			quote_c = names[i];
    1136. 

  1136. 			quote = 1;
    1137. 

  1137. 			i++;
    1138. 

  1138. 		}
    1139. 

  1139. 		start = i;
    1140. 

  1140. 		while(names[i]) {
    1141. 

  1141. 			if (quote && names[i] == quote_c)
    1142. 

  1142. 				break;
    1143. 

  1143. 			else if (names[i] == '\"' || names[i] == '\'')
    1144. 

  1144. 				names[i] = '`';
    1145. 

  1145. 			else if (names[i] == ',') {
    1146. 

  1146. 				if ((i-start) > 0) {
    1147. 

  1147. 					name = xmalloc((i-start+1));
    1148. 

  1148. 					memcpy(name, names+start, (i-start));
    1149. 

  1149. 

  1150. 					id = str_2_slurmdbd_msg_type(name);
    1151. 

  1151. 					if (id == NO_VAL) {
    1152. 

  1152. 						error("You gave a bad action "
    1153. 

  1153. 						      "'%s'.", name);
    1154. 

  1154. 						xfree(name);
    1155. 

  1155. 						break;
    1156. 

  1156. 					}
    1157. 

  1157. 					xfree(name);
    1158. 

  1158. 

  1159. 					name = xstrdup_printf("%u", id);
    1160. 

  1160. 					while((tmp_char = list_next(itr))) {
    1161. 

  1161. 						if (!strcasecmp(tmp_char, name))
    1162. 

  1162. 							break;
    1163. 

  1163. 					}
    1164. 

  1164. 					list_iterator_reset(itr);
    1165. 

  1165. 

  1166. 					if (!tmp_char) {
    1167. 

  1167. 						list_append(char_list, name);
    1168. 

  1168. 						count++;
    1169. 

  1169. 					} else
    1170. 

  1170. 						xfree(name);
    1171. 

  1171. 				}
    1172. 

  1172. 

  1173. 				i++;
    1174. 

  1174. 				start = i;
    1175. 

  1175. 				if (!names[i]) {
    1176. 

  1176. 					error("There is a problem with "
    1177. 

  1177. 					      "your request.  It appears you "
    1178. 

  1178. 					      "have spaces inside your list.");
    1179. 

  1179. 					break;
    1180. 

  1180. 				}
    1181. 

  1181. 			}
    1182. 

  1182. 			i++;
    1183. 

  1183. 		}
    1184. 

  1184. 		if ((i-start) > 0) {
    1185. 

  1185. 			name = xmalloc((i-start)+1);
    1186. 

  1186. 			memcpy(name, names+start, (i-start));
    1187. 

  1187. 

  1188. 			id = str_2_slurmdbd_msg_type(name);
    1189. 

  1189. 			if (id == NO_VAL)  {
    1190. 

  1190. 				error("You gave a bad action '%s'.",
    1191. 

  1191. 				      name);
    1192. 

  1192. 				xfree(name);
    1193. 

  1193. 				goto end_it;
    1194. 

  1194. 			}
    1195. 

  1195. 			xfree(name);
    1196. 

  1196. 

  1197. 			name = xstrdup_printf("%u", id);
    1198. 

  1198. 			while((tmp_char = list_next(itr))) {
    1199. 

  1199. 				if (!strcasecmp(tmp_char, name))
    1200. 

  1200. 					break;
    1201. 

  1201. 			}
    1202. 

  1202. 

  1203. 			if (!tmp_char) {
    1204. 

  1204. 				list_append(char_list, name);
    1205. 

  1205. 				count++;
    1206. 

  1206. 			} else
    1207. 

  1207. 				xfree(name);
    1208. 

  1208. 		}
    1209. 

  1209. 	}
    1210. 

  1210. end_it:
    1211. 

  1211. 	list_iterator_destroy(itr);
    1212. 

  1212. 	return count;
    1213. 

  1213. }
    1214. 

  1214. 

  1215. extern List copy_char_list(List char_list)
    1216. 

  1216. {
    1217. 

  1217. 	List ret_list = NULL;
    1218. 

  1218. 	char *tmp_char = NULL;
    1219. 

  1219. 	ListIterator itr = NULL;
    1220. 

  1220. 

  1221. 	if (!char_list || !list_count(char_list))
    1222. 

  1222. 		return NULL;
    1223. 

  1223. 

  1224. 	itr = list_iterator_create(char_list);
    1225. 

  1225. 	ret_list = list_create(slurm_destroy_char);
    1226. 

  1226. 

  1227. 	while((tmp_char = list_next(itr)))
    1228. 

  1228. 		list_append(ret_list, xstrdup(tmp_char));
    1229. 

  1229. 

  1230. 	list_iterator_destroy(itr);
    1231. 

  1231. 

  1232. 	return ret_list;
    1233. 

  1233. }
    1234. 

  1234. 

  1235. extern void sacctmgr_print_coord_list(
    1236. 

  1236. 	print_field_t *field, List value, int last)
    1237. 

  1237. {
    1238. 

  1238. 	int abs_len = abs(field->len);
    1239. 

  1239. 	ListIterator itr = NULL;
    1240. 

  1240. 	char *print_this = NULL;
    1241. 

  1241. 	slurmdb_coord_rec_t *object = NULL;
    1242. 

  1242. 

  1243. 	if (!value || !list_count(value)) {
    1244. 

  1244. 		if (print_fields_parsable_print)
    1245. 

  1245. 			print_this = xstrdup("");
    1246. 

  1246. 		else
    1247. 

  1247. 			print_this = xstrdup(" ");
    1248. 

  1248. 	} else {
    1249. 

  1249. 		list_sort(value, (ListCmpF)sort_coord_list);
    1250. 

  1250. 		itr = list_iterator_create(value);
    1251. 

  1251. 		while((object = list_next(itr))) {
    1252. 

  1252. 			if (print_this)
    1253. 

  1253. 				xstrfmtcat(print_this, ",%s",
    1254. 

  1254. 					   object->name);
    1255. 

  1255. 			else
    1256. 

  1256. 				print_this = xstrdup(object->name);
    1257. 

  1257. 		}
    1258. 

  1258. 		list_iterator_destroy(itr);
    1259. 

  1259. 	}
    1260. 

  1260. 

  1261. 	if (print_fields_parsable_print == PRINT_FIELDS_PARSABLE_NO_ENDING
    1262. 

  1262. 	    && last)
    1263. 

  1263. 		printf("%s", print_this);
    1264. 

  1264. 	else if (print_fields_parsable_print)
    1265. 

  1265. 		printf("%s|", print_this);
    1266. 

  1266. 	else {
    1267. 

  1267. 		if (strlen(print_this) > abs_len)
    1268. 

  1268. 			print_this[abs_len-1] = '+';
    1269. 

  1269. 

  1270. 		if (field->len == abs_len)
    1271. 

  1271. 			printf("%*.*s ", abs_len, abs_len, print_this);
    1272. 

  1272. 		else
    1273. 

  1273. 			printf("%-*.*s ", abs_len, abs_len, print_this);
    1274. 

  1274. 	}
    1275. 

  1275. 	xfree(print_this);
    1276. 

  1276. }
    1277. 

  1277. 

  1278. extern void sacctmgr_print_qos_list(print_field_t *field, List qos_list,
    1279. 

  1279. 				    List value, int last)
    1280. 

  1280. {
    1281. 

  1281. 	int abs_len = abs(field->len);
    1282. 

  1282. 	char *print_this = NULL;
    1283. 

  1283. 

  1284. 	print_this = get_qos_complete_str(qos_list, value);
    1285. 

  1285. 

  1286. 	if (print_fields_parsable_print == PRINT_FIELDS_PARSABLE_NO_ENDING
    1287. 

  1287. 	    && last)
    1288. 

  1288. 		printf("%s", print_this);
    1289. 

  1289. 	else if (print_fields_parsable_print)
    1290. 

  1290. 		printf("%s|", print_this);
    1291. 

  1291. 	else {
    1292. 

  1292. 		if (strlen(print_this) > abs_len)
    1293. 

  1293. 			print_this[abs_len-1] = '+';
    1294. 

  1294. 

  1295. 		if (field->len == abs_len)
    1296. 

  1296. 			printf("%*.*s ", abs_len, abs_len, print_this);
    1297. 

  1297. 		else
    1298. 

  1298. 			printf("%-*.*s ", abs_len, abs_len, print_this);
    1299. 

  1299. 	}
    1300. 

  1300. 	xfree(print_this);
    1301. 

  1301. }
    1302. 

  1302. 

  1303. extern void sacctmgr_print_qos_bitstr(print_field_t *field, List qos_list,
    1304. 

  1304. 				      bitstr_t *value, int last)
    1305. 

  1305. {
    1306. 

  1306. 	int abs_len = abs(field->len);
    1307. 

  1307. 	char *print_this = NULL;
    1308. 

  1308. 

  1309. 	print_this = get_qos_complete_str_bitstr(qos_list, value);
    1310. 

  1310. 

  1311. 	if (print_fields_parsable_print == PRINT_FIELDS_PARSABLE_NO_ENDING
    1312. 

  1312. 	    && last)
    1313. 

  1313. 		printf("%s", print_this);
    1314. 

  1314. 	else if (print_fields_parsable_print)
    1315. 

  1315. 		printf("%s|", print_this);
    1316. 

  1316. 	else {
    1317. 

  1317. 		if (strlen(print_this) > abs_len)
    1318. 

  1318. 			print_this[abs_len-1] = '+';
    1319. 

  1319. 

  1320. 		if (field->len == abs_len)
    1321. 

  1321. 			printf("%*.*s ", abs_len, abs_len, print_this);
    1322. 

  1322. 		else
    1323. 

  1323. 			printf("%-*.*s ", abs_len, abs_len, print_this);
    1324. 

  1324. 	}
    1325. 

  1325. 	xfree(print_this);
    1326. 

  1326. }
    1327. 

  1327. 

  1328. extern void sacctmgr_print_assoc_limits(slurmdb_association_rec_t *assoc)
    1329. 

  1329. {
    1330. 

  1330. 	if (!assoc)
    1331. 

  1331. 		return;
    1332. 

  1332. 

  1333. 	if (assoc->shares_raw == INFINITE)
    1334. 

  1334. 		printf("  Fairshare     = NONE\n");
    1335. 

  1335. 	else if (assoc->shares_raw != NO_VAL)
    1336. 

  1336. 		printf("  Fairshare     = %u\n", assoc->shares_raw);
    1337. 

  1337. 

  1338. 	if (assoc->grp_cpu_mins == INFINITE)
    1339. 

  1339. 		printf("  GrpCPUMins    = NONE\n");
    1340. 

  1340. 	else if (assoc->grp_cpu_mins != NO_VAL)
    1341. 

  1341. 		printf("  GrpCPUMins    = %"PRIu64"\n",
    1342. 

  1342. 		       assoc->grp_cpu_mins);
    1343. 

  1343. 

  1344. 	if (assoc->grp_cpus == INFINITE)
    1345. 

  1345. 		printf("  GrpCPUs       = NONE\n");
    1346. 

  1346. 	else if (assoc->grp_cpus != NO_VAL)
    1347. 

  1347. 		printf("  GrpCPUs       = %u\n", assoc->grp_cpus);
    1348. 

  1348. 

  1349. 	if (assoc->grp_jobs == INFINITE)
    1350. 

  1350. 		printf("  GrpJobs       = NONE\n");
    1351. 

  1351. 	else if (assoc->grp_jobs != NO_VAL)
    1352. 

  1352. 		printf("  GrpJobs       = %u\n", assoc->grp_jobs);
    1353. 

  1353. 

  1354. 	if (assoc->grp_mem == INFINITE)
    1355. 

  1355. 		printf("  GrpMemory     = NONE\n");
    1356. 

  1356. 	else if (assoc->grp_mem != NO_VAL)
    1357. 

  1357. 		printf("  GrpMemory     = %u\n", assoc->grp_mem);
    1358. 

  1358. 

  1359. 	if (assoc->grp_nodes == INFINITE)
    1360. 

  1360. 		printf("  GrpNodes      = NONE\n");
    1361. 

  1361. 	else if (assoc->grp_nodes != NO_VAL)
    1362. 

  1362. 		printf("  GrpNodes      = %u\n", assoc->grp_nodes);
    1363. 

  1363. 

  1364. 	if (assoc->grp_submit_jobs == INFINITE)
    1365. 

  1365. 		printf("  GrpSubmitJobs = NONE\n");
    1366. 

  1366. 	else if (assoc->grp_submit_jobs != NO_VAL)
    1367. 

  1367. 		printf("  GrpSubmitJobs = %u\n",
    1368. 

  1368. 		       assoc->grp_submit_jobs);
    1369. 

  1369. 

  1370. 	if (assoc->grp_wall == INFINITE)
    1371. 

  1371. 		printf("  GrpWall       = NONE\n");
    1372. 

  1372. 	else if (assoc->grp_wall != NO_VAL) {
    1373. 

  1373. 		char time_buf[32];
    1374. 

  1374. 		mins2time_str((time_t) assoc->grp_wall,
    1375. 

  1375. 			      time_buf, sizeof(time_buf));
    1376. 

  1376. 		printf("  GrpWall       = %s\n", time_buf);
    1377. 

  1377. 	}
    1378. 

  1378. 

  1379. 	if (assoc->max_cpu_mins_pj == (uint64_t)INFINITE)
    1380. 

  1380. 		printf("  MaxCPUMins    = NONE\n");
    1381. 

  1381. 	else if (assoc->max_cpu_mins_pj != (uint64_t)NO_VAL)
    1382. 

  1382. 		printf("  MaxCPUMins    = %"PRIu64"\n",
    1383. 

  1383. 		       assoc->max_cpu_mins_pj);
    1384. 

  1384. 

  1385. 	if (assoc->max_cpus_pj == INFINITE)
    1386. 

  1386. 		printf("  MaxCPUs       = NONE\n");
    1387. 

  1387. 	else if (assoc->max_cpus_pj != NO_VAL)
    1388. 

  1388. 		printf("  MaxCPUs       = %u\n", assoc->max_cpus_pj);
    1389. 

  1389. 

  1390. 	if (assoc->max_jobs == INFINITE)
    1391. 

  1391. 		printf("  MaxJobs       = NONE\n");
    1392. 

  1392. 	else if (assoc->max_jobs != NO_VAL)
    1393. 

  1393. 		printf("  MaxJobs       = %u\n", assoc->max_jobs);
    1394. 

  1394. 

  1395. 	if (assoc->max_nodes_pj == INFINITE)
    1396. 

  1396. 		printf("  MaxNodes      = NONE\n");
    1397. 

  1397. 	else if (assoc->max_nodes_pj != NO_VAL)
    1398. 

  1398. 		printf("  MaxNodes      = %u\n", assoc->max_nodes_pj);
    1399. 

  1399. 

  1400. 	if (assoc->max_submit_jobs == INFINITE)
    1401. 

  1401. 		printf("  MaxSubmitJobs = NONE\n");
    1402. 

  1402. 	else if (assoc->max_submit_jobs != NO_VAL)
    1403. 

  1403. 		printf("  MaxSubmitJobs = %u\n",
    1404. 

  1404. 		       assoc->max_submit_jobs);
    1405. 

  1405. 

  1406. 	if (assoc->max_wall_pj == INFINITE)
    1407. 

  1407. 		printf("  MaxWall       = NONE\n");
    1408. 

  1408. 	else if (assoc->max_wall_pj != NO_VAL) {
    1409. 

  1409. 		char time_buf[32];
    1410. 

  1410. 		mins2time_str((time_t) assoc->max_wall_pj,
    1411. 

  1411. 			      time_buf, sizeof(time_buf));
    1412. 

  1412. 		printf("  MaxWall       = %s\n", time_buf);
    1413. 

  1413. 	}
    1414. 

  1414. 

  1415. 	if (assoc->qos_list) {
    1416. 

  1416. 		if (!g_qos_list)
    1417. 

  1417. 			g_qos_list =
    1418. 

  1418. 				acct_storage_g_get_qos(db_conn, my_uid, NULL);
    1419. 

  1419. 		char *temp_char = get_qos_complete_str(g_qos_list,
    1420. 

  1420. 						       assoc->qos_list);
    1421. 

  1421. 		if (temp_char) {
    1422. 

  1422. 			printf("  QOS           = %s\n", temp_char);
    1423. 

  1423. 			xfree(temp_char);
    1424. 

  1424. 		}
    1425. 

  1425. 	}
    1426. 

  1426. }
    1427. 

  1427. 

  1428. extern void sacctmgr_print_qos_limits(slurmdb_qos_rec_t *qos)
    1429. 

  1429. {
    1430. 

  1430. 	if (!qos)
    1431. 

  1431. 		return;
    1432. 

  1432. 

  1433. 	if (qos->preempt_list && !g_qos_list)
    1434. 

  1434. 		g_qos_list = acct_storage_g_get_qos(db_conn, my_uid, NULL);
    1435. 

  1435. 

  1436. 	if (qos->grace_time != NO_VAL)
    1437. 

  1437. 		printf("  GraceTime       = %d\n", qos->grace_time);
    1438. 

  1438. 	else
    1439. 

  1439. 		printf("  GraceTime       = NONE\n");
    1440. 

  1440. 

  1441. 	if (qos->grp_cpu_mins == INFINITE)
    1442. 

  1442. 		printf("  GrpCPUMins     = NONE\n");
    1443. 

  1443. 	else if (qos->grp_cpu_mins != NO_VAL)
    1444. 

  1444. 		printf("  GrpCPUMins     = %"PRIu64"\n",
    1445. 

  1445. 		       qos->grp_cpu_mins);
    1446. 

  1446. 

  1447. 	if (qos->grp_cpus == INFINITE)
    1448. 

  1448. 		printf("  GrpCPUs        = NONE\n");
    1449. 

  1449. 	else if (qos->grp_cpus != NO_VAL)
    1450. 

  1450. 		printf("  GrpCPUs        = %u\n", qos->grp_cpus);
    1451. 

  1451. 

  1452. 	if (qos->grp_jobs == INFINITE)
    1453. 

  1453. 		printf("  GrpJobs        = NONE\n");
    1454. 

  1454. 	else if (qos->grp_jobs != NO_VAL)
    1455. 

  1455. 		printf("  GrpJobs        = %u\n", qos->grp_jobs);
    1456. 

  1456. 

  1457. 	if (qos->grp_mem == INFINITE)
    1458. 

  1458. 		printf("  GrpMemory      = NONE\n");
    1459. 

  1459. 	else if (qos->grp_mem != NO_VAL)
    1460. 

  1460. 		printf("  GrpMemory      = %u\n", qos->grp_mem);
    1461. 

  1461. 

  1462. 	if (qos->grp_nodes == INFINITE)
    1463. 

  1463. 		printf("  GrpNodes       = NONE\n");
    1464. 

  1464. 	else if (qos->grp_nodes != NO_VAL)
    1465. 

  1465. 		printf("  GrpNodes       = %u\n", qos->grp_nodes);
    1466. 

  1466. 

  1467. 	if (qos->grp_submit_jobs == INFINITE)
    1468. 

  1468. 		printf("  GrpSubmitJobs  = NONE\n");
    1469. 

  1469. 	else if (qos->grp_submit_jobs != NO_VAL)
    1470. 

  1470. 		printf("  GrpSubmitJobs  = %u\n",
    1471. 

  1471. 		       qos->grp_submit_jobs);
    1472. 

  1472. 

  1473. 	if (qos->grp_wall == INFINITE)
    1474. 

  1474. 		printf("  GrpWall        = NONE\n");
    1475. 

  1475. 	else if (qos->grp_wall != NO_VAL) {
    1476. 

  1476. 		char time_buf[32];
    1477. 

  1477. 		mins2time_str((time_t) qos->grp_wall,
    1478. 

  1478. 			      time_buf, sizeof(time_buf));
    1479. 

  1479. 		printf("  GrpWall        = %s\n", time_buf);
    1480. 

  1480. 	}
    1481. 

  1481. 

  1482. 	if (qos->max_cpu_mins_pj == (uint64_t)INFINITE)
    1483. 

  1483. 		printf("  MaxCPUMins     = NONE\n");
    1484. 

  1484. 	else if (qos->max_cpu_mins_pj != (uint64_t)NO_VAL)
    1485. 

  1485. 		printf("  MaxCPUMins     = %"PRIu64"\n",
    1486. 

  1486. 		       qos->max_cpu_mins_pj);
    1487. 

  1487. 

  1488. 	if (qos->max_cpus_pj == INFINITE)
    1489. 

  1489. 		printf("  MaxCPUs        = NONE\n");
    1490. 

  1490. 	else if (qos->max_cpus_pj != NO_VAL)
    1491. 

  1491. 		printf("  MaxCPUs        = %u\n", qos->max_cpus_pj);
    1492. 

  1492. 

  1493. 	if (qos->max_cpus_pu == INFINITE)
    1494. 

  1494. 		printf("  MaxCPUsPerUser        = NONE\n");
    1495. 

  1495. 	else if (qos->max_cpus_pu != NO_VAL)
    1496. 

  1496. 		printf("  MaxCPUsPerUser        = %u\n", qos->max_cpus_pu);
    1497. 

  1497. 

  1498. 	if (qos->max_jobs_pu == INFINITE)
    1499. 

  1499. 		printf("  MaxJobs        = NONE\n");
    1500. 

  1500. 	else if (qos->max_jobs_pu != NO_VAL)
    1501. 

  1501. 		printf("  MaxJobs        = %u\n", qos->max_jobs_pu);
    1502. 

  1502. 

  1503. 	if (qos->max_nodes_pj == INFINITE)
    1504. 

  1504. 		printf("  MaxNodes       = NONE\n");
    1505. 

  1505. 	else if (qos->max_nodes_pj != NO_VAL)
    1506. 

  1506. 		printf("  MaxNodes       = %u\n", qos->max_nodes_pj);
    1507. 

  1507. 

  1508. 	if (qos->max_nodes_pu == INFINITE)
    1509. 

  1509. 		printf("  MaxNodesPerUser       = NONE\n");
    1510. 

  1510. 	else if (qos->max_nodes_pu != NO_VAL)
    1511. 

  1511. 		printf("  MaxNodesPerUser       = %u\n", qos->max_nodes_pu);
    1512. 

  1512. 

  1513. 	if (qos->max_submit_jobs_pu == INFINITE)
    1514. 

  1514. 		printf("  MaxSubmitJobs  = NONE\n");
    1515. 

  1515. 	else if (qos->max_submit_jobs_pu != NO_VAL)
    1516. 

  1516. 		printf("  MaxSubmitJobs  = %u\n",
    1517. 

  1517. 		       qos->max_submit_jobs_pu);
    1518. 

  1518. 

  1519. 	if (qos->max_wall_pj == INFINITE)
    1520. 

  1520. 		printf("  MaxWall        = NONE\n");
    1521. 

  1521. 	else if (qos->max_wall_pj != NO_VAL) {
    1522. 

  1522. 		char time_buf[32];
    1523. 

  1523. 		mins2time_str((time_t) qos->max_wall_pj,
    1524. 

  1524. 			      time_buf, sizeof(time_buf));
    1525. 

  1525. 		printf("  MaxWall        = %s\n", time_buf);
    1526. 

  1526. 	}
    1527. 

  1527. 

  1528. 	if (qos->preempt_list) {
    1529. 

  1529. 		char *temp_char = get_qos_complete_str(g_qos_list,
    1530. 

  1530. 						       qos->preempt_list);
    1531. 

  1531. 		if (temp_char) {
    1532. 

  1532. 			printf("  Preempt        = %s\n", temp_char);
    1533. 

  1533. 			xfree(temp_char);
    1534. 

  1534. 		}
    1535. 

  1535. 	}
    1536. 

  1536. 

  1537. 	if (qos->preempt_mode) {
    1538. 

  1538. 		printf("  PreemptMode    = %s\n",
    1539. 

  1539. 		       preempt_mode_string(qos->preempt_mode));
    1540. 

  1540. 	}
    1541. 

  1541. 

  1542. 	if (qos->priority == INFINITE)
    1543. 

  1543. 		printf("  Priority       = NONE\n");
    1544. 

  1544. 	else if (qos->priority != NO_VAL)
    1545. 

  1545. 		printf("  Priority       = %d\n", qos->priority);
    1546. 

  1546. 

  1547. }
    1548. 

  1548. 

  1549. extern int sort_coord_list(slurmdb_coord_rec_t *coord_a,
    1550. 

  1550. 			   slurmdb_coord_rec_t *coord_b)
    1551. 

  1551. {
    1552. 

  1552. 	int diff = strcmp(coord_a->name, coord_b->name);
    1553. 

  1553. 

  1554. 	if (diff < 0)
    1555. 

  1555. 		return -1;
    1556. 

  1556. 	else if (diff > 0)
    1557. 

  1557. 		return 1;
    1558. 

  1558. 

  1559. 	return 0;
    1560. 

  1560. }
    1561. 

  1561. 

  1562. extern List sacctmgr_process_format_list(List format_list)
    1563. 

  1563. {
    1564. 

  1564. 	List print_fields_list = list_create(destroy_print_field);
    1565. 

  1565. 	ListIterator itr = list_iterator_create(format_list);
    1566. 

  1566. 	print_field_t *field = NULL;
    1567. 

  1567. 	char *object = NULL;
    1568. 

  1568. 

  1569. 	while((object = list_next(itr))) {
    1570. 

  1570. 		if(!(field = _get_print_field(object)))
    1571. 

  1571. 			exit(1);
    1572. 

  1572. 

  1573. 		list_append(print_fields_list, field);
    1574. 

  1574. 	}
    1575. 

  1575. 	list_iterator_destroy(itr);
    1576. 

  1576. 

  1577. 	return print_fields_list;
    1578. 

  1578. }
    1579. 

  1579.