/**
* @brief
* dup_event_list() - evevnt_list copy constructor
*
* @param[in] oelist - event list to copy
* @param[in] nsinfo - new universe
*
* @return duplicated event_list
*
*/
event_list *
dup_event_list(event_list *oelist, server_info *nsinfo)
{
event_list *nelist;
if (oelist == NULL || nsinfo == NULL)
return NULL;
nelist = new_event_list();
if (nelist == NULL)
return NULL;
nelist->eol = oelist->eol;
nelist->current_time = &nsinfo->server_time;
if (oelist->events != NULL) {
nelist->events = dup_timed_event_list(oelist->events, nsinfo);
if (nelist->events == NULL) {
free_event_list(nelist);
return NULL;
}
}
if (oelist->next_event != NULL) {
nelist->next_event = find_timed_event(nelist->events,
oelist->next_event->name,
oelist->next_event->event_type,
oelist->next_event->event_time);
if (nelist->next_event == NULL) {
schdlog(PBSEVENT_SCHED, PBS_EVENTCLASS_SCHED,
LOG_WARNING, oelist->next_event->name,
"can't find next event in duplicated list");
free_event_list(nelist);
return NULL;
}
}
return nelist;
}
/**
* @brief
* calculate the run time of a resresv through simulation of
* future calendar events
*
* @param[in] name - the name of the resresv to find the start time of
* @param[in] sinfo - the pbs environment
* NOTE: sinfo will be modified, it should be a copy
* @param[in] flags - some flags to control the function
* SIM_RUN_JOB - simulate running the resresv
*
* @return int
* @retval time_t of when the job will run
* @retval 0 : can not determine when job will run
* @retval 1 : on error
*
*/
time_t
calc_run_time(char *name, server_info *sinfo, int flags)
{
time_t event_time = (time_t) 0; /* time of the simulated event */
event_list *calendar; /* calendar we are simulating in */
resource_resv *resresv; /* the resource resv to find star time for */
/* the value returned from simulate_events(). Init to TIMED_END_EVENT to
* force the initial check to see if the job can run
*/
unsigned int ret = TIMED_END_EVENT;
schd_error *err = NULL;
timed_event *te_start;
timed_event *te_end;
int desc;
nspec **ns = NULL;
if (name == NULL || sinfo == NULL)
return (time_t) -1;
event_time = sinfo->server_time;
calendar = sinfo->calendar;
resresv = find_resource_resv(sinfo->all_resresv, name);
if (!is_resource_resv_valid(resresv, NULL))
return (time_t) -1;
err = new_schd_error();
if(err == NULL)
return (time_t) 0;
do {
/* policy is used from sinfo instead of being passed into calc_run_time()
* because it's being simulated/updated in simulate_events()
*/
desc = describe_simret(ret);
if (desc > 0 || (desc == 0 && policy_change_info(sinfo, resresv))) {
clear_schd_error(err);
if (resresv->is_job)
ns = is_ok_to_run(sinfo->policy, -1, sinfo, resresv->job->queue, resresv, IGNORE_EQUIV_CLASS, err);
else
ns = is_ok_to_run(sinfo->policy, -1, sinfo, NULL, resresv, IGNORE_EQUIV_CLASS, err);
}
if (ns == NULL) /* event can not run */
ret = simulate_events(sinfo->policy, sinfo, SIM_NEXT_EVENT, &(sinfo->opt_backfill_fuzzy_time), &event_time);
#ifdef NAS /* localmod 030 */
if (check_for_cycle_interrupt(0)) {
break;
}
#endif /* localmod 030 */
} while (ns == NULL && !(ret & (TIMED_NOEVENT|TIMED_ERROR)));
#ifdef NAS /* localmod 030 */
if (check_for_cycle_interrupt(0) || (ret & TIMED_ERROR)) {
#else
if ((ret & TIMED_ERROR)) {
#endif /* localmod 030 */
free_schd_error(err);
if (ns != NULL)
free_nspecs(ns);
return -1;
}
/* we can't run the job, but there are no timed events left to process */
if (ns == NULL && (ret & TIMED_NOEVENT)) {
schdlogerr(PBSEVENT_SCHED, PBS_EVENTCLASS_SCHED, LOG_WARNING, resresv->name,
"Can't find start time estimate", err);
free_schd_error(err);
return 0;
}
/* err is no longer needed, we've reported it. */
free_schd_error(err);
err = NULL;
if (resresv->is_job)
resresv->job->est_start_time = event_time;
resresv->start = event_time;
resresv->end = event_time + resresv->duration;
te_start = create_event(TIMED_RUN_EVENT, resresv->start,
(event_ptr_t *) resresv, NULL, NULL);
if (te_start == NULL) {
if (ns != NULL)
free_nspecs(ns);
return -1;
}
te_end = create_event(TIMED_END_EVENT, resresv->end,
(event_ptr_t *) resresv, NULL, NULL);
if (te_end == NULL) {
if (ns != NULL)
free_nspecs(ns);
free_timed_event(te_start);
return -1;
}
add_event(calendar, te_start);
add_event(calendar, te_end);
if (flags & SIM_RUN_JOB)
sim_run_update_resresv(sinfo->policy, resresv, ns, RURR_NO_FLAGS);
else
free_nspecs(ns);
return event_time;
}
/**
* @brief
* create an event_list from running jobs and confirmed resvs
*
* @param[in] sinfo - server universe to act upon
*
* @return event_list
*/
event_list *
create_event_list(server_info *sinfo)
{
event_list *elist;
elist = new_event_list();
if (elist == NULL)
return NULL;
elist->events = create_events(sinfo);
elist->next_event = elist->events;
elist->current_time = &sinfo->server_time;
add_dedtime_events(elist, sinfo->policy);
return elist;
}
/*
* Handle a request issued from the command line.
* It sends the request to the server and waits for the reply
* request - the request information
*/
int communicate_event_request(Request* request) {
int res = myWriteSocket(request->socket, (char *) &request->event_op, sizeof(EventOp));
if (res == -1)
return -1;
if (operation(request) == ADD) {
myWriteSocket(request->socket, (char *) &request->event, sizeof(Event));
if (res == -1)
return -1;
}
int reply;
res = myReadSocket(request->socket, (char *) &reply, sizeof(int));
if (res == -1)
return -1;
if (reply == -1)
printf ("Error: Could not perform operation.\n");
else if (reply > 0) {
if (is_list(request)) {
EventList* eventList = new_event_list(reply);
res = myReadSocket(request->socket, (char *) eventList->events,
eventList->nEvents * sizeof(Event));
if (res == -1)
return -1;
if (operation(request) == LIST_ONGOING_EVENTS) {
// NOT IMPLEMENTED - START
printf("\n******************\n* NOTIFICATION *\n******************\n");
print_event_list(eventList);
// NOT IMPLEMENTED - END
return 0;
}
else
print_event_list(eventList);
destroy_event_list(eventList);
}
else {
switch (operation(request)) {
case ADD:
printf ("Added event number %d\n", reply);
break;
case REMOVE:
printf("Removed event number %d\n", reply);
break;
default:
printf ("Internal Error - client handling operation %d\n", (-reply));
}
}
}
return 0;
}
