inline void test_serialize_type(const T *dummy = 0)
{
T t1, t2;
const unsigned N = 27;
const unsigned BUF_SIZE = N*N*1000;
char buf[BUF_SIZE];
array_stream as(buf, BUF_SIZE);
for (unsigned i = 0; i<N; ++i) {
set_randomly(t1, i);
array_save(as, t1);
as.reset_read();
array_load(as, t2);
BOOST_CHECK(t1 == t2);
}
}
void program_finalize(void)
{
char *configfile = prefs_file_name();
GKeyFile *config = g_key_file_new();
save_program_settings();
g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL);
array_save(recent_programs, config, "recent", (ASaveFunc) recent_program_save);
utils_key_file_write_to_file(config, configfile);
g_key_file_free(config);
g_free(configfile);
array_free(recent_programs, (GFreeFunc) recent_program_free);
gtk_widget_destroy(program_dialog);
stash_foreach((GFunc) stash_group_destroy, NULL);
}
int setup_array_struct(job *pjob)
{
job_array *pa;
/* struct work_task *wt; */
array_request_node *rn;
int bad_token_count;
int array_size;
int rc;
/* setup a link to this job array in the servers all_arrays list */
pa = (job_array *)calloc(1,sizeof(job_array));
pa->ai_qs.struct_version = ARRAY_QS_STRUCT_VERSION;
pa->template_job = pjob;
/*pa->ai_qs.array_size = pjob->ji_wattr[(int)JOB_ATR_job_array_size].at_val.at_long;*/
strcpy(pa->ai_qs.parent_id, pjob->ji_qs.ji_jobid);
strcpy(pa->ai_qs.fileprefix, pjob->ji_qs.ji_fileprefix);
strncpy(pa->ai_qs.owner, pjob->ji_wattr[JOB_ATR_job_owner].at_val.at_str, PBS_MAXUSER + PBS_MAXSERVERNAME + 2);
strncpy(pa->ai_qs.submit_host, get_variable(pjob, pbs_o_host), PBS_MAXSERVERNAME);
pa->ai_qs.num_cloned = 0;
CLEAR_LINK(pa->all_arrays);
CLEAR_HEAD(pa->request_tokens);
append_link(&svr_jobarrays, &pa->all_arrays, (void*)pa);
if (job_save(pjob, SAVEJOB_FULL, 0) != 0)
{
job_purge(pjob);
if (LOGLEVEL >= 6)
{
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
(pjob != NULL) ? pjob->ji_qs.ji_jobid : "NULL",
"cannot save job");
}
return 1;
}
if ((rc = set_slot_limit(pjob->ji_wattr[JOB_ATR_job_array_request].at_val.at_str, pa)))
{
array_delete(pa);
snprintf(log_buffer,sizeof(log_buffer),
"Array %s requested a slot limit above the max limit %ld, rejecting\n",
pa->ai_qs.parent_id,
server.sv_attr[SRV_ATR_MaxSlotLimit].at_val.at_long);
log_event(PBSEVENT_SYSTEM,
PBS_EVENTCLASS_JOB,
pa->ai_qs.parent_id,
log_buffer);
return(INVALID_SLOT_LIMIT);
}
pa->ai_qs.jobs_running = 0;
pa->ai_qs.num_started = 0;
pa->ai_qs.num_failed = 0;
pa->ai_qs.num_successful = 0;
bad_token_count =
parse_array_request(pjob->ji_wattr[JOB_ATR_job_array_request].at_val.at_str,
&(pa->request_tokens));
/* get the number of elements that should be allocated in the array */
rn = (array_request_node *)GET_NEXT(pa->request_tokens);
array_size = 0;
pa->ai_qs.num_jobs = 0;
while (rn != NULL)
{
if (rn->end > array_size)
array_size = rn->end;
/* calculate the actual number of jobs (different from array size) */
pa->ai_qs.num_jobs += rn->end - rn->start + 1;
rn = (array_request_node *)GET_NEXT(rn->request_tokens_link);
}
/* size of array is the biggest index + 1 */
array_size++;
if (server.sv_attr[SRV_ATR_MaxArraySize].at_flags & ATR_VFLAG_SET)
{
int max_array_size = server.sv_attr[SRV_ATR_MaxArraySize].at_val.at_long;
if (max_array_size < pa->ai_qs.num_jobs)
{
array_delete(pa);
return(ARRAY_TOO_LARGE);
}
}
/* initialize the array */
pa->jobs = malloc(array_size * sizeof(job *));
memset(pa->jobs,0,array_size * sizeof(job *));
/* remember array_size */
pa->ai_qs.array_size = array_size;
CLEAR_HEAD(pa->ai_qs.deps);
array_save(pa);
if (bad_token_count > 0)
{
array_delete(pa);
return 2;
}
return 0;
}
/* array_recov reads in an array struct saved to disk and inserts it into
the servers list of arrays */
int array_recov(
char *path,
job_array **new_pa)
{
extern tlist_head svr_jobarrays;
job_array *pa;
array_request_node *rn;
int fd;
int old_version;
int num_tokens;
int i;
int len;
int rc;
old_version = ARRAY_QS_STRUCT_VERSION;
/* allocate the storage for the struct */
pa = (job_array*)calloc(1,sizeof(job_array));
if (pa == NULL)
{
return PBSE_SYSTEM;
}
/* initialize the linked list nodes */
CLEAR_LINK(pa->all_arrays);
CLEAR_HEAD(pa->request_tokens);
fd = open(path, O_RDONLY, 0);
if ( array_259_upgrade )
{
rc = read_and_convert_259_array(fd, pa, path);
if(rc != PBSE_NONE)
{
free(pa);
close(fd);
return rc;
}
}
else
{
/* read the file into the struct previously allocated.
*/
len = read(fd, &(pa->ai_qs), sizeof(pa->ai_qs));
if ((len < 0) || ((len < (int)sizeof(pa->ai_qs)) && (pa->ai_qs.struct_version == ARRAY_QS_STRUCT_VERSION)))
{
sprintf(log_buffer, "error reading %s", path);
log_err(errno, "array_recov", log_buffer);
free(pa);
close(fd);
return PBSE_SYSTEM;
}
if (pa->ai_qs.struct_version != ARRAY_QS_STRUCT_VERSION)
{
rc = array_upgrade(pa, fd, pa->ai_qs.struct_version, &old_version);
if(rc)
{
sprintf(log_buffer, "Cannot upgrade array version %d to %d", pa->ai_qs.struct_version, ARRAY_QS_STRUCT_VERSION);
log_err(errno, "array_recov", log_buffer);
free(pa);
close(fd);
return rc;
}
}
}
pa->jobs = malloc(sizeof(job *) * pa->ai_qs.array_size);
memset(pa->jobs,0,sizeof(job *) * pa->ai_qs.array_size);
/* check to see if there is any additional info saved in the array file */
/* check if there are any array request tokens that haven't been fully
processed */
if (old_version > 1)
{
if (read(fd, &num_tokens, sizeof(int)) != sizeof(int))
{
sprintf(log_buffer, "error reading token count from %s", path);
log_err(errno, "array_recov", log_buffer);
free(pa);
close(fd);
return PBSE_SYSTEM;
}
for (i = 0; i < num_tokens; i++)
{
rn = (array_request_node*)malloc(sizeof(array_request_node));
if (read(fd, rn, sizeof(array_request_node)) != sizeof(array_request_node))
{
sprintf(log_buffer, "error reading array_request_node from %s", path);
log_err(errno, "array_recov", log_buffer);
free(rn);
for (rn = (array_request_node*)GET_NEXT(pa->request_tokens);
rn != NULL;
rn = (array_request_node*)GET_NEXT(pa->request_tokens))
{
delete_link(&rn->request_tokens_link);
free(rn);
}
free(pa);
close(fd);
return PBSE_SYSTEM;
}
CLEAR_LINK(rn->request_tokens_link);
append_link(&pa->request_tokens, &rn->request_tokens_link, (void*)rn);
}
}
close(fd);
CLEAR_HEAD(pa->ai_qs.deps);
if (old_version != ARRAY_QS_STRUCT_VERSION)
{
/* resave the array struct if the version on disk is older than the current */
array_save(pa);
}
/* link the struct into the servers list of job arrays */
append_link(&svr_jobarrays, &pa->all_arrays, (void*)pa);
*new_pa = pa;
return PBSE_NONE;
}
int read_and_convert_259_array(int fd, job_array *pa, char *path)
{
int len;
job_array_259 *pa_259; /* This is for a backward compatibility problem put
into 2.5.9 and 3.0.3 */
/* allocate the storage for the struct */
pa_259 = (job_array_259*)calloc(1,sizeof(job_array));
if (pa_259 == NULL)
{
return PBSE_SYSTEM;
}
len = read(fd, &(pa_259->ai_qs), sizeof(pa_259->ai_qs));
if (len < 0)
{
sprintf(log_buffer, "error reading %s", path);
log_err(errno, "read_and_convert_259_array", log_buffer);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
if (pa_259->ai_qs.struct_version == ARRAY_QS_STRUCT_VERSION)
{
sprintf(log_buffer, "Already at array structure version 4. Restart pbs_server without -u option");
log_err(errno, "read_and_convert_259_array", log_buffer);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
if (pa_259->ai_qs.struct_version != 3)
{
sprintf(log_buffer, "Cannot upgrade array version %d to %d",
pa_259->ai_qs.struct_version, ARRAY_QS_STRUCT_VERSION);
log_err(errno, "read_and_convert_259_array", log_buffer);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
pa->ai_qs.struct_version = ARRAY_QS_STRUCT_VERSION;
pa->ai_qs.array_size = pa_259->ai_qs.array_size;
pa->ai_qs.num_jobs = pa_259->ai_qs.num_jobs;
pa->ai_qs.slot_limit = pa_259->ai_qs.slot_limit;
pa->ai_qs.jobs_running = pa_259->ai_qs.jobs_running;
pa->ai_qs.jobs_done = pa_259->ai_qs.jobs_done;
pa->ai_qs.num_cloned = pa_259->ai_qs.num_cloned;
pa->ai_qs.num_started = pa_259->ai_qs.num_started;
pa->ai_qs.num_failed = pa_259->ai_qs.num_failed;
pa->ai_qs.num_successful = pa_259->ai_qs.num_successful;
pa->ai_qs.num_purged = pa_259->ai_qs.num_purged;
pa->ai_qs.deps = pa_259->ai_qs.deps;
strncpy(pa->ai_qs.owner, pa_259->ai_qs.owner, PBS_MAXUSER + PBS_MAXSERVERNAME + 2);
strncpy(pa->ai_qs.parent_id, pa_259->ai_qs.parent_id, PBS_MAXSVRJOBID + 1);
strncpy(pa->ai_qs.fileprefix, pa_259->ai_qs.fileprefix, PBS_JOBBASE + 1);
strncpy(pa->ai_qs.submit_host, pa_259->ai_qs.submit_host, PBS_MAXSERVERNAME + 1);
array_save(pa);
return PBSE_NONE;
}
/**
* update_array_values()
*
* updates internal bookeeping values for job arrays
* @param pa - array to update
* @param pjob - the pjob that an event happened on
* @param event - code for what event just happened
*/
void update_array_values(
job_array *pa, /* I */
void *j, /* I */
int old_state, /* I */
enum ArrayEventsEnum event) /* I */
{
job *pjob = (job *)j;
int exit_status;
switch (event)
{
case aeQueue:
/* NYI, nothing needs to be done for this yet */
break;
case aeRun:
if (old_state != JOB_STATE_RUNNING)
{
pa->ai_qs.jobs_running++;
pa->ai_qs.num_started++;
}
break;
case aeTerminate:
exit_status = pjob->ji_qs.ji_un.ji_exect.ji_exitstat;
if (old_state == JOB_STATE_RUNNING)
{
if (pa->ai_qs.jobs_running > 0)
pa->ai_qs.jobs_running--;
}
if (exit_status == 0)
{
pa->ai_qs.num_successful++;
pa->ai_qs.jobs_done++;
}
else
{
pa->ai_qs.num_failed++;
pa->ai_qs.jobs_done++;
}
array_save(pa);
/* update slot limit hold if necessary */
if (server.sv_attr[SRV_ATR_MoabArrayCompatible].at_val.at_long != FALSE)
{
/* only need to update if the job wasn't previously held */
if ((pjob->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l) == FALSE)
{
int i;
int newstate;
int newsub;
job *pj;
/* find the first held job and release its hold */
for (i = 0; i < pa->ai_qs.array_size; i++)
{
if (pa->jobs[i] == NULL)
continue;
pj = (job *)pa->jobs[i];
if (pj->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l)
{
pj->ji_wattr[JOB_ATR_hold].at_val.at_long &= ~HOLD_l;
if (pj->ji_wattr[JOB_ATR_hold].at_val.at_long == 0)
{
pj->ji_wattr[JOB_ATR_hold].at_flags &= ~ATR_VFLAG_SET;
}
svr_evaljobstate(pj, &newstate, &newsub, 1);
svr_setjobstate(pj, newstate, newsub);
job_save(pj, SAVEJOB_FULL, 0);
break;
}
}
}
}
break;
default:
/* log error? */
break;
}
set_array_depend_holds(pa);
array_save(pa);
} /* END update_array_values() */
int setup_array_struct(
job *pjob)
{
job_array *pa;
array_request_node *rn;
int bad_token_count;
int array_size;
int rc;
char log_buf[LOCAL_LOG_BUF_SIZE];
long max_array_size;
pa = (job_array *)calloc(1,sizeof(job_array));
pa->ai_qs.struct_version = ARRAY_QS_STRUCT_VERSION;
strcpy(pa->ai_qs.parent_id, pjob->ji_qs.ji_jobid);
strcpy(pa->ai_qs.fileprefix, pjob->ji_qs.ji_fileprefix);
snprintf(pa->ai_qs.owner, sizeof(pa->ai_qs.owner), "%s", pjob->ji_wattr[JOB_ATR_job_owner].at_val.at_str);
snprintf(pa->ai_qs.submit_host, sizeof(pa->ai_qs.submit_host), "%s", get_variable(pjob, pbs_o_host));
pa->ai_qs.num_cloned = 0;
CLEAR_HEAD(pa->request_tokens);
pa->ai_mutex = calloc(1, sizeof(pthread_mutex_t));
pthread_mutex_init(pa->ai_mutex,NULL);
lock_ai_mutex(pa, __func__, NULL, LOGLEVEL);
if (job_save(pjob, SAVEJOB_FULL, 0) != 0)
{
/* the array is deleted in svr_job_purge */
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
svr_job_purge(pjob);
/* Does job array need to be removed? */
if (LOGLEVEL >= 6)
{
log_record(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
(pjob != NULL) ? pjob->ji_qs.ji_jobid : "NULL",
"cannot save job");
}
return(1);
}
if ((rc = set_slot_limit(pjob->ji_wattr[JOB_ATR_job_array_request].at_val.at_str, pa)))
{
long max_limit = 0;
get_svr_attr_l(SRV_ATR_MaxSlotLimit, &max_limit);
array_delete(pa);
snprintf(log_buf,sizeof(log_buf),
"Array %s requested a slot limit above the max limit %ld, rejecting\n",
pa->ai_qs.parent_id,
max_limit);
log_event(PBSEVENT_SYSTEM,PBS_EVENTCLASS_JOB,pa->ai_qs.parent_id,log_buf);
return(INVALID_SLOT_LIMIT);
}
pa->ai_qs.jobs_running = 0;
pa->ai_qs.num_started = 0;
pa->ai_qs.num_failed = 0;
pa->ai_qs.num_successful = 0;
bad_token_count = parse_array_request(
pjob->ji_wattr[JOB_ATR_job_array_request].at_val.at_str,
&(pa->request_tokens));
/* get the number of elements that should be allocated in the array */
rn = (array_request_node *)GET_NEXT(pa->request_tokens);
array_size = 0;
pa->ai_qs.num_jobs = 0;
while (rn != NULL)
{
if (rn->end > array_size)
array_size = rn->end;
/* calculate the actual number of jobs (different from array size) */
pa->ai_qs.num_jobs += rn->end - rn->start + 1;
rn = (array_request_node *)GET_NEXT(rn->request_tokens_link);
}
/* size of array is the biggest index + 1 */
array_size++;
if (get_svr_attr_l(SRV_ATR_MaxArraySize, &max_array_size) == PBSE_NONE)
{
if (max_array_size < pa->ai_qs.num_jobs)
{
array_delete(pa);
return(ARRAY_TOO_LARGE);
}
}
/* initialize the array */
pa->job_ids = calloc(array_size, sizeof(char *));
if (pa->job_ids == NULL)
{
sprintf(log_buf, "Failed to alloc job_ids: job %s", pjob->ji_qs.ji_jobid);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, log_buf);
return(PBSE_MEM_MALLOC);
}
/* remember array_size */
pa->ai_qs.array_size = array_size;
CLEAR_HEAD(pa->ai_qs.deps);
array_save(pa);
if (bad_token_count > 0)
{
array_delete(pa);
return 2;
}
pjob->ji_arraystruct = pa;
insert_array(pa);
unlock_ai_mutex(pa, __func__, "1", LOGLEVEL);
return(PBSE_NONE);
} /* END setup_array_struct() */
/**
* update_array_values()
*
* updates internal bookeeping values for job arrays
* @param pa - array to update
* @param pjob - the pjob that an event happened on
* @param event - code for what event just happened
*/
void update_array_values(
job_array *pa, /* I */
int old_state, /* I */
enum ArrayEventsEnum event, /* I */
char *job_id,
long job_atr_hold,
int job_exit_status)
{
long moab_compatible;
switch (event)
{
case aeQueue:
/* NYI, nothing needs to be done for this yet */
break;
case aeRun:
if (old_state != JOB_STATE_RUNNING)
{
pa->ai_qs.jobs_running++;
pa->ai_qs.num_started++;
}
break;
case aeTerminate:
if (old_state == JOB_STATE_RUNNING)
{
if (pa->ai_qs.jobs_running > 0)
pa->ai_qs.jobs_running--;
}
if (job_exit_status == 0)
{
pa->ai_qs.num_successful++;
pa->ai_qs.jobs_done++;
}
else
{
pa->ai_qs.num_failed++;
pa->ai_qs.jobs_done++;
}
array_save(pa);
/* update slot limit hold if necessary */
if (get_svr_attr_l(SRV_ATR_MoabArrayCompatible, &moab_compatible) != PBSE_NONE)
moab_compatible = FALSE;
if (moab_compatible != FALSE)
{
/* only need to update if the job wasn't previously held */
if ((job_atr_hold & HOLD_l) == FALSE)
{
int i;
int newstate;
int newsub;
job *pj;
/* find the first held job and release its hold */
for (i = 0; i < pa->ai_qs.array_size; i++)
{
if (pa->job_ids[i] == NULL)
continue;
if (!strcmp(pa->job_ids[i], job_id))
continue;
if ((pj = svr_find_job(pa->job_ids[i], TRUE)) == NULL)
{
free(pa->job_ids[i]);
pa->job_ids[i] = NULL;
}
else
{
if (pj->ji_wattr[JOB_ATR_hold].at_val.at_long & HOLD_l)
{
pj->ji_wattr[JOB_ATR_hold].at_val.at_long &= ~HOLD_l;
if (pj->ji_wattr[JOB_ATR_hold].at_val.at_long == 0)
{
pj->ji_wattr[JOB_ATR_hold].at_flags &= ~ATR_VFLAG_SET;
}
svr_evaljobstate(pj, &newstate, &newsub, 1);
svr_setjobstate(pj, newstate, newsub, FALSE);
job_save(pj, SAVEJOB_FULL, 0);
unlock_ji_mutex(pj, __func__, "1", LOGLEVEL);
break;
}
unlock_ji_mutex(pj, __func__, "2", LOGLEVEL);
}
}
}
}
break;
default:
/* log error? */
break;
}
set_array_depend_holds(pa);
array_save(pa);
} /* END update_array_values() */
/* array_recov reads in an array struct saved to disk and inserts it into
the servers list of arrays */
int array_recov(
char *path,
job_array **new_pa)
{
job_array *pa;
array_request_node *rn;
char log_buf[LOCAL_LOG_BUF_SIZE];
int fd;
int old_version;
int num_tokens;
int i;
int len;
int rc;
*new_pa = NULL;
old_version = ARRAY_QS_STRUCT_VERSION;
/* allocate the storage for the struct */
pa = (job_array*)calloc(1,sizeof(job_array));
if (pa == NULL)
{
return(PBSE_SYSTEM);
}
/* initialize the linked list nodes */
CLEAR_HEAD(pa->request_tokens);
fd = open(path, O_RDONLY, 0);
if(fd < 0)
{
free(pa);
return(PBSE_SYSTEM);
}
if (array_259_upgrade)
{
rc = read_and_convert_259_array(fd, pa, path);
if (rc != PBSE_NONE)
{
free(pa);
close(fd);
return(rc);
}
}
else
{
/* read the file into the struct previously allocated.
*/
len = read_ac_socket(fd, &(pa->ai_qs), sizeof(pa->ai_qs));
if ((len < 0) || ((len < (int)sizeof(pa->ai_qs)) && (pa->ai_qs.struct_version == ARRAY_QS_STRUCT_VERSION)))
{
sprintf(log_buf, "error reading %s", path);
log_err(errno, __func__, log_buf);
free(pa);
close(fd);
return(PBSE_SYSTEM);
}
if (pa->ai_qs.struct_version != ARRAY_QS_STRUCT_VERSION)
{
rc = array_upgrade(pa, fd, pa->ai_qs.struct_version, &old_version);
if (rc)
{
sprintf(log_buf, "Cannot upgrade array version %d to %d", pa->ai_qs.struct_version, ARRAY_QS_STRUCT_VERSION);
log_err(errno, __func__, log_buf);
free(pa);
close(fd);
return(rc);
}
}
}
pa->job_ids = (char **)calloc(pa->ai_qs.array_size, sizeof(char *));
/* check to see if there is any additional info saved in the array file */
/* check if there are any array request tokens that haven't been fully
processed */
if (old_version > 1)
{
if (read_ac_socket(fd, &num_tokens, sizeof(int)) != sizeof(int))
{
sprintf(log_buf, "error reading token count from %s", path);
log_err(errno, __func__, log_buf);
free(pa);
close(fd);
return(PBSE_SYSTEM);
}
for (i = 0; i < num_tokens; i++)
{
rn = (array_request_node *)calloc(1, sizeof(array_request_node));
if (read_ac_socket(fd, rn, sizeof(array_request_node)) != sizeof(array_request_node))
{
sprintf(log_buf, "error reading array_request_node from %s", path);
log_err(errno, __func__, log_buf);
free(rn);
for (rn = (array_request_node*)GET_NEXT(pa->request_tokens);
rn != NULL;
rn = (array_request_node*)GET_NEXT(pa->request_tokens))
{
delete_link(&rn->request_tokens_link);
free(rn);
}
free(pa);
close(fd);
return(PBSE_SYSTEM);
}
CLEAR_LINK(rn->request_tokens_link);
append_link(&pa->request_tokens, &rn->request_tokens_link, (void*)rn);
}
}
close(fd);
CLEAR_HEAD(pa->ai_qs.deps);
if (old_version != ARRAY_QS_STRUCT_VERSION)
{
/* resave the array struct if the version on disk is older than the current */
array_save(pa);
}
pa->ai_mutex = (pthread_mutex_t *)calloc(1, sizeof(pthread_mutex_t));
pthread_mutex_init(pa->ai_mutex,NULL);
lock_ai_mutex(pa, __func__, NULL, LOGLEVEL);
/* link the struct into the servers list of job arrays */
insert_array(pa);
*new_pa = pa;
return(PBSE_NONE);
} /* END array_recov() */
int read_and_convert_259_array(
int fd,
job_array *pa,
char *path)
{
char log_buf[LOCAL_LOG_BUF_SIZE];
int len;
job_array_259 *pa_259; /* This is for a backward compatibility problem put
into 2.5.9 and 3.0.3 */
/* allocate the storage for the struct */
pa_259 = (job_array_259*)calloc(1, sizeof(job_array_259));
if (pa_259 == NULL)
{
return PBSE_SYSTEM;
}
len = read_ac_socket(fd, &(pa_259->ai_qs), sizeof(pa_259->ai_qs));
if (len < 0)
{
sprintf(log_buf, "error reading %s", path);
log_err(errno, "read_and_convert_259_array", log_buf);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
if (pa_259->ai_qs.struct_version == ARRAY_QS_STRUCT_VERSION)
{
sprintf(log_buf, "Already at array structure version 4. Restart pbs_server without -u option");
log_err(errno, "read_and_convert_259_array", log_buf);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
if (pa_259->ai_qs.struct_version != 3)
{
sprintf(log_buf, "Cannot upgrade array version %d to %d",
pa_259->ai_qs.struct_version, ARRAY_QS_STRUCT_VERSION);
log_err(errno, "read_and_convert_259_array", log_buf);
free(pa_259);
close(fd);
return PBSE_BAD_ARRAY_DATA;
}
pa->ai_qs.struct_version = ARRAY_QS_STRUCT_VERSION;
pa->ai_qs.array_size = pa_259->ai_qs.array_size;
pa->ai_qs.num_jobs = pa_259->ai_qs.num_jobs;
pa->ai_qs.slot_limit = pa_259->ai_qs.slot_limit;
pa->ai_qs.jobs_running = pa_259->ai_qs.jobs_running;
pa->ai_qs.jobs_done = pa_259->ai_qs.jobs_done;
pa->ai_qs.num_cloned = pa_259->ai_qs.num_cloned;
pa->ai_qs.num_started = pa_259->ai_qs.num_started;
pa->ai_qs.num_failed = pa_259->ai_qs.num_failed;
pa->ai_qs.num_successful = pa_259->ai_qs.num_successful;
pa->ai_qs.num_purged = pa_259->ai_qs.num_purged;
pa->ai_qs.deps = pa_259->ai_qs.deps;
snprintf(pa->ai_qs.owner, sizeof(pa->ai_qs.owner), "%s", pa_259->ai_qs.owner);
snprintf(pa->ai_qs.parent_id, sizeof(pa->ai_qs.parent_id), "%s", pa_259->ai_qs.parent_id);
snprintf(pa->ai_qs.fileprefix, sizeof(pa->ai_qs.fileprefix), "%s", pa_259->ai_qs.fileprefix);
snprintf(pa->ai_qs.submit_host, sizeof(pa->ai_qs.submit_host), "%s", pa_259->ai_qs.submit_host);
free(pa_259);
array_save(pa);
return(PBSE_NONE);
} /* END read_and_convert_259_array() */