int main() {
LIST *jlist = init_list();
assert(gen_job_id(jlist) == 1);
assert(get_fg(jlist) == (job *)NULL);
assert(jlist->size == 0);
//print_bg(jlist);
job *jb1 = tstjob(1);
push(jlist, JOB, jb1);
assert(gen_job_id(jlist) == 2);
assert(get_fg(jlist) == jb1);
//print_bg(jlist);
job *jb2 = tstjob(3);
push(jlist, JOB, jb2);
assert(gen_job_id(jlist) == 2);
job *jb3 = tstjob(2);
push(jlist, JOB, jb3);
assert(gen_job_id(jlist) == 4);
push(jlist, JOB, tstjob(7));
assert(gen_job_id(jlist) == 4);
print_bg(jlist);
pop(jlist);
assert(gen_job_id(jlist) == 4);
assert(get_job_pgid(jlist, 11) == (job *)NULL);
assert(get_job_pgid(jlist, 7) == jb2);
assert(get_job_pgid(jlist, 3) == jb3);
assert(get_job(jlist, 3) == jb2);
assert(del_job(jlist, 7) == jb2);
assert(get_job(jlist, 3) == (job *)NULL);
assert(get_job(jlist, 55) == jb3);
assert(get_job(jlist, 10) == (job *)NULL);
assert(set_complete(jb2, 3) == 0);
assert(set_complete(jb2, 4) == -1);
assert(set_complete(jb3, 55) == 0);
assert(((process *)jb2->pid_list->head->node_ptr)->complete == 0);
assert(jb2->complete == 0);
assert(jb3->complete == 1);
assert(jlist->size == 2);
assert(get_job_jid(jlist, 1) == jb1);
assert(get_job_jid(jlist, 11) == (job *)NULL);
printf("[job_handler_tst] All tests pass!\n");
return 0;
}
/** Wait on fg job **/
void jwait(job *j) {
if (j == NULL)
return;
//printf("Waiting on %s (j->running = %d)...\n", j->rawcmd, j->running);
while(j->running)
pause();
if(j->complete) {
free_job(del_job(job_list, j->pgid));
}
}
static void *work(void *args)
{
int i;
int work_num;
int failed = 0;
DENTER(TOP_LAYER, "work");
work_num = *((int *)args);
WARNING((SGE_EVENT, "work %d starting %d loops", work_num, loops));
for (i = 0; i < loops; i++) {
#if SGE_LOCKING
/* SGE_LOCK(LOCK_GLOBAL, LOCK_WRITE); */
pthread_mutex_lock(&mtx);
#endif
if (!add_job(work_num * loops + i)) {
failed++;
}
#if SGE_LOCKING
/* SGE_UNLOCK(LOCK_GLOBAL, LOCK_WRITE); */
pthread_mutex_unlock(&mtx);
#endif
}
WARNING((SGE_EVENT, "work %d finished adding %d jobs, %d failed",
work_num, loops, failed));
failed = 0;
for (i = 0; i < loops; i++) {
#if SGE_LOCKING
/* SGE_LOCK(LOCK_GLOBAL, LOCK_WRITE); */
pthread_mutex_lock(&mtx);
#endif
if(!del_job(work_num * loops + i)) {
failed++;
}
#if SGE_LOCKING
/* SGE_UNLOCK(LOCK_GLOBAL, LOCK_WRITE); */
pthread_mutex_unlock(&mtx);
#endif
}
WARNING((SGE_EVENT, "work %d finished deleting %d jobs, %d failed",
work_num, loops, failed));
DEXIT;
return (void *)NULL;
}
void gw_em_mad_recover_callback(void *arg, globus_gram_protocol_error_t
failure_code, const char * job_contact,
globus_gram_protocol_job_state_t job_state,
globus_gram_protocol_error_t error_code)
{
int *jid;
jid = (int *) arg;
if ( failure_code == GLOBUS_SUCCESS)
{
printf("RECOVER %d SUCCESS %s\n", *jid, get_job_state_name(job_state));
}
else
{
printf("RECOVER %d FAILURE %s (%i)\n", *jid,
globus_gram_client_error_string(failure_code), error_code);
del_job(*jid);
}
free(jid);
}
void gw_em_mad_state_callback(void *arg, char *job_contact, int job_state,
int error_code )
{
int jid = -1;
int done = 0;
jid = get_jid(job_contact);
if (jid == -1)
{
return;
}
switch (job_state)
{
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING:
printf("CALLBACK %d SUCCESS PENDING\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_SUSPENDED:
printf("CALLBACK %d SUCCESS SUSPENDED\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE:
printf("CALLBACK %d SUCCESS ACTIVE\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED:
if (error_code == GLOBUS_GRAM_PROTOCOL_ERROR_USER_CANCELLED )
printf("CALLBACK %d SUCCESS FAILED\n", jid);
else
printf("CALLBACK %d FAILURE %s (error %d)\n", jid,
globus_gram_client_error_string(error_code),
error_code);
done = 1;
job_pool.cancel_state[jid] = 0;
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE:
printf("CALLBACK %d SUCCESS DONE\n", jid);
done = 1;
job_pool.cancel_state[jid] = 0;
break;
}
if (done && (jid != -1))
del_job(jid);
}
/** SIGCHLD handler **/
void handler(int signum, siginfo_t *info, void *context) {
int cpid, status;
cpid = info->si_pid; // sending pid
//printf("Got a SIGCHLD from %d!\n", cpid);
// loop to catch simultaneous SIGCHLDs
while( (cpid = waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED)) > 0 ) {
//printf("HANDLER Got %d from waitpid\n", cpid);
job *j = get_job(job_list, cpid);
if(j == NULL) {
printf("Error: get_job returned null\n");
_exit(EXIT_FAILURE);
}
if(WIFEXITED(status)) { // completed
if( set_complete(j, cpid) == -1 ) {
printf("HANDLER set_complete went awry!\n");
_exit(EXIT_FAILURE);
}
}
else if(WIFSIGNALED(status)) { // terminated
set_complete(j, cpid);
printf("\n");
//printf("TERMINATED: %d\n", WTERMSIG(status));
}
else if(WIFSTOPPED(status)) { // stopped
j->running = 0;
if(j->fg) {
send_back(job_list, j->pgid);
printf("\nStopped: %s\n", j->rawcmd);
} else {
// queue stopped message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 0;
push(msg_q, PROCESS, (void *)m);
}
}
else if(WIFCONTINUED(status)) { // continued
j->running = 1;
//printf("CONTINUED\n");
}
if(j->complete) {
j->running = 0;
if(!j->fg) {
// queue finished message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 1;
push(msg_q, PROCESS, (void *)m);
free_job(del_job(job_list, j->pgid));
}
}
}
//printf("HANDLER Done with waitpid loop\n");
}
void gw_em_mad_state_callback(void *arg, const char *job_contact,
globus_gram_client_job_info_t *job_info)
{
globus_gram_protocol_extension_t *entry;
int jid = -1;
int done = 0;
int job_state;
jid = get_jid(job_contact);
if (jid == -1)
{
return;
}
job_state = job_info->job_state;
switch (job_state)
{
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING:
printf("CALLBACK %d SUCCESS PENDING\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_SUSPENDED:
printf("CALLBACK %d SUCCESS SUSPENDED\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE:
printf("CALLBACK %d SUCCESS ACTIVE\n", jid);
if (job_pool.cancel_state[jid] == 1)
{
globus_gram_client_job_cancel(job_contact);
job_pool.cancel_state[jid] = 0;
}
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED:
if (job_info->protocol_error_code == GLOBUS_GRAM_PROTOCOL_ERROR_USER_CANCELLED )
printf("CALLBACK %d SUCCESS FAILED\n", jid);
else
printf("CALLBACK %d FAILURE %s (error %d)\n", jid,
globus_gram_client_error_string(job_info->protocol_error_code),
job_info->protocol_error_code);
done = 1;
job_pool.cancel_state[jid] = 0;
break;
case GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE:
if (job_info->extensions)
{
entry = globus_hashtable_lookup(&job_info->extensions, "exit-code");
if (entry != NULL)
printf("CALLBACK %d SUCCESS DONE:%s\n", jid, entry->value);
else
printf("CALLBACK %d SUCCESS DONE\n", jid);
}
else
printf("CALLBACK %d SUCCESS DONE\n", jid);
done = 1;
job_pool.cancel_state[jid] = 0;
break;
}
if (done && (jid != -1))
del_job(jid);
}
