/**
* @brief
* executes a job
*
* @param[in] job - The fully qualified job id.
* @param[in] server - The name of the server that manages the job.
* @param[in] location - location indicating where to run job
*
* @return - Void
*
* @File Variables:
* exitstatus Set to two if an error occurs.
*
*/
static void
execute(char *job, char *server, char *location)
{
int ct; /* Connection to the server */
int err; /* Error return from pbs_run */
int out; /* Stores the size of err_msg_buf*/
int located = FALSE;
char *errmsg;
char err_msg_buf[COMMENT_BUF_SIZE] = {'\0'}; /* generic buffer - comments & logging*/
char rmt_server[MAXSERVERNAME];
cnt:
if ((ct = cnt2server(server)) > 0) {
if (async)
err = pbs_asyrunjob(ct, job, location, NULL);
else
err = pbs_runjob(ct, job, location, NULL);
if (err && (pbs_errno != PBSE_UNKJOBID)) {
errmsg = pbs_geterrmsg(ct);
if (errmsg != NULL) {
if (pbs_errno == PBSE_UNKNODE) {
out = snprintf(err_msg_buf, sizeof(err_msg_buf),"qrun: %s %s",errmsg, location);
if (out >= sizeof(err_msg_buf)) {
fprintf(stderr,"%s...\n", err_msg_buf);
} else {
fprintf(stderr, "%s\n", err_msg_buf);
}
} else {
prt_job_err("qrun", ct, job);
}
} else {
fprintf(stderr, "qrun : Server returned error %d for job ", pbs_errno);
}
exitstatus = 2;
} else if (err && (pbs_errno == PBSE_UNKJOBID) && !located) {
located = TRUE;
if (locate_job(job, server, rmt_server)) {
pbs_disconnect(ct);
strcpy(server, rmt_server);
goto cnt;
}
prt_job_err("qrun", ct, job);
exitstatus = 2;
}
pbs_disconnect(ct);
} else {
fprintf(stderr,
"qrun: could not connect to server %s (%d)\n", server, pbs_errno);
exitstatus = 2;
}
}
/**
* @brief
* disables a destination (queue)
*
* @param queue - The name of the queue to disable.
* @param server - The name of the server that manages the queue.
*
* @return - Void
*
* @File Variables:
* exitstatus Set to two if an error occurs.
*
*/
static void
execute(char *queue, char *server)
{
int ct; /* Connection to the server */
int merr; /* Error return from pbs_manager */
char *errmsg; /* Error message from pbs_manager */
/* The disable request */
static struct attropl attr = {NULL, "started", NULL, "FALSE", SET};
if ((ct = cnt2server(server)) > 0) {
merr = pbs_manager(ct, MGR_CMD_SET, MGR_OBJ_QUEUE, queue, &attr, NULL);
if (merr != 0) {
errmsg = pbs_geterrmsg(ct);
if (errmsg != NULL) {
fprintf(stderr, "qstop: %s ", errmsg);
} else {
fprintf(stderr, "qstop: Error (%d) disabling queue ", pbs_errno);
}
if (notNULL(queue))
fprintf(stderr, "%s", queue);
if (notNULL(server))
fprintf(stderr, "@%s", server);
fprintf(stderr, "\n");
exitstatus = 2;
}
pbs_disconnect(ct);
} else {
fprintf(stderr, "qstop: could not connect to server %s (%d)\n", server, pbs_errno);
exitstatus = 2;
}
}
/**
* Gets the information about a job.
*
* It stores the info in a module variable.
* In order to retrieve it, use @see readJobInfo.
* @param jobid is the PID assigned by the queue
* @return 0 if correct, non-zero if error
*/
int rm_getJobInfo(struct soap* soap, char* jobid, char* user,
struct jobcard** jobInfo )
{
//! stores the status of a job
struct batch_status* status;
int connectionIdentifier;
struct jobcard* job;
connectionIdentifier = pbs_connect(server);
if(!connectionIdentifier)
return BESE_BACKEND;
status = pbs_statjob(connectionIdentifier, jobid, NULL, NULL);
pbs_disconnect(connectionIdentifier);
if(status == NULL)
return BESE_NO_ACTIVITY;
job = (struct jobcard*)soap_malloc(soap, sizeof(struct jobcard));
if (!job)
return BESE_MEM_ALLOC;
memset(job, 0, sizeof(struct jobcard));
fillJobStatusDefaults(job);
convertJobInfo(soap, job, status);
*jobInfo = job;
pbs_statfree(status);
return BESE_OK;
}
/*
* int execute( char *queue, char *server )
*
* queue The name of the queue to disable.
* server The name of the server that manages the queue.
*
* Returns:
* None
*
* File Variables:
* exitstatus Set to two if an error occurs.
*/
static void execute(
char *queue,
char *server)
{
int ct; /* Connection to the server */
int local_errno = 0;
int merr; /* Error return from pbs_manager */
char *errmsg; /* Error message from pbs_manager */
/* The disable request */
static struct attropl attr =
{
NULL, (char *)"enabled", NULL, (char *)"FALSE", SET
};
if ((ct = cnt2server(server)) > 0)
{
merr = pbs_manager_err(ct, MGR_CMD_SET, MGR_OBJ_QUEUE, queue, &attr, NULL, &local_errno);
if (merr != 0)
{
errmsg = pbs_geterrmsg(ct);
if (errmsg != NULL)
{
fprintf(stderr, "qdisable: %s ", errmsg);
free(errmsg);
}
else
{
fprintf(stderr, "qdisable: Error disabling queue: %d - %s ",
local_errno,
pbs_strerror(local_errno));
}
if (notNULL(queue))
fprintf(stderr, "%s", queue);
if (notNULL(server))
fprintf(stderr, "@%s", server);
fprintf(stderr, "\n");
exitstatus = 2;
}
pbs_disconnect(ct);
}
else
{
fprintf(stderr, "qdisable: could not connect to server %s (%d) %s\n",
server,
ct * -1,
pbs_strerror(ct * -1));
exitstatus = 2;
}
}
/**
* Prints in stderr the error message of the last error.
*
* It gets the error
* description of the last error that happened in the PBS queue server.
* @param userMessage message to append to the output. It may contain
* additional information from the main program
*/
void printError(char* userMessage)
{
char *errorMessage;
int connectionIdentifier = pbs_connect(server);
errorMessage = pbs_geterrmsg(connectionIdentifier);
pbs_disconnect(connectionIdentifier);
fprintf(stderr, "%s\n%s\n", userMessage, errorMessage);
}
int locate_job(
char *job_id,
char *parent_server,
char *located_server)
{
int connect;
int local_errno = 0;
char jid_server[PBS_MAXCLTJOBID + 1];
char *location;
if ((connect = pbs_connect(parent_server)) >= 0)
{
/* SUCCESS */
strcpy(jid_server, job_id);
if (notNULL(parent_server))
{
strcat(jid_server, "@");
strcat(jid_server, parent_server);
}
location = pbs_locjob_err(connect, jid_server, NULL, &local_errno);
if (location == NULL)
{
pbs_disconnect(connect);
return(FALSE);
}
strcpy(located_server, location);
free(location);
pbs_disconnect(connect);
return(TRUE);
}
/* FAILURE */
return(-1);
} /* END locate_job() */
/*
* void execute( char *node, char *gpuid, int ecc_perm, int ecc_vol, char *server )
*
* node The name of the MOM node.
* gpuid The id of the GPU.
* ecc_perm The value for resetting the permanent ECC count.
* ecc_vol The value for resetting the volatile ECC count.
* server The name of the server to send to.
*
* Returns:
* None
*
* File Variables:
* exitstatus Set to two if an error occurs.
*/
static void execute(
char *node,
char *gpuid,
int ecc_perm,
int ecc_vol,
const char *server)
{
int local_errno = 0;
int ct; /* Connection to the server */
int merr; /* Error return from pbs_manager */
char *errmsg; /* Error message from pbs_manager */
/* The request to change mode */
if ((ct = cnt2server(server, false)) > 0)
{
merr = pbs_gpureset_err(ct, node, gpuid, ecc_perm, ecc_vol, &local_errno);
if (merr != 0)
{
errmsg = pbs_geterrmsg(ct);
if (errmsg != NULL)
{
fprintf(stderr, " qgpureset: %s ", errmsg);
free(errmsg);
}
else
{
fprintf(stderr, " qgpureset: Error (%d - %s) resetting GPU ECC counts",
local_errno,
pbs_strerror(local_errno));
}
if (notNULL(server))
fprintf(stderr, "@%s", server);
fprintf(stderr, "\n");
exitstatus = 2;
}
pbs_disconnect(ct);
}
else
{
local_errno = -1 * ct;
fprintf(stderr, " qgpureset: could not connect to server %s (%d) %s\n",
server,
local_errno,
pbs_strerror(local_errno));
exitstatus = 2;
}
}
/**
* Gets the status of the job.
*
* It maps the different states of PBS jobs to
* pending and running. It does not make a difference between finished,
* cancelled, terminated and unknown jobs since PBS does not store this info.
* @param jobid is the PID assigned by the queue
* @return 0 if correct, non-zero if error
*/
int rm_getJobStatus(struct soap* s, char* jobid, char* user, struct bes__ActivityStatusType** jobStatus)
{
struct bes__ActivityStatusType *activityStatus;
int connectionIdentifier;
//! stores the status of a job
struct batch_status* status;
if (!jobid || !jobStatus) {
return BESE_BAD_ARG;
}
connectionIdentifier = pbs_connect(server);
if (!connectionIdentifier)
return BESE_BACKEND;
status = pbs_statjob(connectionIdentifier,jobid,NULL,NULL);
pbs_disconnect(connectionIdentifier);
if(status == NULL)
{
return BESE_NO_ACTIVITY;
}
activityStatus = (struct bes__ActivityStatusType*)soap_malloc(s, sizeof(struct bes__ActivityStatusType));
if (activityStatus == NULL) {
return BESE_MEM_ALLOC;
}
memset(activityStatus, 0, sizeof(struct bes__ActivityStatusType));
struct attrl* attrList = status->attribs;
while (attrList != NULL)
{
if(!strcmp(attrList->name, ATTR_state))
{
if(!strcmp(attrList->value, "T")) {
activityStatus->state = Pending;
}
else if(!strcmp(attrList->value, "Q")) {
activityStatus->state = Pending;
}
else if(!strcmp(attrList->value,"H")) {
activityStatus->state = Pending;
}
else if(!strcmp(attrList->value,"W")){
activityStatus->state = Pending;
}
else if(!strcmp(attrList->value,"R")){
activityStatus->state = Running;
}
else if(!strcmp(attrList->value,"E")) {
activityStatus->state = Finished;
}
pbs_statfree(status);
*jobStatus = activityStatus;
return BESE_OK;
}
attrList = attrList->next;
}
pbs_statfree(status);
return BESE_NO_ACTIVITY;
}
/**
* Terminates a job.
* @param jobid is the PID assigned by the queue
* @return 0 if correct, non-zero if error
*/
int rm_terminateJob(struct soap* s, char* jobid, char* user)
{
int connectionIdentifier = pbs_connect(server);
if (connectionIdentifier < 1 )
return BESE_BACKEND;
int rc = pbs_deljob(connectionIdentifier, jobid, NULL);
updateErrorNo();
pbs_disconnect(connectionIdentifier);
return BESE_OK;
}
static void execute(
int manner, /* I */
const char *server) /* I */
{
int ct; /* Connection to the server */
int err; /* Error return from pbs_terminate */
char *errmsg; /* Error message from pbs_terminate */
int local_errno = 0;
if ((ct = cnt2server(server)) > 0)
{
err = pbs_terminate_err(ct, manner, NULL, &local_errno);
if (err != 0)
{
errmsg = pbs_geterrmsg(ct);
if (errmsg != NULL)
{
fprintf(stderr, "qterm: %s",
errmsg);
}
else
{
fprintf(stderr, "qterm: Error (%d - %s) terminating server ",
local_errno, pbs_strerror(local_errno));
}
fprintf(stderr, "%s\n",
server);
exitstatus = 2;
}
pbs_disconnect(ct);
}
else
{
/* FAILURE */
local_errno = -1 * ct;
fprintf(stderr, "qterm: could not connect to server '%s' (%d) %s\n",
server,
local_errno,
pbs_strerror(local_errno));
exitstatus = 2;
}
return;
} /* END execute() */
/**
* Connects to the PBS queue server and loads cluster info.
* @param soap is used to allocate memory
* @param serverName is a string with the hostname in which the queue is running
* @return 0 if connection established, 1 if error
*/
int rm_initialize(struct soap* soap, char* serverName){
int connectionIdentifier;
int error_code = BESE_OK;
if (!serverName)
return BESE_BAD_ARG;
server = (char*) malloc(strlen(serverName) + 1);
nresources = (int*) malloc(sizeof(int));
strcpy(server,serverName);
connectionIdentifier = pbs_connect(serverName);
if (connectionIdentifier <= 0 )
return BESE_BACKEND;
pbs_disconnect(connectionIdentifier);
error_code = rm_getClusterInfo(soap, &clusterInfo);
if (error_code != BESE_OK)
return error_code;
else {
printf("Looking for resources now");
error_code = rm_getResourceList(soap, NULL, &resourceList, nresources);
return error_code;
}
}
/** Closes connection with DRM (if any) and destroys DRMAA session data. */
int
drmaa_destroy(drmaa_session_t *c, char *errmsg, size_t errlen)
{
int rc = 0;
if (c->pbs_conn >= 0)
rc = pbs_disconnect(c->pbs_conn);
free(c->contact);
if (c->jt_list)
{
drmaa_job_template_t *i;
for (i = c->jt_list->next; i != c->jt_list;)
{
drmaa_job_template_t *jt = i;
i = i->next;
drmaa_delete_async_job_template(jt);
}
free(c->jt_list);
}
drmaa_delete_job_hashtab(c->job_hashtab);
pthread_mutex_destroy(&c->conn_mutex);
pthread_mutex_destroy(&c->jobs_mutex);
free(c);
if (rc)
RAISE_PBS();
return DRMAA_ERRNO_SUCCESS;
}
/**
* @brief
* handles attribute errors and prints appropriate errmsg
*
* @param[in] connect - value indicating server connection
* @param[in] err_list - list of possible attribute errors
*
* @return - Void
*
*/
static void
handle_attribute_errors(int connect,
struct ecl_attribute_errors *err_list)
{
struct attropl *attribute;
char * opt;
int i;
for (i=0; i<err_list->ecl_numerrors; i++) {
attribute = err_list->ecl_attrerr[i].ecl_attribute;
if (strcmp(attribute->name, ATTR_h) == 0)
opt="h";
else
return;
fprintf(stderr, "qhold: illegal -%s value\n", opt);
print_usage();
pbs_disconnect(connect);
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(2);
}
}
int main(
int argc,
char **argv) /* qmsg */
{
int c;
int to_file;
int errflg = 0;
int any_failed = 0;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME] = "";
char rmt_server[MAXSERVERNAME];
#define MAX_MSG_STRING_LEN 256
char msg_string[MAX_MSG_STRING_LEN+1];
#define GETOPT_ARGS "EO"
msg_string[0] = '\0';
to_file = 0;
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
switch (c)
{
case 'E':
to_file |= MSG_ERR;
break;
case 'O':
to_file |= MSG_OUT;
break;
default :
errflg++;
}
if (to_file == 0) to_file = MSG_ERR; /* default */
if (errflg || ((optind + 1) >= argc))
{
static char usage[] =
"usage: qmsg [-O] [-E] msg_string job_identifier...\n";
fprintf(stderr,"%s", usage);
exit(2);
}
snprintf(msg_string, sizeof(msg_string), "%s", argv[optind]);
for (optind++; optind < argc; optind++)
{
int connect;
int stat = 0;
int located = FALSE;
std::string server_name;
std::vector<std::string> id_list;
snprintf(job_id, sizeof(job_id), "%s", argv[optind]);
if (get_server_and_job_ids(job_id, id_list, server_name))
{
fprintf(stderr, "qmsg: illegally formed job identifier: %s\n", job_id);
any_failed = 1;
continue;
}
snprintf(server_out, sizeof(server_out), "%s", server_name.c_str());
cnt:
connect = cnt2server(server_out, false);
if (connect <= 0)
{
any_failed = -1 * connect;
if (server_out[0] != 0)
fprintf(stderr, "qmsg: cannot connect to server %s (errno=%d) %s\n",
server_out, any_failed, pbs_strerror(any_failed));
else
fprintf(stderr, "qmsg: cannot connect to server %s (errno=%d) %s\n",
pbs_server, any_failed, pbs_strerror(any_failed));
continue;
}
for (size_t i = 0; i < id_list.size(); i++)
{
snprintf(job_id_out, sizeof(job_id_out), "%s", id_list[i].c_str());
stat = pbs_msgjob_err(connect, job_id_out, to_file, msg_string, NULL, &any_failed);
if (any_failed != PBSE_UNKJOBID)
break;
}
if (stat && (any_failed != PBSE_UNKJOBID))
{
prt_job_err("qmsg", connect, job_id_out);
}
else if (stat && (any_failed == PBSE_UNKJOBID) && !located)
{
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server))
{
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qmsg", connect, job_id_out);
}
pbs_disconnect(connect);
}
exit(any_failed);
}
int
main(int argc, char **argv, char **envp) /* qrls */
{
int c;
int errflg=0;
int any_failed=0;
int u_cnt, o_cnt, s_cnt, n_cnt, p_cnt;
char *pc;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME];
char rmt_server[MAXSERVERNAME];
#define MAX_HOLD_TYPE_LEN 32
char hold_type[MAX_HOLD_TYPE_LEN+1];
#define GETOPT_ARGS "h:"
/*test for real deal or just version and exit*/
execution_mode(argc, argv);
#ifdef WIN32
winsock_init();
#endif
hold_type[0]='\0';
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
switch (c) {
case 'h':
while (isspace((int)*optarg)) optarg++;
if (strlen(optarg) == 0) {
fprintf(stderr, "qrls: illegal -h value\n");
errflg++;
break;
}
pc = optarg;
u_cnt = o_cnt = s_cnt = n_cnt = p_cnt = 0;
while (*pc) {
if (*pc == 'u')
u_cnt++;
else if (*pc == 'o')
o_cnt++;
else if (*pc == 's')
s_cnt++;
else if (*pc == 'p')
p_cnt++;
else if (*pc == 'n')
n_cnt++;
else {
fprintf(stderr, "qrls: illegal -h value\n");
errflg++;
break;
}
pc++;
}
if (n_cnt && (u_cnt + o_cnt + s_cnt + p_cnt)) {
fprintf(stderr, "qrls: illegal -h value\n");
errflg++;
break;
}
strcpy(hold_type, optarg);
break;
default :
errflg++;
}
if (errflg || optind >= argc) {
static char usage[]="usage: qrls [-h hold_list] job_identifier...\n";
static char usag2[]=" qrls --version\n";
fprintf(stderr, "%s", usage);
fprintf(stderr, "%s", usag2);
exit(2);
}
/*perform needed security library initializations (including none)*/
if (CS_client_init() != CS_SUCCESS) {
fprintf(stderr, "qrls: unable to initialize security library.\n");
exit(1);
}
for (; optind < argc; optind++) {
int connect;
int stat=0;
int located = FALSE;
strcpy(job_id, argv[optind]);
if (get_server(job_id, job_id_out, server_out)) {
fprintf(stderr, "qrls: illegally formed job identifier: %s\n", job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0) {
fprintf(stderr, "qrls: cannot connect to server %s (errno=%d)\n",
pbs_server, pbs_errno);
any_failed = pbs_errno;
continue;
}
stat = pbs_rlsjob(connect, job_id_out, hold_type, NULL);
if (stat && (pbs_errno != PBSE_UNKJOBID)) {
prt_job_err("qrls", connect, job_id_out);
any_failed = pbs_errno;
} else if (stat && (pbs_errno == PBSE_UNKJOBID) && !located) {
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server)) {
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qrls", connect, job_id_out);
any_failed = pbs_errno;
}
pbs_disconnect(connect);
}
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(any_failed);
}
int main(
int argc, /* I */
char **argv) /* I */
{
int c;
int errflg = 0;
int any_failed = 0;
int u_cnt, o_cnt, s_cnt;
char *pc;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME] = "";
char rmt_server[MAXSERVERNAME];
char extend[MAXPATHLEN];
#define MAX_HOLD_TYPE_LEN 32
char hold_type[MAX_HOLD_TYPE_LEN+1];
#define GETOPT_ARGS "h:t:"
hold_type[0] = '\0';
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
{
switch (c)
{
case 'h':
while (isspace((int)*optarg))
optarg++;
if (strlen(optarg) == 0)
{
fprintf(stderr, "qrls: illegal -h value\n");
errflg++;
break;
}
pc = optarg;
u_cnt = o_cnt = s_cnt = 0;
while (*pc)
{
if (*pc == 'u')
u_cnt++;
else if (*pc == 'o')
o_cnt++;
else if (*pc == 's')
s_cnt++;
else
{
fprintf(stderr, "qrls: illegal -h value\n");
errflg++;
break;
}
pc++;
}
strcpy(hold_type, optarg);
break;
case 't':
pc = optarg;
if (strlen(pc) == 0)
{
fprintf(stderr, "qrls: illegal -t value (array range cannot be zero length)\n");
errflg++;
break;
}
snprintf(extend,sizeof(extend),"%s%s",
ARRAY_RANGE,
pc);
break;
default:
errflg++;
break;
}
}
if (errflg || optind >= argc)
{
static char usage[] = "usage: qrls [-h {uos}] [-t array_range] job_identifier...\n";
fprintf(stderr,"%s", usage);
exit(2);
}
for (;optind < argc;optind++)
{
int connect;
int stat = 0;
int located = FALSE;
snprintf(job_id, sizeof(job_id), "%s", argv[optind]);
if (get_server(job_id, job_id_out, sizeof(job_id_out), server_out, sizeof(server_out)))
{
fprintf(stderr, "qrls: illegally formed job identifier: %s\n",
job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0)
{
any_failed = -1 * connect;
if (server_out[0] != 0)
fprintf(stderr, "qrls: cannot connect to server %s (errno=%d) %s\n",
server_out,
any_failed,
pbs_strerror(any_failed));
else
fprintf(stderr, "qrls: cannot connect to server %s (errno=%d) %s\n",
pbs_server,
any_failed,
pbs_strerror(any_failed));
continue;
}
stat = pbs_rlsjob_err(connect, job_id_out, hold_type, extend, &any_failed);
if (stat &&
(any_failed != PBSE_UNKJOBID))
{
prt_job_err("qrls", connect, job_id_out);
}
else if (stat &&
(any_failed != PBSE_UNKJOBID) &&
!located)
{
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server))
{
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qrls", connect, job_id_out);
}
pbs_disconnect(connect);
} /* END for () */
exit(any_failed);
/*NOTREACHED*/
return(0);
} /* END main() */
static void execute(
char *job, /* I */
char *server, /* I */
char *location, /* I */
int async) /* I */
{
int ct; /* Connection to the server */
int err; /* Error return from pbs_run */
int located = FALSE;
char rmt_server[MAXSERVERNAME];
int local_errno = 0;
cnt:
if ((ct = cnt2server(server)) > 0)
{
if (async == TRUE)
{
err = pbs_asyrunjob_err(ct, job, location, NULL, &local_errno); /* see lib/Libifl/pbsD_runjob.c */
}
else
{
err = pbs_runjob_err(ct, job, location, NULL, &local_errno); /* see lib/Libifl/pbsD_runjob.c */
}
if (err && (local_errno == PBSE_UNKNODE))
{
fprintf(stderr, "qrun: Unknown node in hostlist '%.16s...' for job %s\n",
location,
job);
exitstatus = 2;
}
else if (err && (local_errno != PBSE_UNKJOBID))
{
prt_job_err("qrun", ct, job);
exitstatus = 2;
}
else if (err && (local_errno == PBSE_UNKJOBID) && !located)
{
located = TRUE;
if (locate_job(job, server, rmt_server))
{
pbs_disconnect(ct);
strcpy(server, rmt_server);
goto cnt;
}
prt_job_err("qrun", ct, job);
exitstatus = 2;
}
pbs_disconnect(ct);
}
else
{
fprintf(stderr, "qrun: could not connect to server %s (%d) %s\n",
server,
ct * -1,
pbs_strerror(ct * -1));
exitstatus = 2;
}
return;
} /* END execute() */
/**
* Gets the factory attributes.
*
* This function uses @see loadResourceFile
* and also queries the PBS queue.
* @param soap is needed to allocate memory that can be deallocated by the
* gsoap library after.
* @param clusterInf a struct of type clusterInfo with the information needed for the
* factory attributes document
*/
int rm_getClusterInfo(struct soap*soap, struct rm_clusterInfo** clusterInf
/*,int compactResources*/)
{
char outputFile[256];
FILE* fd;
int rc;
char resource[128];
int connectionIdentifier = pbs_connect(server);
struct rm_clusterInfo* clusterInfo;
struct rm_resource* resourcesInfo;
struct batch_status* status;
if (!clusterInf) {
return BESE_BAD_ARG;
}
clusterInfo = (struct rm_clusterInfo*) soap_malloc(soap,
sizeof(struct rm_clusterInfo));
if (clusterInfo == NULL)
return BESE_MEM_ALLOC;
memset(clusterInfo, 0, sizeof(struct rm_clusterInfo));
//First, contact the PBS queue
status = pbs_statserver(connectionIdentifier,NULL,NULL);
if(status != NULL)
{
//Loop over the list of attributes returned
struct attrl* attributeList = status->attribs;
while(attributeList != NULL)
{
//Server_host for the CommonName element
if(!strcmp(attributeList->name, "server_host"))
{
clusterInfo->CommonName = soap_strdup(soap,
attributeList->value);
}
//Server_state for the IsAcceptingNewActivities element
else if(!strcmp(attributeList->name, "server_state"))
{
if(!strcmp(attributeList->value, "Active"))
clusterInfo->IsAcceptingNewActivities = true_;
else
clusterInfo->IsAcceptingNewActivities = false_;
}//total_jobs for the TotalNumberOfActivities element
else if(!strcmp(attributeList->name, "total_jobs"))
{
//clusterInfo->TotalNumberOfActivities =
// atoi(attributeList->value);
}//pbs_version for the LocalResourceManagerType element
else if(!strcmp(attributeList->name, "pbs_version"))
{
char* pbsStr = (char*) soap_malloc(soap, strlen(PBS) +
strlen(attributeList->value) + 10);
sprintf(pbsStr, "%s %s %s", PBS, "Version", attributeList->value);
clusterInfo->LocalResourceManagerType = pbsStr;
}
//fprintf(stderr,"Attribute: %s - Value: %s\n",attributeList->name,attributeList->value);
attributeList = attributeList->next;
}
}
pbs_statfree(status);
pbs_disconnect(connectionIdentifier);
*clusterInf = clusterInfo;
return BESE_OK;
}
int main(
int argc,
char **argv) /* qrerun */
{
int any_failed = 0;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[PBS_MAXSERVERNAME] = "";
char rmt_server[MAXSERVERNAME];
char extend[1024];
int errflg = 0;
int c;
static char usage[] = "usage: qrerun [-f] <JOBID>[ <JOBID>]...\n";
if (argc < 2)
{
fprintf(stderr,"%s", usage);
exit(2);
}
#define GETOPT_ARGS "m:f"
extend[0] = '\0';
while ((c = (char) getopt(argc, argv, GETOPT_ARGS)) != EOF)
{
switch (c)
{
case 'm':
/* add delete message */
if (extend[0] != '\0')
{
/* extension option already specified */
errflg++;
break;
}
if (strchr(optarg, '='))
{
/* message cannot contain '=' character */
errflg++;
break;
}
strncpy(extend, optarg, sizeof(extend));
break;
case 'f':
if (extend[0] != '\0')
{
errflg++;
break;
}
strcpy(extend, RERUNFORCE);
break;
} /* END switch (c) */
} /* END while ((c = getopt(argc,argv,GETOPT_ARGS)) != EOF) */
if ((errflg != 0) || (optind >= argc))
{
fprintf(stderr,"%s", usage);
exit(2);
}
for (;optind < argc;optind++)
{
int connect;
int stat = 0;
int located = FALSE;
snprintf(job_id, sizeof(job_id), "%s", argv[optind]);
if (get_server(job_id, job_id_out, sizeof(job_id_out), server_out, sizeof(server_out)))
{
fprintf(stderr, "qrerun: illegally formed job identifier: %s\n",
job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0)
{
any_failed = -1 * connect;
if (server_out[0] != 0)
fprintf(stderr, "qrerun: cannot connect to server %s (errno=%d) %s\n",
server_out,
any_failed,
pbs_strerror(any_failed));
else
fprintf(stderr, "qrerun: cannot connect to server %s (errno=%d) %s\n",
pbs_server,
any_failed,
pbs_strerror(any_failed));
continue;
}
if (extend[0] != '\0')
stat = pbs_rerunjob_err(connect, job_id_out, extend, &any_failed);
else
stat = pbs_rerunjob_err(connect, job_id_out, NULL, &any_failed);
if (stat && (any_failed != PBSE_UNKJOBID))
{
prt_job_err("qrerun", connect, job_id_out);
}
else if (stat && (any_failed == PBSE_UNKJOBID) && !located)
{
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server))
{
pbs_disconnect(connect);
snprintf(server_out, sizeof(server_out), "%s", rmt_server);
goto cnt;
}
prt_job_err("qrerun", connect, job_id_out);
}
pbs_disconnect(connect);
}
exit(any_failed);
} /* END main() */
/**
* @brief
* handles attribute errors and prints appropriate errmsg
*
* @param[in] connect - value indicating server connection
* @param[in] err_list - list of possible attribute errors
* @param[in] id - corresponding id(string) for attribute error
*
* @return - Void
*
*/
static void
handle_attribute_errors(int connect,
struct ecl_attribute_errors *err_list, char *id)
{
struct attropl *attribute;
char * opt;
int i;
for (i=0; i<err_list->ecl_numerrors; i++) {
attribute = err_list->ecl_attrerr[i].ecl_attribute;
if (strcmp(attribute->name, ATTR_a) == 0)
opt="a";
else if (strcmp(attribute->name, ATTR_A) == 0)
opt="A";
else if (strcmp(attribute->name, ATTR_project) == 0)
opt = "P";
else if (strcmp(attribute->name, ATTR_c) == 0)
opt="c";
else if (strcmp(attribute->name, ATTR_e) == 0)
opt="e";
else if (strcmp(attribute->name, ATTR_h) == 0)
opt="h";
else if (strcmp(attribute->name, ATTR_j)==0)
opt="j";
else if (strcmp(attribute->name, ATTR_k)==0)
opt="k";
else if (strcmp(attribute->name, ATTR_l)==0) {
opt="l";
fprintf(stderr, "qalter: %s %s\n",
err_list->ecl_attrerr[i].ecl_errmsg, id);
exit(err_list->ecl_attrerr[i].ecl_errcode);
}
else if (strcmp(attribute->name, ATTR_m)==0)
opt="m";
else if (strcmp(attribute->name, ATTR_M)==0)
opt="M";
else if (strcmp(attribute->name, ATTR_N)==0)
opt="N";
else if (strcmp(attribute->name, ATTR_o)==0)
opt="o";
else if (strcmp(attribute->name, ATTR_p)==0)
opt="p";
else if (strcmp(attribute->name, ATTR_r)==0)
opt="r";
else if (strcmp(attribute->name, ATTR_R)==0)
opt="R";
else if (strcmp(attribute->name, ATTR_S)==0)
opt="S";
else if (strcmp(attribute->name, ATTR_u)==0)
opt="u";
else if ((strcmp(attribute->name, ATTR_depend)==0) ||
(strcmp(attribute->name, ATTR_stagein)==0) ||
(strcmp(attribute->name, ATTR_stageout)==0) ||
(strcmp(attribute->name, ATTR_sandbox)==0) ||
(strcmp(attribute->name, ATTR_umask) == 0) ||
(strcmp(attribute->name, ATTR_runcount) == 0) ||
(strcmp(attribute->name, ATTR_g)==0))
opt="W";
else
return;
pbs_disconnect(connect);
CS_close_app();
if (err_list->ecl_attrerr->ecl_errcode == PBSE_JOBNBIG)
fprintf(stderr, "qalter: Job %s \n", err_list->ecl_attrerr->ecl_errmsg);
else {
fprintf(stderr, "qalter: illegal -%s value\n", opt);
print_usage();
}
exit(2);
}
}
int main(int argc, char **argv) {
char *server = NULL;
char *jobid = NULL;
char *var = NULL;
char *value = NULL;
int server_fd = 0;
int ret = 0;
int c = 0;
struct batch_status *job = NULL;
struct attrl *attribute = NULL;
char *var_string = NULL;
struct option prg_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
};
for ( ; ; ) {
int option_index = 0;
c = getopt_long(argc, argv, "s:hV",
prg_options, &option_index
);
if (c == -1) break;
switch (c) {
case 'h':
usage(0);
break;
case 'V':
printf("qsetenv version: %s; for torque version %s\n", QSETENV_VERSION, TORQUE_VERSION);
exit(0);
break;
case 's':
server = optarg;
break;
}
}
for (c = optind; c != argc; c++) {
switch (c-optind) {
case 0:
jobid = argv[c];
break;
case 1:
var = argv[c];
break;
case 2:
value = argv[c];
break;
default:
printf("Too many arguments!\n");
usage(1);
break;
}
}
if (value == NULL) {
printf("Too few arguments!\n");
usage(1);
}
if (server == NULL) {
server = pbs_get_server_list();
}
char *tok_server = server;
char *tgt_server = NULL;
while ((tgt_server = strtok(tok_server, ",")) != NULL) {
tok_server = NULL;
server_fd = pbs_connect(tgt_server);
if (server_fd > 0) {
break;
}
}
if (server_fd <= 0) {
fprintf(stderr, "Failed to connect to PBS server!\n");
exit(1);
}
printf("Querying job %s\n", jobid);
job = pbs_statjob(server_fd, jobid, NULL, 0);
if (job != NULL) {
printf("job name: %s\n", job->name);
var_string = job_setenv_varstr(job, var, value);
attribute = (struct attrl *) malloc(sizeof(struct attrl));
memset(attribute, 0, sizeof(struct attrl));
attribute->name = ATTR_v;
attribute->value = var_string;
attribute->next = NULL;
ret = pbs_alterjob(server_fd, jobid, attribute, NULL);
if (ret != 0) {
printf("Got error: %s\n", pbs_strerror(pbs_errno));
}
free(attribute);
attribute = NULL;
}
if (var_string != NULL) {
free(var_string);
}
if (job != NULL) {
pbs_statfree(job);
job = NULL;
}
pbs_disconnect(server_fd);
if (ret != 0) {
return 1;
}
return 0;
}
int main(int argc, char **argv) /* qchkpt */
{
int any_failed = 0;
static char usage[] = "Usage: qchkpt job_id ...\n";
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID] = "";
char server_out[MAXSERVERNAME] = "";
char rmt_server[MAXSERVERNAME] = "";
if (argc == 1)
{
fprintf(stderr, "%s", usage);
return 1;
}
initialize_network_info();
for (optind = 1; optind < argc; optind++)
{
int connect;
int stat = 0;
int located = FALSE;
snprintf(job_id, sizeof(job_id), "%s", argv[optind]);
if (get_server(job_id, job_id_out, sizeof(job_id_out), server_out, sizeof(server_out)))
{
fprintf(stderr, "qchkpt: illegally formed job identifier: %s\n", job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0)
{
any_failed = -1 * connect;
if (server_out[0] != '\0')
fprintf(stderr, "qchkpt: cannot connect to server %s (errno=%d)\n",
server_out, any_failed);
else
fprintf(stderr, "qchkpt: cannot connect to server %s (errno=%d)\n",
pbs_server, any_failed);
continue;
}
stat = pbs_checkpointjob_err(connect, job_id_out, NULL, &any_failed);
if (stat &&
(any_failed != PBSE_UNKJOBID))
{
prt_job_err("qchkpt", connect, job_id_out);
}
else if (stat &&
(any_failed == PBSE_UNKJOBID) &&
!located)
{
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server))
{
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qchkpt", connect, job_id_out);
}
pbs_disconnect(connect);
}
return any_failed;
}
int
main(int argc, char **argv, char **envp) /* qselect */
{
int c;
int errflg=0;
char *errmsg;
#define MAX_OPTARG_LEN 256
#define MAX_RESOURCE_NAME_LEN 256
char optargout[MAX_OPTARG_LEN+1];
char resource_name[MAX_RESOURCE_NAME_LEN+1];
enum batch_op op;
enum batch_op *pop = &op;
struct attropl *select_list = 0;
static char destination[PBS_MAXQUEUENAME+1] = "";
char server_out[MAXSERVERNAME] = "";
char *queue_name_out;
char *server_name_out;
int connect;
char **selectjob_list;
char *res_pos;
char *pc;
time_t after;
char a_value[80];
char extendopts[4] = "";
char *attr_time = NULL;
struct ecl_attribute_errors *err_list;
char *resc_time = NULL;
#define GETOPT_ARGS "a:A:c:h:HJl:N:p:q:r:s:t:Tu:xP:"
/*test for real deal or just version and exit*/
execution_mode(argc, argv);
#ifdef WIN32
winsock_init();
#endif
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
switch (c) {
case 'a':
check_op(optarg, pop, optargout);
if ((after = cvtdate(optargout)) < 0) {
fprintf(stderr, "qselect: illegal -a value\n");
errflg++;
break;
}
sprintf(a_value, "%ld", (long)after);
set_attrop(&select_list, ATTR_a, NULL, a_value, op);
break;
case 'c':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)*pc)) pc++;
if (strlen(pc) == 0) {
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
set_attrop(&select_list, ATTR_c, NULL, optargout, op);
break;
case 'h':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)*pc)) pc++;
set_attrop(&select_list, ATTR_h, NULL, optargout, op);
break;
case 'J':
op = EQ;
set_attrop(&select_list, ATTR_array, NULL, "True", op);
break;
case 'l':
res_pos = optarg;
while (*res_pos != '\0') {
if (check_res_op(res_pos, resource_name, pop, optargout, &res_pos) != 0) {
errflg++;
break;
}
set_attrop(&select_list, ATTR_l, resource_name, optargout, op);
}
break;
case 'p':
check_op(optarg, pop, optargout);
set_attrop(&select_list, ATTR_p, NULL, optargout, op);
break;
case 'q':
strcpy(destination, optarg);
check_op(optarg, pop, optargout);
set_attrop(&select_list, ATTR_q, NULL, optargout, op);
break;
case 'r':
op = EQ;
pc = optarg;
while (isspace((int)(*pc))) pc++;
if (*pc != 'y' && *pc != 'n') { /* qselect specific check - stays */
fprintf(stderr, "qselect: illegal -r value\n");
errflg++;
break;
}
set_attrop(&select_list, ATTR_r, NULL, pc, op);
break;
case 's':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)(*pc))) pc++;
set_attrop(&select_list, ATTR_state, NULL, optargout, op);
break;
case 't':
if (get_tsubopt(*optarg, &attr_time, &resc_time)) {
fprintf(stderr, "qselect: illegal -t value\n");
errflg++;
break;
}
/* 1st character possess the subopt, so send optarg++ */
optarg ++;
check_op(optarg, pop, optargout);
if ((after = cvtdate(optargout)) < 0) {
fprintf(stderr, "qselect: illegal -t value\n");
errflg++;
break;
}
sprintf(a_value, "%ld", (long)after);
set_attrop(&select_list, attr_time, resc_time, a_value, op);
break;
case 'T':
if (strchr(extendopts, (int)'T') == NULL)
(void)strcat(extendopts, "T");
break;
case 'x':
if (strchr(extendopts, (int)'x') == NULL)
(void)strcat(extendopts, "x");
break;
case 'H':
op = EQ;
if (strchr(extendopts, (int)'x') == NULL)
(void)strcat(extendopts, "x");
set_attrop(&select_list, ATTR_state, NULL, "FM", op);
break;
case 'u':
op = EQ;
set_attrop(&select_list, ATTR_u, NULL, optarg, op);
break;
case 'A':
op = EQ;
set_attrop(&select_list, ATTR_A, NULL, optarg, op);
break;
case 'P':
op = EQ;
set_attrop(&select_list, ATTR_project, NULL, optarg, op);
break;
case 'N':
op = EQ;
set_attrop(&select_list, ATTR_N, NULL, optarg, op);
break;
default :
errflg++;
}
if (errflg || (optind < argc)) {
print_usage();
exit(2);
}
if (notNULL(destination)) {
if (parse_destination_id(destination, &queue_name_out, &server_name_out)) {
fprintf(stderr, "qselect: illegally formed destination: %s\n", destination);
exit(2);
} else {
if (notNULL(server_name_out)) {
strcpy(server_out, server_name_out);
}
}
}
/*perform needed security library initializations (including none)*/
if (CS_client_init() != CS_SUCCESS) {
fprintf(stderr, "qselect: unable to initialize security library.\n");
exit(2);
}
connect = cnt2server(server_out);
if (connect <= 0) {
fprintf(stderr, "qselect: cannot connect to server %s (errno=%d)\n",
pbs_server, pbs_errno);
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(pbs_errno);
}
if (extendopts[0] == '\0')
selectjob_list = pbs_selectjob(connect, select_list, NULL);
else
selectjob_list = pbs_selectjob(connect, select_list, extendopts);
if (selectjob_list == NULL) {
if ((err_list = pbs_get_attributes_in_error(connect)))
handle_attribute_errors(err_list);
if (pbs_errno != PBSE_NONE) {
errmsg = pbs_geterrmsg(connect);
if (errmsg != NULL) {
fprintf(stderr, "qselect: %s\n", errmsg);
} else {
fprintf(stderr, "qselect: Error (%d) selecting jobs\n", pbs_errno);
}
/*
* If the server is not configured for history jobs i.e.
* job_history_enable svr attr is unset/set to FALSE, qselect
* command with -x/-H option is being used, then pbs_selectjob()
* will return PBSE_JOBHISTNOTSET error code. But command will
* exit with exit code '0'after printing the corresponding error
* message. i.e. "job_history_enable is set to false"
*/
if (pbs_errno == PBSE_JOBHISTNOTSET)
pbs_errno = 0;
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(pbs_errno);
}
} else { /* got some jobs ids */
int i = 0;
while (selectjob_list[i] != NULL) {
printf("%s\n", selectjob_list[i++]);
}
free(selectjob_list);
}
pbs_disconnect(connect);
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(0);
}
int main(
int argc, /* I */
char **argv) /* I */
{
char job_id1[PBS_MAXCLTJOBID+1]; /* from the command line */
char job_id2[PBS_MAXCLTJOBID+1]; /* from the command line */
char job_id1_out[PBS_MAXCLTJOBID+1];
char job_id2_out[PBS_MAXCLTJOBID+1];
char *pn;
int port1 = 0;
int port2 = 0;
char server_out1[MAXSERVERNAME+1];
char server_out2[MAXSERVERNAME+1];
char svrtmp[MAXSERVERNAME+1] = "";
int connect;
int stat = 0;
int rc = 0;
int local_errno = 0;
if (argc != 3)
{
static char usage[] = "usage: qorder job_identifier job_identifier\n";
fprintf(stderr, "%s",
usage);
exit(2);
}
snprintf(job_id1, sizeof(job_id1), "%s", argv[1]);
snprintf(job_id2, sizeof(job_id2), "%s", argv[2]);
svrtmp[0] = '\0';
if (get_server(job_id1, job_id1_out, sizeof(job_id1_out), svrtmp, sizeof(svrtmp)))
{
fprintf(stderr, "qorder: illegally formed job identifier: %s\n",
job_id1);
exit(1);
}
if (*svrtmp == '\0')
{
if ((pn = pbs_default()))
{
strcpy(svrtmp, pn);
}
else
{
fprintf(stderr, "qorder: could not get default server: %s\n",
job_id1);
exit(1);
}
}
if ((pn = strchr(svrtmp, (int)':')) != 0)
{
*pn = '\0';
port1 = atoi(pn + 1);
}
if (get_fullhostname(svrtmp, server_out1, MAXSERVERNAME, NULL) != 0)
{
fprintf(stderr, "qorder: invalid server name: %s\n",
job_id1);
exit(1);
}
svrtmp[0] = '\0';
if (get_server(job_id2, job_id2_out, sizeof(job_id2_out), svrtmp, sizeof(svrtmp)))
{
fprintf(stderr, "qorder: illegally formed job identifier: %s\n",
job_id2);
exit(1);
}
if (*svrtmp == '\0')
{
if ((pn = pbs_default()))
{
snprintf(svrtmp, sizeof(svrtmp), "%s", pn);
}
else
{
fprintf(stderr, "qorder: could not get default server: %s\n",
job_id1);
exit(1);
}
}
if ((pn = strchr(svrtmp, (int)':')) != 0)
{
*pn = '\0';
port2 = atoi(pn + 1);
}
if (get_fullhostname(svrtmp, server_out2, MAXSERVERNAME, NULL) != 0)
{
fprintf(stderr, "qorder: invalid server name: %s\n",
job_id2);
exit(1);
}
if ((strcmp(server_out1, server_out2) != 0) || (port1 != port2))
{
fprintf(stderr, "qorder: both jobs ids must specify the same server\n");
exit(1);
}
if (pn != NULL)
*pn = ':'; /* restore : if it was present */
connect = cnt2server(svrtmp);
if (connect <= 0)
{
local_errno = -1 * connect;
if (svrtmp[0] != 0)
fprintf(stderr, "qorder: cannot connect to server %s (errno=%d) %s\n",
svrtmp,
local_errno,
pbs_strerror(local_errno));
else
fprintf(stderr, "qorder: cannot connect to server %s (errno=%d) %s\n",
pbs_server,
local_errno,
pbs_strerror(local_errno));
exit(1);
}
stat = pbs_orderjob_err(connect, job_id1_out, job_id2_out, NULL, &local_errno);
if (stat != 0)
{
prt_job_err("qorder", connect, "");
rc = local_errno;
}
pbs_disconnect(connect);
exit(rc);
} /* END main() */
int main(
int argc, /* I */
char **argv) /* I */
{
struct batch_status *bstatus = NULL;
int con;
char *specified_server = NULL;
int errflg = 0;
int i;
extern char *optarg;
extern int optind;
char **pa;
struct batch_status *pbstat;
int flag = ALLI;
char *note = NULL;
enum note_flags note_flag = unused;
char **nodeargs = NULL;
int lindex;
enum NStateEnum ListType = tnsNONE;
/* get default server, may be changed by -s option */
progname = strdup(argv[0]);
while ((i = getopt(argc, argv, "acdlopqrs:x-:N:n")) != EOF)
{
switch (i)
{
case 'a':
flag = ALLI;
break;
case 'c':
flag = CLEAR;
break;
case 'd':
flag = DIAG;
break;
case 'l':
flag = LIST;
break;
case 'o':
flag = OFFLINE;
break;
case 'p':
flag = PURGE;
break;
case 'q':
quiet = 1;
break;
case 'r':
flag = RESET;
break;
case 's':
specified_server = optarg;
break;
case 'x':
flag = ALLI;
DisplayXML = TRUE;
break;
case 'N':
/* preserve any previous option other than the default,
* to allow -N to be combined with -o, -c, etc
*/
if (flag == ALLI)
flag = NOTE;
note = strdup(optarg);
if (note == NULL)
{
perror("Error: strdup() returned NULL");
exit(1);
}
note_flag = set;
/* -N n is the same as -N "" -- it clears the note */
if (!strcmp(note, "n"))
*note = '\0';
if (strlen(note) > MAX_NOTE)
{
fprintf(stderr, "Warning: note exceeds length limit (%d) - server may reject it...\n",
MAX_NOTE);
}
if (strchr(note, '\n') != NULL)
fprintf(stderr, "Warning: note contains a newline - server may reject it...\n");
break;
case 'n':
note_flag = list;
break;
case '-':
if ((optarg != NULL) && !strcmp(optarg, "version"))
{
fprintf(stderr, "Version: %s\nRevision: %s\n",
PACKAGE_VERSION, SVN_VERSION);
exit(0);
}
else if ((optarg != NULL) && !strcmp(optarg, "about"))
{
TShowAbout_exit();
}
errflg = 1;
break;
case '?':
default:
errflg = 1;
break;
} /* END switch (i) */
} /* END while (i = getopt()) */
if ((note_flag == list) && (flag != LIST))
{
fprintf(stderr, "Error: -n requires -l\n");
errflg = 1;
}
for (pa = argv + optind;*pa;pa++)
{
if (strlen(*pa) == 0)
{
errflg = 1;
}
}
if (errflg != 0)
{
if (!quiet)
{
fprintf(stderr, "usage:\t%s [-{c|d|l|o|p|r}] [-s server] [-n] [-N \"note\"] [-q] node ...\n",
progname);
fprintf(stderr, "\t%s [-{a|x}] [-s server] [-q] [node]\n",
progname);
}
exit(1);
}
con = cnt2server(specified_server);
if (con <= 0)
{
if (!quiet)
{
fprintf(stderr, "%s: cannot connect to server %s, error=%d (%s)\n",
progname,
(specified_server) ? specified_server : pbs_default(),
con * -1,
pbs_strerror(con * -1));
}
exit(1);
}
/* if flag is ALLI, LIST, get status of all nodes */
if ((flag == ALLI) || (flag == LIST) || (flag == DIAG))
{
if ((flag == ALLI) || (flag == LIST) || (flag == DIAG))
{
if (flag == LIST)
{
/* allow state specification */
if (argv[optind] != NULL)
{
for (lindex = 1;lindex < tnsLAST;lindex++)
{
if (!strcasecmp(NState[lindex], argv[optind]))
{
ListType = lindex;
optind++;
break;
}
}
}
}
/* allow node specification (if none, then create an empty list) */
if (argv[optind] != NULL)
{
nodeargs = argv + optind;
}
else
{
nodeargs = calloc(2, sizeof(char **));
nodeargs[0] = strdup("");
nodeargs[1] = '\0';
}
}
}
if ((note_flag == set) && (note != NULL))
{
/* set the note attrib string on specified nodes */
for (pa = argv + optind;*pa;pa++)
{
set_note(con, *pa, note);
}
}
switch (flag)
{
case DIAG:
/* NYI */
break;
case CLEAR:
/* clear OFFLINE from specified nodes */
for (pa = argv + optind;*pa;pa++)
{
marknode(con, *pa, ND_offline, DECR, NULL, DECR);
}
break;
case RESET:
/* clear OFFLINE, add DOWN to specified nodes */
for (pa = argv + optind;*pa;pa++)
{
marknode(con, *pa, ND_offline, DECR, ND_down, INCR);
}
break;
case OFFLINE:
/* set OFFLINE on specified nodes */
for (pa = argv + optind;*pa;pa++)
{
marknode(con, *pa, ND_offline, INCR, NULL, INCR);
}
break;
case PURGE:
/* remove node record */
/* NYI */
break;
case ALLI:
if (DisplayXML == TRUE)
{
char *tmpBuf = NULL, *tail = NULL;
int bufsize;
mxml_t *DE;
DE = NULL;
MXMLCreateE(&DE, "Data");
for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
{
bstatus = statnode(con, nodeargs[lindex]);
for (pbstat = bstatus;pbstat;pbstat = pbstat->next)
{
addxmlnode(DE, pbstat);
} /* END for (pbstat) */
pbs_statfree(pbstat);
}
MXMLToXString(DE, &tmpBuf, &bufsize, INT_MAX, &tail, TRUE);
MXMLDestroyE(&DE);
fprintf(stdout, "%s\n",
tmpBuf);
}
else
{
for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
{
bstatus = statnode(con, nodeargs[lindex]);
for (pbstat = bstatus;pbstat;pbstat = pbstat->next)
{
printf("%s\n",
pbstat->name);
prt_node_attr(pbstat, 0);
putchar('\n');
} /* END for (bpstat) */
pbs_statfree(pbstat);
}
}
break;
case LIST:
/* list any node that is DOWN, OFFLINE, or UNKNOWN */
for (lindex = 0;nodeargs[lindex] != '\0';lindex++)
{
bstatus = statnode(con, nodeargs[lindex]);
for (pbstat = bstatus;pbstat != NULL;pbstat = pbstat->next)
{
char *S;
S = get_nstate(pbstat);
if (filterbystate(pbstat, ListType, S))
{
char *n;
if ((note_flag == list) && (n = get_note(pbstat)))
{
printf("%-20.20s %-26.26s %s\n",
pbstat->name,
S,
n);
}
else
{
printf("%-20.20s %s\n",
pbstat->name,
S);
}
}
}
pbs_statfree(pbstat);
}
break;
} /* END switch (flag) */
pbs_disconnect(con);
return(0);
} /* END main() */
int
main(int argc, char **argv, char **envp) /* qhold */
{
int c;
int errflg=0;
int any_failed=0;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME];
char rmt_server[MAXSERVERNAME];
struct ecl_attribute_errors *err_list;
#define MAX_HOLD_TYPE_LEN 32
char hold_type[MAX_HOLD_TYPE_LEN+1];
#define GETOPT_ARGS "h:-:"
/*test for real deal or just version and exit*/
execution_mode(argc, argv);
#ifdef WIN32
winsock_init();
#endif
hold_type[0]='\0';
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
switch (c) {
case 'h':
while (isspace((int)*optarg)) optarg++;
if (optarg[0] == '\0') {
fprintf(stderr, "qhold: illegal -h value\n");
errflg++;
}
else
strcpy(hold_type, optarg);
break;
default :
errflg++;
}
if (errflg || optind >= argc) {
print_usage();
exit(2);
}
/*perform needed security library initializations (including none)*/
if (CS_client_init() != CS_SUCCESS) {
fprintf(stderr, "qhold: unable to initialize security library.\n");
exit(2);
}
for (; optind < argc; optind++) {
int connect;
int stat=0;
int located = FALSE;
strcpy(job_id, argv[optind]);
if (get_server(job_id, job_id_out, server_out)) {
fprintf(stderr, "qhold: illegally formed job identifier: %s\n", job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0) {
fprintf(stderr, "qhold: cannot connect to server %s (errno=%d)\n",
pbs_server, pbs_errno);
any_failed = pbs_errno;
continue;
}
stat = pbs_holdjob(connect, job_id_out, hold_type, NULL);
if (stat && (err_list = pbs_get_attributes_in_error(connect)))
handle_attribute_errors(connect, err_list);
if (stat && (pbs_errno != PBSE_UNKJOBID)) {
prt_job_err("qhold", connect, job_id_out);
any_failed = pbs_errno;
} else if (stat && (pbs_errno == PBSE_UNKJOBID) && !located) {
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server)) {
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qhold", connect, job_id_out);
any_failed = pbs_errno;
}
pbs_disconnect(connect);
}
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(any_failed);
}
int main(
int argc,
char **argv)
{
int c;
int errflg = 0;
char *errmsg;
#define MAX_OPTARG_LEN 256
#define MAX_RESOURCE_NAME_LEN 256
char optargout[MAX_OPTARG_LEN+1];
char resource_name[MAX_RESOURCE_NAME_LEN+1];
enum batch_op op;
enum batch_op *pop = &op;
struct attropl *select_list = 0;
static char destination[PBS_MAXROUTEDEST+1] = "";
char server_out[MAXSERVERNAME] = "";
char *queue_name_out;
char *server_name_out;
int connect;
char **selectjob_list;
char *res_pos;
char *pc;
int u_cnt, o_cnt, s_cnt, n_cnt;
time_t after;
char a_value[80];
int exec_only = 0;
if (getenv("PBS_QSTAT_EXECONLY") != NULL)
exec_only = 1;
#define GETOPT_ARGS "a:A:ec:h:l:N:p:q:r:s:u:"
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
switch (c)
{
case 'a':
check_op(optarg, pop, optargout);
if ((after = cvtdate(optargout)) < 0)
{
fprintf(stderr, "qselect: illegal -a value\n");
errflg++;
break;
}
sprintf(a_value, "%ld", (long)after);
set_attrop(&select_list, ATTR_a, NULL, a_value, op);
break;
case 'e':
exec_only = 1;
break;
case 'c':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)*pc)) pc++;
if (strlen(pc) == 0)
{
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
if (strcmp(pc, "u") == 0)
{
if ((op != EQ) && (op != NE))
{
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
}
else if ((strcmp(pc, "n") != 0) &&
(strcmp(pc, "s") != 0) &&
(strcmp(pc, "c") != 0))
{
if (strncmp(pc, "c=", 2) != 0)
{
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
pc += 2;
if (strlen(pc) == 0)
{
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
while (*pc != '\0')
{
if (!isdigit((int)*pc))
{
fprintf(stderr, "qselect: illegal -c value\n");
errflg++;
break;
}
pc++;
}
}
set_attrop(&select_list, ATTR_c, NULL, optargout, op);
break;
case 'h':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)*pc)) pc++;
if (strlen(pc) == 0)
{
fprintf(stderr, "qselect: illegal -h value\n");
errflg++;
break;
}
u_cnt = o_cnt = s_cnt = n_cnt = 0;
while (*pc)
{
if (*pc == 'u')
u_cnt++;
else if (*pc == 'o')
o_cnt++;
else if (*pc == 's')
s_cnt++;
else if (*pc == 'n')
n_cnt++;
else
{
fprintf(stderr, "qselect: illegal -h value\n");
errflg++;
break;
}
pc++;
}
if (n_cnt && (u_cnt + o_cnt + s_cnt))
{
fprintf(stderr, "qselect: illegal -h value\n");
errflg++;
break;
}
set_attrop(&select_list, ATTR_h, NULL, optargout, op);
break;
case 'l':
res_pos = optarg;
while (*res_pos != '\0')
{
if (check_res_op(res_pos, resource_name, pop, optargout, &res_pos) != 0)
{
errflg++;
break;
}
set_attrop(&select_list, ATTR_l, resource_name, optargout, op);
}
break;
case 'p':
check_op(optarg, pop, optargout);
set_attrop(&select_list, ATTR_p, NULL, optargout, op);
break;
case 'q':
strncpy(destination, optarg, PBS_MAXROUTEDEST);
check_op(optarg, pop, optargout);
set_attrop(&select_list, ATTR_q, NULL, optargout, op);
break;
case 'r':
op = EQ;
pc = optarg;
while (isspace((int)(*pc))) pc++;
if (strlen(pc) != 1)
{
fprintf(stderr, "qsub: illegal -r value\n");
errflg++;
break;
}
if (*pc != 'y' && *pc != 'n')
{
fprintf(stderr, "qsub: illegal -r value\n");
errflg++;
break;
}
set_attrop(&select_list, ATTR_r, NULL, pc, op);
break;
case 's':
check_op(optarg, pop, optargout);
pc = optargout;
while (isspace((int)(*pc))) pc++;
if (strlen(optarg) == 0)
{
fprintf(stderr, "qselect: illegal -s value\n");
errflg++;
break;
}
while (*pc)
{
if (*pc != 'C' && *pc != 'E' && *pc != 'H' &&
*pc != 'Q' && *pc != 'R' && *pc != 'T' &&
*pc != 'W')
{
fprintf(stderr, "qselect: illegal -s value\n");
errflg++;
break;
}
pc++;
}
set_attrop(&select_list, ATTR_state, NULL, optargout, op);
break;
case 'u':
op = EQ;
if (parse_at_list(optarg, FALSE, FALSE))
{
fprintf(stderr, "qselect: illegal -u value\n");
errflg++;
break;
}
set_attrop(&select_list, ATTR_u, NULL, optarg, op);
break;
case 'A':
op = EQ;
set_attrop(&select_list, ATTR_A, NULL, optarg, op);
break;
case 'N':
op = EQ;
set_attrop(&select_list, ATTR_N, NULL, optarg, op);
break;
default :
errflg++;
}
if (errflg || (optind < argc))
{
static char usage[] = "usage: qselect \
[-a [op]date_time] [-A account_string] [-e] [-c [op]interval] \n\
[-h hold_list] [-l resource_list] [-N name] [-p [op]priority] \n\
[-q destination] [-r y|n] [-s states] [-u user_name]\n";
fprintf(stderr,"%s", usage);
exit(2);
}
if (notNULL(destination))
{
if (parse_destination_id(destination, &queue_name_out, &server_name_out))
{
fprintf(stderr, "qselect: illegally formed destination: %s\n", destination);
exit(2);
}
else
{
if (notNULL(server_name_out))
{
strcpy(server_out, server_name_out);
}
}
}
connect = cnt2server(server_out);
if (connect <= 0)
{
fprintf(stderr, "qselect: cannot connect to server %s (errno=%d) %s\n",
pbs_server, pbs_errno, pbs_strerror(pbs_errno));
exit(pbs_errno);
}
selectjob_list = pbs_selectjob(connect, select_list, exec_only ? EXECQUEONLY : NULL);
if (selectjob_list == NULL)
{
if (pbs_errno != PBSE_NONE)
{
errmsg = pbs_geterrmsg(connect);
if (errmsg != NULL)
{
fprintf(stderr, "qselect: %s\n", errmsg);
}
else
{
fprintf(stderr, "qselect: Error (%d - %s) selecting jobs\n",
pbs_errno,
pbs_strerror(pbs_errno));
}
exit(pbs_errno);
}
}
else /* got some jobs ids */
{
int i = 0;
while (selectjob_list[i] != NULL)
{
printf("%s\n", selectjob_list[i++]);
}
free(selectjob_list);
}
pbs_disconnect(connect);
exit(0);
}
int main(
int argc,
char **argv)
{
int c;
int errflg = 0;
int any_failed = 0;
int purge_completed = FALSE;
int located = FALSE;
char *pc;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME] = "";
char rmt_server[MAXSERVERNAME] = "";
char extend[1024];
#define GETOPT_ARGS "acm:pW:t:"
initialize_network_info();
extend[0] = '\0';
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF)
{
switch (c)
{
case 'a': /* Async job deletion */
if (extend[0] != '\0')
{
errflg++;
break;
}
strcpy(extend, DELASYNC);
break;
case 'c':
if (extend[0] != '\0')
{
errflg++;
break;
}
snprintf(extend,sizeof(extend),"%s%ld",PURGECOMP,(long)(time(NULL)));
purge_completed = TRUE;
break;
case 'm':
/* add delete message */
if (extend[0] != '\0')
{
/* extension option already specified */
errflg++;
break;
}
strncpy(extend, optarg, sizeof(extend));
break;
case 'p':
if (extend[0] != '\0')
{
errflg++;
break;
}
strcpy(extend, DELPURGE);
strcat(extend, "1");
break;
case 't':
if (extend[0] != '\0')
{
errflg++;
break;
}
pc = optarg;
if (strlen(pc) == 0)
{
fprintf(stderr, "qdel: illegal -t value (array range cannot be zero length)\n");
errflg++;
break;
}
snprintf(extend,sizeof(extend),"%s%s",
ARRAY_RANGE,
pc);
break;
case 'W':
if (extend[0] != '\0')
{
errflg++;
break;
}
pc = optarg;
if (strlen(pc) == 0)
{
fprintf(stderr, "qdel: illegal -W value\n");
errflg++;
break;
}
while (*pc != '\0')
{
if (!isdigit(*pc))
{
fprintf(stderr, "qdel: illegal -W value\n");
errflg++;
break;
}
pc++;
}
strcpy(extend, DELDELAY);
strcat(extend, optarg);
break;
default:
errflg++;
break;
}
} /* END while (c) */
if (purge_completed)
{
strcpy(server_out,pbs_default());
goto cnt;
}
if ((errflg != 0) || (optind >= argc))
{
static char usage[] = "usage: qdel [{ -a | -c | -p | -t | -W delay | -m message}] [<JOBID>[<JOBID>]|'all'|'ALL']...\n";
fprintf(stderr, "%s", usage);
fprintf(stderr, " -a -c, -m, -p, -t, and -W are mutually exclusive\n");
exit(2);
}
for (;optind < argc;optind++)
{
int connect;
int stat = 0;
/* check to see if user specified 'all' to delete all jobs */
snprintf(job_id, sizeof(job_id), "%s", argv[optind]);
if (get_server(job_id, job_id_out, sizeof(job_id_out), server_out, sizeof(server_out)))
{
fprintf(stderr, "qdel: illegally formed job identifier: %s\n",
job_id);
any_failed = 1;
continue;
}
cnt:
connect = cnt2server(server_out);
if (connect <= 0)
{
any_failed = -1 * connect;
if(server_out[0] != 0)
fprintf(stderr, "qdel: cannot connect to server %s (errno=%d) %s\n",
server_out,
any_failed,
pbs_strerror(any_failed));
else
fprintf(stderr, "qdel: cannot connect to server %s (errno=%d) %s\n",
pbs_server,
any_failed,
pbs_strerror(any_failed));
continue;
}
stat = pbs_deljob_err(connect, job_id_out, extend, &any_failed);
if (stat &&
(any_failed != PBSE_UNKJOBID))
{
prt_job_err("qdel", connect, job_id_out);
}
else if (stat &&
(any_failed != PBSE_UNKJOBID) &&
!located)
{
located = TRUE;
if (locate_job(job_id_out, server_out, rmt_server))
{
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
goto cnt;
}
prt_job_err("qdel", connect, job_id_out);
}
pbs_disconnect(connect);
}
exit(any_failed);
} /* END main() */
int main(
int ArgC, /* I */
char **ArgV) /* I */
{
const char *OptString = "c:Cd:f:h:lp:q:r:sv";
char HostList[65536];
char *HPtr;
int c;
int rc = PBSE_NONE;
int local_errno = 0;
int HostCount;
int FailCount;
/* initialize */
HostList[0] = '\0';
ConfigBuf[0] = '\0';
if (IamRoot() == 0)
{
exit(EXIT_FAILURE);
}
while ((c = getopt(ArgC, ArgV, OptString)) != EOF)
{
switch (c)
{
case 'c':
/* clear job */
JPtr = optarg;
CmdIndex = momClear;
break;
case 'C':
/* force cycle */
CmdIndex = momQuery;
Query[QueryI] = strdup("cycle");
QueryI++;
break;
case 'd':
/* diagnose */
/* FORMAT: momctl -d<X> */
CmdIndex = momQuery;
if ((Query[QueryI] = (char *)calloc(strlen(DiagPtr) + 3, sizeof(char))) == NULL)
{
fprintf(stderr,"ERROR: could not calloc %d bytes!\n",
(int)strlen(DiagPtr) + 3);
exit(EXIT_FAILURE);
}
if (optarg == NULL)
{
strncpy(Query[QueryI],DiagPtr,strlen(DiagPtr));
}
else
{
snprintf(Query[QueryI],strlen(DiagPtr) + 2,"%s%s",
DiagPtr,
optarg);
}
QueryI++;
break;
case 'f':
{
int rc;
FILE *fp;
long size;
if ((fp = fopen(optarg, "r")) == NULL)
{
fprintf(stderr, "ERROR: cannot open file '%s', errno: %d (%s)\n",
optarg,
errno,
strerror(errno));
exit(EXIT_FAILURE);
}
rc = fread(HostList, sizeof(HostList), 1, fp);
if ((rc == 0) && (!feof(fp)))
{
fprintf(stderr, "ERROR: cannot read file '%s', errno: %d (%s)\n",
optarg,
errno,
strerror(errno));
exit(EXIT_FAILURE);
}
if ((size = ftell(fp)) < 0)
size = 0;
HostList[MIN(size,(long)sizeof(HostList) - 1)] = '\0';
fclose(fp);
} /* END BLOCK */
break;
case 'h':
/* connect to specified host */
snprintf(HostList, sizeof(HostList), "%s", optarg);
break;
case 'l':
CmdIndex = momLayout;
break;
case 'p':
/* port */
if (optarg == NULL)
MCShowUsage("port not specified");
MOMPort = (int)strtol(optarg, NULL, 10);
if (MOMPort == 0)
MCShowUsage("invalid port specified");
break;
case 'q':
/* query resources */
if (optarg == NULL)
{
MCShowUsage("query not specified");
Query[QueryI] = strdup(DiagPtr);
}
else
{
Query[QueryI] = strdup(optarg);
}
QueryI++;
CmdIndex = momQuery;
break;
case 'r':
/* reconfigure */
{
CmdIndex = momReconfig;
/* NOTE: specify remote file to load -> 'fname' */
/* specify local file to stage -> 'LOCAL:fname' */
if (optarg == NULL)
MCShowUsage("file not specified");
if (!strncmp(optarg, "LOCAL:", strlen("LOCAL:")))
{
FILE *fp;
int size;
int rc;
char *ptr;
char *cptr;
strcpy(ConfigBuf, "CONFIG:");
cptr = ConfigBuf + strlen(ConfigBuf);
ptr = optarg + strlen("LOCAL:");
if ((fp = fopen(ptr, "r")) == NULL)
{
fprintf(stderr, "ERROR: cannot open file '%s', errno: %d (%s)\n",
optarg,
errno,
strerror(errno));
exit(EXIT_FAILURE);
}
rc = fread(cptr, sizeof(ConfigBuf) - strlen(ConfigBuf), 1, fp);
if ((rc == 0) && (!feof(fp)))
{
fprintf(stderr, "ERROR: cannot read file '%s', errno: %d (%s)\n",
optarg,
errno,
strerror(errno));
exit(EXIT_FAILURE);
}
size = ftell(fp);
ConfigBuf[MIN(size + strlen("CONFIG:"),sizeof(ConfigBuf) - 1)] = '\0';
fclose(fp);
}
else
{
snprintf(ConfigBuf, sizeof(ConfigBuf), "%s", optarg);
}
} /* END (case 'r') */
break;
case 's':
/* shutdown */
CmdIndex = momShutdown;
break;
case 'v':
/* report verbose logging */
IsVerbose = TRUE;
break;
} /* END switch (c) */
} /* END while (c = getopt()) */
if (CmdIndex == momNONE)
{
MCShowUsage("no command specified");
}
if (HostList[0] == '\0')
snprintf(HostList, sizeof(HostList), "%s", LocalHost);
HPtr = strtok(HostList, ", \t\n");
HostCount = 0;
FailCount = 0;
/* at this point, all args processing and setup is completed ...
* ... now we run through each comma-delimited word in HPtr */
while (HPtr != NULL)
{
if ((*HPtr == ':') && (*(HPtr + 1) != '\0'))
{
/* finds nodes with this property */
int con;
char *def_server, *pserver, *servername;
struct batch_status *bstatus, *pbstat;
struct attrl *nodeattrs;
def_server = pbs_default();
if ((pserver = strchr(HPtr,'@')) != NULL)
{
*pserver = '\0';
servername = pserver + 1;
}
else
{
servername = def_server;
}
con = pbs_connect(servername);
if (con < 0)
{
fprintf(stderr,"failed to connect to pbs_server:%s\n",
servername);
exit(EXIT_FAILURE);
}
/* get a batch_status entry for each node in ":property" */
bstatus = pbs_statnode_err(con,HPtr,NULL,NULL, &local_errno);
if (bstatus != NULL)
{
for (pbstat = bstatus;pbstat != NULL;pbstat = pbstat->next)
{
/* check state first, only do_mom() if not down */
for (nodeattrs = pbstat->attribs;nodeattrs != NULL; nodeattrs = nodeattrs->next)
{
if (!strcmp(nodeattrs->name, ATTR_NODE_state))
{
if (!strstr(nodeattrs->value, ND_down))
{
if ((rc = perform_communications_with_retry(pbstat->name, MOMPort, &FailCount)) == PBSE_NONE)
HostCount++;
}
else
{
fprintf(stderr,"%12s: skipping down node\n",
pbstat->name);
}
break;
} /* END if (attrib name eq state) */
} /* END for (nodeattrs) */
} /* END for (pbstat) */
pbs_statfree(bstatus);
} /* END if (bstatus != NULL) */
else
{
fprintf(stderr,"no nodes found in %s on %s\n",
HPtr,
servername);
}
pbs_disconnect(con);
if (pserver != NULL)
*pserver = '@';
}
else
{
if ((rc = perform_communications_with_retry(HPtr, MOMPort, &FailCount)) == PBSE_NONE)
HostCount++;
} /* END if (*HPtr == ':') */
HPtr = strtok(NULL, ", \t\n");
} /* END while (HPtr != NULL) */
if (IsVerbose == TRUE)
{
fprintf(stdout, "Node Summary: %d Successful %d Failed\n",
HostCount,
FailCount);
}
/* test success of do_mom before returning success */
if (rc != PBSE_NONE)
exit(EXIT_FAILURE);
/* SUCCESS */
exit(EXIT_SUCCESS);
} /* END main() */
int
main(int argc, char **argv, char **envp) /* pbs_release_nodes */
{
int c;
int errflg=0;
int any_failed=0;
char job_id[PBS_MAXCLTJOBID]; /* from the command line */
char job_id_out[PBS_MAXCLTJOBID];
char server_out[MAXSERVERNAME];
char rmt_server[MAXSERVERNAME];
int len;
char *node_list = NULL;
int connect;
int stat=0;
int k;
int all_opt = 0;
#define GETOPT_ARGS "j:a"
/*test for real deal or just version and exit*/
execution_mode(argc, argv);
#ifdef WIN32
winsock_init();
#endif
job_id[0] = '\0';
while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF) {
switch (c) {
case 'j':
strncpy(job_id, optarg, PBS_MAXCLTJOBID);
job_id[PBS_MAXCLTJOBID-1] = '\0';
break;
case 'a':
all_opt = 1;
break;
default :
errflg++;
}
}
if (job_id[0] == '\0') {
char *jid;
jid = getenv("PBS_JOBID");
strncpy(job_id, jid?jid:"", PBS_MAXCLTJOBID);
job_id[PBS_MAXCLTJOBID-1] = '\0';
}
if (errflg ||
((optind == argc) && !all_opt) ||
((optind != argc) && all_opt) ) {
fprintf(stderr, USAGE);
fprintf(stderr, USAGE2);
fprintf(stderr, USAGE3);
exit(2);
}
if (job_id[0] == '\0') {
fprintf(stderr, "pbs_release_nodes: No jobid given\n");
exit(2);
}
/*perform needed security library initializations (including none)*/
if (CS_client_init() != CS_SUCCESS) {
fprintf(stderr, "pbs_release_nodes: unable to initialize security library.\n");
exit(2);
}
len = 0;
for (k = optind; k < argc; k++) {
len += (strlen(argv[k]) + 1); /* +1 for space */
}
node_list = (char *)malloc(len + 1);
if (node_list == NULL) {
fprintf(stderr, "failed to malloc to store data (error %d)", errno);
exit(2);
}
node_list[0] = '\0';
for (k = optind; k < argc; k++) {
if (k != optind)
strcat(node_list, "+");
strcat(node_list, argv[k]);
}
if (get_server(job_id, job_id_out, server_out)) {
fprintf(stderr, "pbs_release_nodes: illegally formed job identifier: %s\n", job_id);
free(node_list);
exit(2);
}
pbs_errno = 0;
stat = 0;
while(1) {
connect = cnt2server(server_out);
if (connect <= 0) {
fprintf(stderr,
"pbs_release_nodes: cannot connect to server %s (errno=%d)\n",
pbs_server, pbs_errno);
break;
}
stat = pbs_relnodesjob(connect, job_id_out, node_list, NULL);
if (stat && (pbs_errno == PBSE_UNKJOBID)) {
if (locate_job(job_id_out, server_out, rmt_server)) {
/*
* job located at a different server
* retry connect on the new server
*/
pbs_disconnect(connect);
strcpy(server_out, rmt_server);
} else {
prt_job_err("pbs_release_nodes", connect, job_id_out);
break;
}
} else {
char *info_msg;
if (stat && (pbs_errno != PBSE_UNKJOBID)) {
prt_job_err("pbs_release_nodes", connect, "");
} else if ((info_msg = pbs_geterrmsg(connect)) != NULL) {
/* print potential warning message */
printf("pbs_release_nodes: %s\n", info_msg);
}
break;
}
}
any_failed = pbs_errno;
pbs_disconnect(connect);
/*cleanup security library initializations before exiting*/
CS_close_app();
exit(any_failed);
}