Attachment #27767 for ticket #14634




		}
	}

	if (((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) ||
	     (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) &&
	    ((resv_desc_ptr->flags & RESERVE_FLAG_STATIC) ||
	     (resv_desc_ptr->flags & RESERVE_FLAG_MAINT))) {
		info("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
		rc = ESLURM_NOT_SUPPORTED;
		goto bad_parse;
	}

	if (resv_desc_ptr->partition) {
		part_ptr = find_part_record(resv_desc_ptr->partition);
		if (!part_ptr) {
- 
reservation requests
--
src/slurmctld/proc_req.c    |  5 +++--
src/slurmctld/reservation.c | 10 +++++++++-
src/slurmctld/reservation.h |  2 +-
3 files changed, 13 insertions(+), 4 deletions(-)




static void _slurm_rpc_resv_create(slurm_msg_t * msg)
{
	int error_code = SLURM_SUCCESS;
	char *err_msg = NULL;
	DEF_TIMERS;
	resv_desc_msg_t *resv_desc_ptr = (resv_desc_msg_t *)
		msg->data;

	if (error_code == SLURM_SUCCESS) {
		/* do RPC call */
		lock_slurmctld(node_write_lock);
		error_code = create_resv(resv_desc_ptr, &err_msg);
		unlock_slurmctld(node_write_lock);
		END_TIMER2("_slurm_rpc_resv_create");
	}

			info("_slurm_rpc_resv_create: %s",
			     slurm_strerror(error_code));
		}
		slurm_send_rc_err_msg(msg, error_code, err_msg);
	} else {
		slurm_msg_t response_msg;
		reservation_name_msg_t resv_resp_msg;

Lines 2552-2558 static bitstr_t _get_update_node_bitmap(slurmctld_resv_t resv_ptr, Link Here

(-)a/src/slurmctld/reservation.c (-1 / +9 lines)
2552	}	2552	}
2553		2553
2554	/* Create a resource reservation */	2554	/* Create a resource reservation */
2555	extern int create_resv(resv_desc_msg_t *resv_desc_ptr)	2555	extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg)
2556	{	2556	{
2557	int i, j, rc = SLURM_SUCCESS;	2557	int i, j, rc = SLURM_SUCCESS;
2558	time_t now = time(NULL);	2558	time_t now = time(NULL);
Lines 2627-2638 extern int create_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
2627	if (resv_desc_ptr->node_list) {	2627	if (resv_desc_ptr->node_list) {
2628	info("%s: REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify Nodes",	2628	info("%s: REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify Nodes",
2629	__func__);	2629	__func__);
		2630	if (err_msg)
		2631	*err_msg = xstrdup("REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify Nodes");
2630	rc = ESLURM_INVALID_NODE_NAME;	2632	rc = ESLURM_INVALID_NODE_NAME;
2631	goto bad_parse;	2633	goto bad_parse;
2632	}	2634	}
2633	if (resv_desc_ptr->core_cnt) {	2635	if (resv_desc_ptr->core_cnt) {
2634	info("%s: REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify CoreCnt",	2636	info("%s: REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify CoreCnt",
2635	__func__);	2637	__func__);
		2638	if (err_msg)
		2639	*err_msg = xstrdup("REPLACE or REPLACE_DOWN flags should be used with the NodeCnt reservation option; do not specify CoreCnt");
2636	rc = ESLURM_INVALID_CPU_COUNT;	2640	rc = ESLURM_INVALID_CPU_COUNT;
2637	goto bad_parse;	2641	goto bad_parse;
2638	}	2642	}
Lines 2643-2648 extern int create_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
2643	((resv_desc_ptr->flags & RESERVE_FLAG_STATIC) \|\|	2647	((resv_desc_ptr->flags & RESERVE_FLAG_STATIC) \|\|
2644	(resv_desc_ptr->flags & RESERVE_FLAG_MAINT))) {	2648	(resv_desc_ptr->flags & RESERVE_FLAG_MAINT))) {
2645	info("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");	2649	info("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
		2650	if (err_msg)
		2651	*err_msg = xstrdup("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
2646	rc = ESLURM_NOT_SUPPORTED;	2652	rc = ESLURM_NOT_SUPPORTED;
2647	goto bad_parse;	2653	goto bad_parse;
2648	}	2654	}
Lines 2722-2727 extern int create_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
2722	if ((resv_desc_ptr->flags & RESERVE_FLAG_TIME_FLOAT) &&	2728	if ((resv_desc_ptr->flags & RESERVE_FLAG_TIME_FLOAT) &&
2723	(resv_desc_ptr->flags & RESERVE_REOCCURING)) {	2729	(resv_desc_ptr->flags & RESERVE_REOCCURING)) {
2724	info("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");	2730	info("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");
		2731	if (err_msg)
		2732	*err_msg = xstrdup("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");
2725	rc = ESLURM_NOT_SUPPORTED;	2733	rc = ESLURM_NOT_SUPPORTED;
2726	goto bad_parse;	2734	goto bad_parse;
2727	}	2735	}

Lines 48-54 Link Here

(-)a/src/slurmctld/reservation.h (-3 / +1 lines)
48	#include "src/slurmctld/slurmctld.h"	48	#include "src/slurmctld/slurmctld.h"
49		49
50	/* Create a resource reservation */	50	/* Create a resource reservation */
51	extern int create_resv(resv_desc_msg_t *resv_desc_ptr);	51	extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg);
52		52
53	/* Update an existing resource reservation */	53	/* Update an existing resource reservation */
54	extern int update_resv(resv_desc_msg_t *resv_desc_ptr);	54	extern int update_resv(resv_desc_msg_t *resv_desc_ptr);
55	-
56	--
57	src/slurmctld/proc_req.c \| 1 +	55	src/slurmctld/proc_req.c \| 1 +
58	1 file changed, 1 insertion(+)	56	1 file changed, 1 insertion(+)

Lines 4533-4538 static void _slurm_rpc_resv_create(slurm_msg_t * msg) Link Here

(-)a/src/slurmctld/proc_req.c (-2 / +1 lines)
4533		4533
4534	queue_job_scheduler();	4534	queue_job_scheduler();
4535	}	4535	}
		4536	xfree(err_msg);
4536	}	4537	}
4537		4538
4538	/* _slurm_rpc_resv_update - process RPC to update a reservation */	4539	/* _slurm_rpc_resv_update - process RPC to update a reservation */
4539	-
4540	--
4541	src/slurmctld/reservation.c \| 7 ++++---	4540	src/slurmctld/reservation.c \| 7 ++++---
4542	1 file changed, 4 insertions(+), 3 deletions(-)	4541	1 file changed, 4 insertions(+), 3 deletions(-)




					rc = ESLURM_INVALID_CORE_CNT;
					goto bad_parse;
				}
				log_flag(RESERVATION, "%s: Requesting %d cores for node_list %d",
					 __func__,
					 resv_desc_ptr->core_cnt[nodeinx],
					 nodeinx);
				nodeinx++;
			}
			rc = _select_nodes(resv_desc_ptr, &part_ptr,
- 
--
slurm/slurm.h               | 2 +-
src/slurmctld/reservation.c | 8 ++++----
2 files changed, 5 insertions(+), 5 deletions(-)

Lines 2565-2571 typedef struct will_run_response_msg { Link Here

(-)a/slurm/slurm.h (-1 / +1 lines)
2565	#define RESERVE_FLAG_HOURLY SLURM_BIT(35) /* Set HOURLY flag */	2565	#define RESERVE_FLAG_HOURLY SLURM_BIT(35) /* Set HOURLY flag */
2566	#define RESERVE_FLAG_NO_HOURLY SLURM_BIT(36) /* Clear HOURLY flag */	2566	#define RESERVE_FLAG_NO_HOURLY SLURM_BIT(36) /* Clear HOURLY flag */
2567		2567
2568	#define RESERVE_REOCCURING (RESERVE_FLAG_HOURLY \| RESERVE_FLAG_DAILY \| \	2568	#define RESERVE_REOCCURRING (RESERVE_FLAG_HOURLY \| RESERVE_FLAG_DAILY \| \
2569	RESERVE_FLAG_WEEKLY \| RESERVE_FLAG_WEEKDAY \| \	2569	RESERVE_FLAG_WEEKLY \| RESERVE_FLAG_WEEKDAY \| \
2570	RESERVE_FLAG_WEEKEND)	2570	RESERVE_FLAG_WEEKEND)
2571		2571




		}
	}
	if ((resv_desc_ptr->flags & RESERVE_FLAG_TIME_FLOAT) &&
	    (resv_desc_ptr->flags & RESERVE_REOCCURRING)) {
		info("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");
		if (err_msg)
			*err_msg = xstrdup("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");


		/* handle skipping later */
		if (resv_desc_ptr->flags & RESERVE_FLAG_SKIP) {
			if (!(resv_ptr->flags & RESERVE_REOCCURRING)) {
				error_code = ESLURM_RESERVATION_NO_SKIP;
				goto update_failure;
			}

			 * If we are ending a reoccurring reservation advance
			 * it, otherwise delete it.
			 */
			if (!(resv_ptr->flags & RESERVE_REOCCURRING)) {
				/*
				 * Reset time here for reoccurring reservations
				 * so we don't continually keep running this.

		(void)_advance_resv_time(resv_ptr);
		if ((!resv_ptr->job_run_cnt ||
		     (resv_ptr->flags & RESERVE_FLAG_FLEX)) &&
		    !(resv_ptr->flags & RESERVE_REOCCURRING)) {
			if (resv_ptr->job_pend_cnt) {
				info("Purging vestigial reservation %s "
				     "with %u pending jobs",
- 
reservation updates
--
src/slurmctld/proc_req.c    | 6 ++++--
src/slurmctld/reservation.c | 6 +++++-
src/slurmctld/reservation.h | 2 +-
3 files changed, 10 insertions(+), 4 deletions(-)




static void _slurm_rpc_resv_update(slurm_msg_t * msg)
{
	int error_code = SLURM_SUCCESS;
	char *err_msg = NULL;
	DEF_TIMERS;
	resv_desc_msg_t *resv_desc_ptr = (resv_desc_msg_t *)
		msg->data;


	if (error_code == SLURM_SUCCESS) {
		/* do RPC call */
		error_code = update_resv(resv_desc_ptr, &err_msg);
		END_TIMER2("_slurm_rpc_resv_update");
	}
	unlock_slurmctld(node_write_lock);

	if (error_code) {
		info("_slurm_rpc_resv_update reservation=%s: %s",
		     resv_desc_ptr->name, slurm_strerror(error_code));
		slurm_send_rc_err_msg(msg, error_code, err_msg);
	} else {
		debug2("_slurm_rpc_resv_update complete for %s %s",
		       resv_desc_ptr->name, TIME_STR);


		queue_job_scheduler();
	}
	xfree(err_msg);
}

/* _slurm_rpc_resv_delete - process RPC to delete a reservation */

Lines 3006-3012 extern void resv_fini(void) Link Here

(-)a/src/slurmctld/reservation.c (-1 / +5 lines)
3006	}	3006	}
3007		3007
3008	/* Update an exiting resource reservation */	3008	/* Update an exiting resource reservation */
3009	extern int update_resv(resv_desc_msg_t *resv_desc_ptr)	3009	extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg)
3010	{	3010	{
3011	time_t now = time(NULL);	3011	time_t now = time(NULL);
3012	slurmctld_resv_t resv_backup, resv_ptr;	3012	slurmctld_resv_t resv_backup, resv_ptr;
Lines 3090-3095 extern int update_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
3090	!(resv_ptr->ctld_flags & RESV_CTLD_FULL_NODE)) {	3090	!(resv_ptr->ctld_flags & RESV_CTLD_FULL_NODE)) {
3091	info("%s: reservation %s can't be updated with REPLACE or REPLACE_DOWN flags; they should be updated on a NodeCnt reservation",	3091	info("%s: reservation %s can't be updated with REPLACE or REPLACE_DOWN flags; they should be updated on a NodeCnt reservation",
3092	__func__, resv_desc_ptr->name);	3092	__func__, resv_desc_ptr->name);
		3093	if (err_msg)
		3094	*err_msg = xstrdup("Reservation can't be updated with REPLACE or REPLACE_DOWN flags; they should be updated on a NodeCnt reservation");
3093	error_code = ESLURM_NOT_SUPPORTED;	3095	error_code = ESLURM_NOT_SUPPORTED;
3094	goto update_failure;	3096	goto update_failure;
3095	}	3097	}
Lines 3378-3383 extern int update_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
3378	(resv_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {	3380	(resv_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
3379	info("%s: reservation %s can't be updated with Nodes option; it is incompatible with REPLACE[_DOWN]",	3381	info("%s: reservation %s can't be updated with Nodes option; it is incompatible with REPLACE[_DOWN]",
3380	__func__, resv_desc_ptr->name);	3382	__func__, resv_desc_ptr->name);
		3383	if (err_msg)
		3384	*err_msg = xstrdup("Reservation can't be updated with Nodes option; it is incompatible with REPLACE[_DOWN]");
3381	error_code = ESLURM_NOT_SUPPORTED;	3385	error_code = ESLURM_NOT_SUPPORTED;
3382	goto update_failure;	3386	goto update_failure;
3383	}	3387	}




extern int create_resv(resv_desc_msg_t *resv_desc_ptr, char **err_msg);

/* Update an existing resource reservation */
extern int update_resv(resv_desc_msg_t *resv_desc_ptr, char **err_msg);

/* Delete an existing resource reservation */
extern int delete_resv(reservation_name_msg_t *resv_desc_ptr);
- 
STATIC_ALLOC flags
--
src/slurmctld/reservation.c | 43 +++++++++++++++++++++++++++++++++----
1 file changed, 39 insertions(+), 4 deletions(-)




			resv_ptr->flags |= RESERVE_FLAG_FLEX;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_FLEX)
			resv_ptr->flags &= (~RESERVE_FLAG_FLEX);
		if (resv_desc_ptr->flags & RESERVE_FLAG_MAINT)
			resv_ptr->flags |= RESERVE_FLAG_MAINT;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_MAINT)
			resv_ptr->flags &= (~RESERVE_FLAG_MAINT);
		if (resv_desc_ptr->flags & RESERVE_FLAG_OVERLAP)

			resv_ptr->flags |= RESERVE_FLAG_ANY_NODES;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_ANY_NODES)
			resv_ptr->flags &= (~RESERVE_FLAG_ANY_NODES);
		if (resv_desc_ptr->flags & RESERVE_FLAG_STATIC)
			resv_ptr->flags |= RESERVE_FLAG_STATIC;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_STATIC)
			resv_ptr->flags &= (~RESERVE_FLAG_STATIC);
		if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)

				error_code = ESLURM_NOT_SUPPORTED;
				goto update_failure;
			}

			/*
			 * If requesting to add the REPLACE or REPLACE_DOWN
			 * flags, and the STATIC or MAINT flags were already
			 * set, then reject the update.
			 */
			if ((resv_ptr->flags & RESERVE_FLAG_STATIC) ||
			    (resv_ptr->flags & RESERVE_FLAG_MAINT)) {
				info("%s: reservation %s can't be updated: REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags",
				     __func__, resv_desc_ptr->name);
				if (err_msg)
					*err_msg = xstrdup("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
				error_code = ESLURM_NOT_SUPPORTED;
				goto update_failure;
			}


			if (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE)
				resv_ptr->flags |= RESERVE_FLAG_REPLACE;
			else
				resv_ptr->flags |= RESERVE_FLAG_REPLACE_DOWN;
		}
		if ((resv_desc_ptr->flags & RESERVE_FLAG_STATIC) ||
		    (resv_desc_ptr->flags & RESERVE_FLAG_MAINT)) {
			/*
			 * If requesting to add the MAINT or STATIC flag,
			 * and the REPLACE or REPLACE_DOWN flags were already
			 * set, then reject the update.
			 */
			if ((resv_ptr->flags & RESERVE_FLAG_REPLACE) ||
		            (resv_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
		     		info("%s: reservation %s can't be updated: REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags",
				     __func__, resv_desc_ptr->name);
				if (err_msg)
					*err_msg = xstrdup("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
				error_code = ESLURM_NOT_SUPPORTED;
				goto update_failure;
			}

			if (resv_desc_ptr->flags & RESERVE_FLAG_STATIC)
				resv_ptr->flags |= RESERVE_FLAG_STATIC;
			else
				resv_ptr->flags |= RESERVE_FLAG_MAINT;
		}
		if (resv_desc_ptr->flags & RESERVE_FLAG_PART_NODES) {
			if ((resv_ptr->partition == NULL) &&
			    (resv_desc_ptr->partition == NULL)) {
- 
reoccurring flag
--
src/slurmctld/reservation.c | 63 +++++++++++++++++++++++++++++++------
1 file changed, 53 insertions(+), 10 deletions(-)




	return node_bitmap;
}

/* Returns false if only one reoccurring flag is set, true otherwise */
static bool _has_multiple_reoccurring(resv_desc_msg_t *resv_desc_ptr){
	int flag_count = 0;
	if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
		flag_count++;
	if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
		flag_count++;
	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
		flag_count++;
	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
		flag_count++;
	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
		flag_count++;

	return (flag_count > 1);
}

/* Create a resource reservation */
extern int create_resv(resv_desc_msg_t *resv_desc_ptr, char **err_msg)
{

	} else
		resv_desc_ptr->end_time = INFINITE;

	if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {
		if (_has_multiple_reoccurring(resv_desc_ptr)) {
			info("Reservation has multiple reoccurring flags. Please specify only one reoccurring flag");
			if (err_msg)
				*err_msg = xstrdup("Reservation has multiple reoccurring flags. Please specify only one reoccurring flag");
			rc = ESLURM_NOT_SUPPORTED;
			goto bad_parse;
		}
	}

	if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) ||
	    (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
		if (resv_desc_ptr->node_list) {

			resv_ptr->flags |= RESERVE_FLAG_IGN_JOBS;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_IGN_JOB)
			resv_ptr->flags &= (~RESERVE_FLAG_IGN_JOBS);
		if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
			resv_ptr->flags |= RESERVE_FLAG_HOURLY;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_HOURLY)
			resv_ptr->flags &= (~RESERVE_FLAG_HOURLY);
		if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
			resv_ptr->flags |= RESERVE_FLAG_DAILY;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_DAILY)
			resv_ptr->flags &= (~RESERVE_FLAG_DAILY);
		if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
			resv_ptr->flags |= RESERVE_FLAG_WEEKDAY;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKDAY)
			resv_ptr->flags &= (~RESERVE_FLAG_WEEKDAY);
		if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
			resv_ptr->flags |= RESERVE_FLAG_WEEKEND;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKEND)
			resv_ptr->flags &= (~RESERVE_FLAG_WEEKEND);
		if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
			resv_ptr->flags |= RESERVE_FLAG_WEEKLY;
		if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKLY)
			resv_ptr->flags &= (~RESERVE_FLAG_WEEKLY);
		if (resv_desc_ptr->flags & RESERVE_FLAG_ANY_NODES)

			resv_ptr->flags &= (~RESERVE_FLAG_STATIC);
		if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)
			resv_ptr->flags |= RESERVE_FLAG_FIRST_CORES;
		if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {

			/*
			 * If the reservation already has a reoccurring flag
			 * or is being updated to have multiple reoccurring
			 * flags, then reject the update
			 */
			if ((resv_ptr->flags & RESERVE_REOCCURRING) ||
			    (_has_multiple_reoccurring(resv_desc_ptr))) {
				info("Cannot update reservation to have multiple reoccurring flags. Please specify only one reoccurring flag");
				if (err_msg)
					*err_msg = xstrdup("Cannot update reservation to have multiple reoccurring flags. Please specify only one reoccurring flag");
				error_code = ESLURM_NOT_SUPPORTED;
				goto update_failure;
			}
			else if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
				resv_ptr->flags |= RESERVE_FLAG_HOURLY;
			else if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
				resv_ptr->flags |= RESERVE_FLAG_DAILY;
			else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
				resv_ptr->flags |= RESERVE_FLAG_WEEKDAY;
			else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
				resv_ptr->flags |= RESERVE_FLAG_WEEKEND;
			else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
				resv_ptr->flags |= RESERVE_FLAG_WEEKLY;
		}
		if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) ||
		    (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
			if ((resv_ptr->flags & RESERVE_FLAG_SPEC_NODES) ||
- 
reoccurring
--
src/slurmctld/reservation.c | 8 ++++++++
1 file changed, 8 insertions(+)




			resv_ptr->flags |= RESERVE_FLAG_FIRST_CORES;
		if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {

			if (resv_ptr->flags & RESERVE_FLAG_TIME_FLOAT) {
				info("Cannot add a reoccurring flag to a floating reservation");
				if (err_msg)
					*err_msg = xstrdup("Cannot add a reoccurring flag to a floating reservation");
				error_code = ESLURM_NOT_SUPPORTED;
				goto update_failure;
			}

			/*
			 * If the reservation already has a reoccurring flag
			 * or is being updated to have multiple reoccurring
- 
--
NEWS          | 5 +++++
RELEASE_NOTES | 6 ++++++
2 files changed, 11 insertions(+)

Lines 135-140 documents those changes that are of interest to users and administrators. Link Here

(-)a/NEWS (+5 lines)
135	-- Add "[jobid.stepid]" prefix from slurmstepd and "slurmscriptd" prefix from	135	-- Add "[jobid.stepid]" prefix from slurmstepd and "slurmscriptd" prefix from
136	slurmcriptd to Syslog logging. Previously was only happening when logging	136	slurmcriptd to Syslog logging. Previously was only happening when logging
137	to a file.	137	to a file.
		138	-- Remove ability for reservation to have STATIC_ALLOC or MAINT flags and
		139	REPLACE[_DOWN] flags simultaneously.
		140	-- Accept only one reoccurring flag when creating/updating any reservation.
		141	-- Remove ability to update a reservation to have a reoccurring flag if it
		142	is a floating reservation.
138		143
139	* Changes in Slurm 22.05.7	144	* Changes in Slurm 22.05.7
140	==========================	145	==========================

Lines 95-100 COMMAND CHANGES (see man pages for details) Link Here

(-)a/RELEASE_NOTES (-1 / +6 lines)
95	-- scontrol - Add ResumeAfter=<secs> option to "scontrol update nodename=".	95	-- scontrol - Add ResumeAfter=<secs> option to "scontrol update nodename=".
96	-- Add a new "nodes=" argument to scontrol setdebug to allow the debug level	96	-- Add a new "nodes=" argument to scontrol setdebug to allow the debug level
97	on the slurmd processes to be temporarily altered.	97	on the slurmd processes to be temporarily altered.
		98	-- scontrol - Reservations will not be allowed to have STATIC_ALLOC or MAINT
		99	flags and REPLACE[_DOWN] flags simultaneously.
		100	-- scontrol - Reservations will only accept one reoccurring flag when
		101	being created or updated.
		102	-- scontrol - A reservation cannot be updated to be reoccurring if it is
		103	already a floating reservation.
98		104
99	API CHANGES	105	API CHANGES
100	===========	106	===========
101	-

Return to ticket 14634

Lines 4484-4489 static void _slurm_rpc_delete_partition(slurm_msg_t * msg) Link Here

(-)a/src/slurmctld/proc_req.c (-2 / +3 lines)
4484	static void _slurm_rpc_resv_create(slurm_msg_t * msg)	4484	static void _slurm_rpc_resv_create(slurm_msg_t * msg)
4485	{	4485	{
4486	int error_code = SLURM_SUCCESS;	4486	int error_code = SLURM_SUCCESS;
		4487	char *err_msg = NULL;
4487	DEF_TIMERS;	4488	DEF_TIMERS;
4488	resv_desc_msg_t resv_desc_ptr = (resv_desc_msg_t )	4489	resv_desc_msg_t resv_desc_ptr = (resv_desc_msg_t )
4489	msg->data;	4490	msg->data;
Lines 4501-4507 static void _slurm_rpc_resv_create(slurm_msg_t * msg) Link Here
4501	if (error_code == SLURM_SUCCESS) {	4502	if (error_code == SLURM_SUCCESS) {
4502	/* do RPC call */	4503	/* do RPC call */
4503	lock_slurmctld(node_write_lock);	4504	lock_slurmctld(node_write_lock);
4504	error_code = create_resv(resv_desc_ptr);	4505	error_code = create_resv(resv_desc_ptr, &err_msg);
4505	unlock_slurmctld(node_write_lock);	4506	unlock_slurmctld(node_write_lock);
4506	END_TIMER2("_slurm_rpc_resv_create");	4507	END_TIMER2("_slurm_rpc_resv_create");
4507	}	4508	}
Lines 4515-4521 static void _slurm_rpc_resv_create(slurm_msg_t * msg) Link Here
4515	info("_slurm_rpc_resv_create: %s",	4516	info("_slurm_rpc_resv_create: %s",
4516	slurm_strerror(error_code));	4517	slurm_strerror(error_code));
4517	}	4518	}
4518	slurm_send_rc_msg(msg, error_code);	4519	slurm_send_rc_err_msg(msg, error_code, err_msg);
4519	} else {	4520	} else {
4520	slurm_msg_t response_msg;	4521	slurm_msg_t response_msg;
4521	reservation_name_msg_t resv_resp_msg;	4522	reservation_name_msg_t resv_resp_msg;

Lines 2820-2828 extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here

(-)a/src/slurmctld/reservation.c (-5 / +4 lines)
2820	rc = ESLURM_INVALID_CORE_CNT;	2820	rc = ESLURM_INVALID_CORE_CNT;
2821	goto bad_parse;	2821	goto bad_parse;
2822	}	2822	}
2823	log_flag(RESERVATION, "%s: Requesting %d cores for node_list %d",	2823	log_flag(RESERVATION, "%s: Requesting %d cores for node_list %d",
2824	__func__, resv_desc_ptr->core_cnt[nodeinx],	2824	__func__,
2825	nodeinx);	2825	resv_desc_ptr->core_cnt[nodeinx],
		2826	nodeinx);
2826	nodeinx++;	2827	nodeinx++;
2827	}	2828	}
2828	rc = _select_nodes(resv_desc_ptr, &part_ptr,	2829	rc = _select_nodes(resv_desc_ptr, &part_ptr,
2829	-
2830	--
2831	slurm/slurm.h \| 2 +-	2830	slurm/slurm.h \| 2 +-
2832	src/slurmctld/reservation.c \| 8 ++++----	2831	src/slurmctld/reservation.c \| 8 ++++----
2833	2 files changed, 5 insertions(+), 5 deletions(-)	2832	2 files changed, 5 insertions(+), 5 deletions(-)

Lines 4540-4545 static void _slurm_rpc_resv_create(slurm_msg_t * msg) Link Here

(-)a/src/slurmctld/proc_req.c (-2 / +4 lines)
4540	static void _slurm_rpc_resv_update(slurm_msg_t * msg)	4540	static void _slurm_rpc_resv_update(slurm_msg_t * msg)
4541	{	4541	{
4542	int error_code = SLURM_SUCCESS;	4542	int error_code = SLURM_SUCCESS;
		4543	char *err_msg = NULL;
4543	DEF_TIMERS;	4544	DEF_TIMERS;
4544	resv_desc_msg_t resv_desc_ptr = (resv_desc_msg_t )	4545	resv_desc_msg_t resv_desc_ptr = (resv_desc_msg_t )
4545	msg->data;	4546	msg->data;
Lines 4574-4580 static void _slurm_rpc_resv_update(slurm_msg_t * msg) Link Here
4574		4575
4575	if (error_code == SLURM_SUCCESS) {	4576	if (error_code == SLURM_SUCCESS) {
4576	/* do RPC call */	4577	/* do RPC call */
4577	error_code = update_resv(resv_desc_ptr);	4578	error_code = update_resv(resv_desc_ptr, &err_msg);
4578	END_TIMER2("_slurm_rpc_resv_update");	4579	END_TIMER2("_slurm_rpc_resv_update");
4579	}	4580	}
4580	unlock_slurmctld(node_write_lock);	4581	unlock_slurmctld(node_write_lock);
Lines 4583-4589 static void _slurm_rpc_resv_update(slurm_msg_t * msg) Link Here
4583	if (error_code) {	4584	if (error_code) {
4584	info("_slurm_rpc_resv_update reservation=%s: %s",	4585	info("_slurm_rpc_resv_update reservation=%s: %s",
4585	resv_desc_ptr->name, slurm_strerror(error_code));	4586	resv_desc_ptr->name, slurm_strerror(error_code));
4586	slurm_send_rc_msg(msg, error_code);	4587	slurm_send_rc_err_msg(msg, error_code, err_msg);
4587	} else {	4588	} else {
4588	debug2("_slurm_rpc_resv_update complete for %s %s",	4589	debug2("_slurm_rpc_resv_update complete for %s %s",
4589	resv_desc_ptr->name, TIME_STR);	4590	resv_desc_ptr->name, TIME_STR);
Lines 4591-4596 static void _slurm_rpc_resv_update(slurm_msg_t * msg) Link Here
4591		4592
4592	queue_job_scheduler();	4593	queue_job_scheduler();
4593	}	4594	}
		4595	xfree(err_msg);
4594	}	4596	}
4595		4597
4596	/* _slurm_rpc_resv_delete - process RPC to delete a reservation */	4598	/* _slurm_rpc_resv_delete - process RPC to delete a reservation */

Lines 3099-3104 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here

(-)a/src/slurmctld/reservation.c (-2 / +8 lines)
3099	resv_ptr->flags \|= RESERVE_FLAG_FIRST_CORES;	3099	resv_ptr->flags \|= RESERVE_FLAG_FIRST_CORES;
3100	if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {	3100	if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {
3101		3101
		3102	if (resv_ptr->flags & RESERVE_FLAG_TIME_FLOAT) {
		3103	info("Cannot add a reoccurring flag to a floating reservation");
		3104	if (err_msg)
		3105	*err_msg = xstrdup("Cannot add a reoccurring flag to a floating reservation");
		3106	error_code = ESLURM_NOT_SUPPORTED;
		3107	goto update_failure;
		3108	}
		3109
3102	/*	3110	/*
3103	* If the reservation already has a reoccurring flag	3111	* If the reservation already has a reoccurring flag
3104	* or is being updated to have multiple reoccurring	3112	* or is being updated to have multiple reoccurring
3105	-
3106	--
3107	NEWS \| 5 +++++	3113	NEWS \| 5 +++++
3108	RELEASE_NOTES \| 6 ++++++	3114	RELEASE_NOTES \| 6 ++++++
3109	2 files changed, 11 insertions(+)	3115	2 files changed, 11 insertions(+)

Lines 2726-2732 extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here

(-)a/src/slurmctld/reservation.c (-6 / +4 lines)
2726	}	2726	}
2727	}	2727	}
2728	if ((resv_desc_ptr->flags & RESERVE_FLAG_TIME_FLOAT) &&	2728	if ((resv_desc_ptr->flags & RESERVE_FLAG_TIME_FLOAT) &&
2729	(resv_desc_ptr->flags & RESERVE_REOCCURING)) {	2729	(resv_desc_ptr->flags & RESERVE_REOCCURRING)) {
2730	info("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");	2730	info("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");
2731	if (err_msg)	2731	if (err_msg)
2732	*err_msg = xstrdup("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");	2732	*err_msg = xstrdup("Reservation request has mutually exclusive flags. Repeating floating reservations are not supported.");
Lines 3155-3161 extern int update_resv(resv_desc_msg_t *resv_desc_ptr) Link Here
3155		3155
3156	/* handle skipping later */	3156	/* handle skipping later */
3157	if (resv_desc_ptr->flags & RESERVE_FLAG_SKIP) {	3157	if (resv_desc_ptr->flags & RESERVE_FLAG_SKIP) {
3158	if (!(resv_ptr->flags & RESERVE_REOCCURING)) {	3158	if (!(resv_ptr->flags & RESERVE_REOCCURRING)) {
3159	error_code = ESLURM_RESERVATION_NO_SKIP;	3159	error_code = ESLURM_RESERVATION_NO_SKIP;
3160	goto update_failure;	3160	goto update_failure;
3161	}	3161	}
Lines 6921-6927 extern void job_resv_check(void) Link Here
6921	* If we are ending a reoccurring reservation advance	6921	* If we are ending a reoccurring reservation advance
6922	* it, otherwise delete it.	6922	* it, otherwise delete it.
6923	*/	6923	*/
6924	if (!(resv_ptr->flags & RESERVE_REOCCURING)) {	6924	if (!(resv_ptr->flags & RESERVE_REOCCURRING)) {
6925	/*	6925	/*
6926	* Reset time here for reoccurring reservations	6926	* Reset time here for reoccurring reservations
6927	* so we don't continually keep running this.	6927	* so we don't continually keep running this.
Lines 6960-6966 extern void job_resv_check(void) Link Here
6960	(void)_advance_resv_time(resv_ptr);	6960	(void)_advance_resv_time(resv_ptr);
6961	if ((!resv_ptr->job_run_cnt \|\|	6961	if ((!resv_ptr->job_run_cnt \|\|
6962	(resv_ptr->flags & RESERVE_FLAG_FLEX)) &&	6962	(resv_ptr->flags & RESERVE_FLAG_FLEX)) &&
6963	!(resv_ptr->flags & RESERVE_REOCCURING)) {	6963	!(resv_ptr->flags & RESERVE_REOCCURRING)) {
6964	if (resv_ptr->job_pend_cnt) {	6964	if (resv_ptr->job_pend_cnt) {
6965	info("Purging vestigial reservation %s "	6965	info("Purging vestigial reservation %s "
6966	"with %u pending jobs",	6966	"with %u pending jobs",
6967	-
6968	reservation updates	6967	reservation updates
6969	--
6970	src/slurmctld/proc_req.c \| 6 ++++--	6968	src/slurmctld/proc_req.c \| 6 ++++--
6971	src/slurmctld/reservation.c \| 6 +++++-	6969	src/slurmctld/reservation.c \| 6 +++++-
6972	src/slurmctld/reservation.h \| 2 +-	6970	src/slurmctld/reservation.h \| 2 +-
6973	3 files changed, 10 insertions(+), 4 deletions(-)	6971	3 files changed, 10 insertions(+), 4 deletions(-)

Lines 3044-3051 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here

(-)a/src/slurmctld/reservation.c (-6 / +39 lines)
3044	resv_ptr->flags \|= RESERVE_FLAG_FLEX;	3044	resv_ptr->flags \|= RESERVE_FLAG_FLEX;
3045	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_FLEX)	3045	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_FLEX)
3046	resv_ptr->flags &= (~RESERVE_FLAG_FLEX);	3046	resv_ptr->flags &= (~RESERVE_FLAG_FLEX);
3047	if (resv_desc_ptr->flags & RESERVE_FLAG_MAINT)
3048	resv_ptr->flags \|= RESERVE_FLAG_MAINT;
3049	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_MAINT)	3047	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_MAINT)
3050	resv_ptr->flags &= (~RESERVE_FLAG_MAINT);	3048	resv_ptr->flags &= (~RESERVE_FLAG_MAINT);
3051	if (resv_desc_ptr->flags & RESERVE_FLAG_OVERLAP)	3049	if (resv_desc_ptr->flags & RESERVE_FLAG_OVERLAP)
Lines 3078-3085 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here
3078	resv_ptr->flags \|= RESERVE_FLAG_ANY_NODES;	3076	resv_ptr->flags \|= RESERVE_FLAG_ANY_NODES;
3079	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_ANY_NODES)	3077	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_ANY_NODES)
3080	resv_ptr->flags &= (~RESERVE_FLAG_ANY_NODES);	3078	resv_ptr->flags &= (~RESERVE_FLAG_ANY_NODES);
3081	if (resv_desc_ptr->flags & RESERVE_FLAG_STATIC)
3082	resv_ptr->flags \|= RESERVE_FLAG_STATIC;
3083	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_STATIC)	3079	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_STATIC)
3084	resv_ptr->flags &= (~RESERVE_FLAG_STATIC);	3080	resv_ptr->flags &= (~RESERVE_FLAG_STATIC);
3085	if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)	3081	if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)
Lines 3095-3105 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here
3095	error_code = ESLURM_NOT_SUPPORTED;	3091	error_code = ESLURM_NOT_SUPPORTED;
3096	goto update_failure;	3092	goto update_failure;
3097	}	3093	}
		3094
		3095	/*
		3096	* If requesting to add the REPLACE or REPLACE_DOWN
		3097	* flags, and the STATIC or MAINT flags were already
		3098	* set, then reject the update.
		3099	*/
		3100	if ((resv_ptr->flags & RESERVE_FLAG_STATIC) \|\|
		3101	(resv_ptr->flags & RESERVE_FLAG_MAINT)) {
		3102	info("%s: reservation %s can't be updated: REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags",
		3103	__func__, resv_desc_ptr->name);
		3104	if (err_msg)
		3105	*err_msg = xstrdup("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
		3106	error_code = ESLURM_NOT_SUPPORTED;
		3107	goto update_failure;
		3108	}
		3109
		3110
3098	if (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE)	3111	if (resv_desc_ptr->flags & RESERVE_FLAG_REPLACE)
3099	resv_ptr->flags \|= RESERVE_FLAG_REPLACE;	3112	resv_ptr->flags \|= RESERVE_FLAG_REPLACE;
3100	else	3113	else
3101	resv_ptr->flags \|= RESERVE_FLAG_REPLACE_DOWN;	3114	resv_ptr->flags \|= RESERVE_FLAG_REPLACE_DOWN;
3102	}	3115	}
		3116	if ((resv_desc_ptr->flags & RESERVE_FLAG_STATIC) \|\|
		3117	(resv_desc_ptr->flags & RESERVE_FLAG_MAINT)) {
		3118	/*
		3119	* If requesting to add the MAINT or STATIC flag,
		3120	* and the REPLACE or REPLACE_DOWN flags were already
		3121	* set, then reject the update.
		3122	*/
		3123	if ((resv_ptr->flags & RESERVE_FLAG_REPLACE) \|\|
		3124	(resv_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
		3125	info("%s: reservation %s can't be updated: REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags",
		3126	__func__, resv_desc_ptr->name);
		3127	if (err_msg)
		3128	*err_msg = xstrdup("REPLACE and REPLACE_DOWN flags cannot be used with STATIC_ALLOC or MAINT flags");
		3129	error_code = ESLURM_NOT_SUPPORTED;
		3130	goto update_failure;
		3131	}
		3132
		3133	if (resv_desc_ptr->flags & RESERVE_FLAG_STATIC)
		3134	resv_ptr->flags \|= RESERVE_FLAG_STATIC;
		3135	else
		3136	resv_ptr->flags \|= RESERVE_FLAG_MAINT;
		3137	}
3103	if (resv_desc_ptr->flags & RESERVE_FLAG_PART_NODES) {	3138	if (resv_desc_ptr->flags & RESERVE_FLAG_PART_NODES) {
3104	if ((resv_ptr->partition == NULL) &&	3139	if ((resv_ptr->partition == NULL) &&
3105	(resv_desc_ptr->partition == NULL)) {	3140	(resv_desc_ptr->partition == NULL)) {
3106	-
3107	reoccurring flag	3141	reoccurring flag
3108	--
3109	src/slurmctld/reservation.c \| 63 +++++++++++++++++++++++++++++++------	3142	src/slurmctld/reservation.c \| 63 +++++++++++++++++++++++++++++++------
3110	1 file changed, 53 insertions(+), 10 deletions(-)	3143	1 file changed, 53 insertions(+), 10 deletions(-)

Lines 2551-2556 static bitstr_t _get_update_node_bitmap(slurmctld_resv_t resv_ptr, Link Here

(-)a/src/slurmctld/reservation.c (-12 / +53 lines)
2551	return node_bitmap;	2551	return node_bitmap;
2552	}	2552	}
2553		2553
		2554	/* Returns false if only one reoccurring flag is set, true otherwise */
		2555	static bool _has_multiple_reoccurring(resv_desc_msg_t *resv_desc_ptr){
		2556	int flag_count = 0;
		2557	if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
		2558	flag_count++;
		2559	if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
		2560	flag_count++;
		2561	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
		2562	flag_count++;
		2563	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
		2564	flag_count++;
		2565	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
		2566	flag_count++;
		2567
		2568	return (flag_count > 1);
		2569	}
		2570
2554	/* Create a resource reservation */	2571	/* Create a resource reservation */
2555	extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg)	2572	extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg)
2556	{	2573	{
Lines 2622-2627 extern int create_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here
2622	} else	2639	} else
2623	resv_desc_ptr->end_time = INFINITE;	2640	resv_desc_ptr->end_time = INFINITE;
2624		2641
		2642	if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {
		2643	if (_has_multiple_reoccurring(resv_desc_ptr)) {
		2644	info("Reservation has multiple reoccurring flags. Please specify only one reoccurring flag");
		2645	if (err_msg)
		2646	*err_msg = xstrdup("Reservation has multiple reoccurring flags. Please specify only one reoccurring flag");
		2647	rc = ESLURM_NOT_SUPPORTED;
		2648	goto bad_parse;
		2649	}
		2650	}
		2651
2625	if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) \|\|	2652	if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) \|\|
2626	(resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {	2653	(resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
2627	if (resv_desc_ptr->node_list) {	2654	if (resv_desc_ptr->node_list) {
Lines 3052-3075 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here
3052	resv_ptr->flags \|= RESERVE_FLAG_IGN_JOBS;	3079	resv_ptr->flags \|= RESERVE_FLAG_IGN_JOBS;
3053	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_IGN_JOB)	3080	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_IGN_JOB)
3054	resv_ptr->flags &= (~RESERVE_FLAG_IGN_JOBS);	3081	resv_ptr->flags &= (~RESERVE_FLAG_IGN_JOBS);
3055	if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
3056	resv_ptr->flags \|= RESERVE_FLAG_HOURLY;
3057	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_HOURLY)	3082	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_HOURLY)
3058	resv_ptr->flags &= (~RESERVE_FLAG_HOURLY);	3083	resv_ptr->flags &= (~RESERVE_FLAG_HOURLY);
3059	if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
3060	resv_ptr->flags \|= RESERVE_FLAG_DAILY;
3061	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_DAILY)	3084	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_DAILY)
3062	resv_ptr->flags &= (~RESERVE_FLAG_DAILY);	3085	resv_ptr->flags &= (~RESERVE_FLAG_DAILY);
3063	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
3064	resv_ptr->flags \|= RESERVE_FLAG_WEEKDAY;
3065	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKDAY)	3086	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKDAY)
3066	resv_ptr->flags &= (~RESERVE_FLAG_WEEKDAY);	3087	resv_ptr->flags &= (~RESERVE_FLAG_WEEKDAY);
3067	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
3068	resv_ptr->flags \|= RESERVE_FLAG_WEEKEND;
3069	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKEND)	3088	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKEND)
3070	resv_ptr->flags &= (~RESERVE_FLAG_WEEKEND);	3089	resv_ptr->flags &= (~RESERVE_FLAG_WEEKEND);
3071	if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
3072	resv_ptr->flags \|= RESERVE_FLAG_WEEKLY;
3073	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKLY)	3090	if (resv_desc_ptr->flags & RESERVE_FLAG_NO_WEEKLY)
3074	resv_ptr->flags &= (~RESERVE_FLAG_WEEKLY);	3091	resv_ptr->flags &= (~RESERVE_FLAG_WEEKLY);
3075	if (resv_desc_ptr->flags & RESERVE_FLAG_ANY_NODES)	3092	if (resv_desc_ptr->flags & RESERVE_FLAG_ANY_NODES)
Lines 3080-3085 extern int update_resv(resv_desc_msg_t resv_desc_ptr, char *err_msg) Link Here
3080	resv_ptr->flags &= (~RESERVE_FLAG_STATIC);	3097	resv_ptr->flags &= (~RESERVE_FLAG_STATIC);
3081	if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)	3098	if (resv_desc_ptr->flags & RESERVE_FLAG_FIRST_CORES)
3082	resv_ptr->flags \|= RESERVE_FLAG_FIRST_CORES;	3099	resv_ptr->flags \|= RESERVE_FLAG_FIRST_CORES;
		3100	if (resv_desc_ptr->flags & RESERVE_REOCCURRING) {
		3101
		3102	/*
		3103	* If the reservation already has a reoccurring flag
		3104	* or is being updated to have multiple reoccurring
		3105	* flags, then reject the update
		3106	*/
		3107	if ((resv_ptr->flags & RESERVE_REOCCURRING) \|\|
		3108	(_has_multiple_reoccurring(resv_desc_ptr))) {
		3109	info("Cannot update reservation to have multiple reoccurring flags. Please specify only one reoccurring flag");
		3110	if (err_msg)
		3111	*err_msg = xstrdup("Cannot update reservation to have multiple reoccurring flags. Please specify only one reoccurring flag");
		3112	error_code = ESLURM_NOT_SUPPORTED;
		3113	goto update_failure;
		3114	}
		3115	else if (resv_desc_ptr->flags & RESERVE_FLAG_HOURLY)
		3116	resv_ptr->flags \|= RESERVE_FLAG_HOURLY;
		3117	else if (resv_desc_ptr->flags & RESERVE_FLAG_DAILY)
		3118	resv_ptr->flags \|= RESERVE_FLAG_DAILY;
		3119	else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKDAY)
		3120	resv_ptr->flags \|= RESERVE_FLAG_WEEKDAY;
		3121	else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKEND)
		3122	resv_ptr->flags \|= RESERVE_FLAG_WEEKEND;
		3123	else if (resv_desc_ptr->flags & RESERVE_FLAG_WEEKLY)
		3124	resv_ptr->flags \|= RESERVE_FLAG_WEEKLY;
		3125	}
3083	if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) \|\|	3126	if ((resv_desc_ptr->flags & RESERVE_FLAG_REPLACE) \|\|
3084	(resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {	3127	(resv_desc_ptr->flags & RESERVE_FLAG_REPLACE_DOWN)) {
3085	if ((resv_ptr->flags & RESERVE_FLAG_SPEC_NODES) \|\|	3128	if ((resv_ptr->flags & RESERVE_FLAG_SPEC_NODES) \|\|
3086	-
3087	reoccurring	3129	reoccurring
3088	--
3089	src/slurmctld/reservation.c \| 8 ++++++++	3130	src/slurmctld/reservation.c \| 8 ++++++++
3090	1 file changed, 8 insertions(+)	3131	1 file changed, 8 insertions(+)