static void job_monitor_watchdog(watchdog_t *self)
{
JCR *control_jcr, *jcr;
control_jcr = (JCR *)self->data;
Dsm_check(100);
Dmsg1(800, "job_monitor_watchdog %p called\n", self);
foreach_jcr(jcr) {
bool cancel = false;
if (jcr->JobId == 0 || job_canceled(jcr) || jcr->no_maxtime) {
Dmsg2(800, "Skipping JCR=%p Job=%s\n", jcr, jcr->Job);
continue;
}
/* check MaxWaitTime */
if (job_check_maxwaittime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Qmsg(jcr, M_FATAL, 0, _("Max wait time exceeded. Job canceled.\n"));
cancel = true;
/* check MaxRunTime */
} else if (job_check_maxruntime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Qmsg(jcr, M_FATAL, 0, _("Max run time exceeded. Job canceled.\n"));
cancel = true;
/* check MaxRunSchedTime */
} else if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Qmsg(jcr, M_FATAL, 0, _("Max run sched time exceeded. Job canceled.\n"));
cancel = true;
}
if (cancel) {
Dmsg3(800, "Cancelling JCR %p jobid %d (%s)\n", jcr, jcr->JobId, jcr->Job);
UAContext *ua = new_ua_context(jcr);
ua->jcr = control_jcr;
cancel_job(ua, jcr);
free_ua_context(ua);
Dmsg2(800, "Have cancelled JCR %p Job=%d\n", jcr, jcr->JobId);
}
}
/* Keep reference counts correct */
endeach_jcr(jcr);
}
int bb_end_scan(struct ledm_session* ps, int io_error)
{
struct bb_ledm_session *pbb = ps->bb_session;
_DBG("bb_end_scan(error=%d)\n", io_error);
if (pbb->http_handle)
{
http_close(pbb->http_handle);
pbb->http_handle = 0;
}
cancel_job(ps);
memset(ps->url, 0, sizeof(ps->url));
ps->job_id = 0;
ps->page_id = 0;
return 0;
}
static PyObject *job_cancel(PyObject *self, PyObject *args)
{
JobId_t JobId = 0;
JCR *jcr;
bool found = false;
if (!PyArg_ParseTuple(args, "i:cancel", &JobId)) {
Dmsg0(000, "Parse tuple error in job_write\n");
return NULL;
}
foreach_jcr(jcr) {
if (jcr->JobId == 0) {
continue;
}
if (jcr->JobId == JobId) {
found = true;
break;
}
}
/* endeach_jcr(jcr) not needed because freed below */
if (!found) {
/* ***FIXME*** raise exception */
return NULL;
}
// PyEval_ReleaseLock();
UAContext *ua = new_ua_context(jcr);
ua->batch = true;
if (!cancel_job(ua, jcr)) {
/* ***FIXME*** raise exception */
return NULL;
}
free_ua_context(ua);
free_jcr(jcr);
// PyEval_AcquireLock();
Py_INCREF(Py_None);
return Py_None;
}
/*****************************************************************************\
* Parse, process and respond to a request
\*****************************************************************************/
static void _proc_msg(slurm_fd_t new_fd, char *msg)
{
DEF_TIMERS;
char *req, *cmd_ptr, *msg_type = NULL;
char response[128];
if (new_fd < 0)
return;
START_TIMER;
if (!msg) {
err_code = -300;
err_msg = "NULL request message";
error("wiki: NULL request message");
goto resp_msg;
}
if (_parse_msg(msg, &req) != 0)
goto resp_msg;
cmd_ptr = strstr(req, "CMD=");
if (cmd_ptr == NULL) {
err_code = -300;
err_msg = "request lacks CMD";
error("wiki: request lacks CMD");
goto resp_msg;
}
cmd_ptr +=4;
err_code = 0;
if (strncmp(cmd_ptr, "GETJOBS", 7) == 0) {
msg_type = "wiki:GETJOBS";
if (!get_jobs(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
} else if (strncmp(cmd_ptr, "GETNODES", 8) == 0) {
msg_type = "wiki:GETNODES";
if (!get_nodes(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
} else if (strncmp(cmd_ptr, "STARTJOB", 8) == 0) {
msg_type = "wiki:STARTJOB";
start_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "CANCELJOB", 9) == 0) {
msg_type = "wiki:CANCELJOB";
cancel_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "SUSPENDJOB", 10) == 0) {
msg_type = "wiki:SUSPENDJOB";
suspend_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "RESUMEJOB", 9) == 0) {
msg_type = "wiki:RESUMEJOB";
resume_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "MODIFYJOB", 9) == 0) {
msg_type = "wiki:MODIFYJOB";
job_modify_wiki(cmd_ptr, &err_code, &err_msg);
} else {
err_code = -300;
err_msg = "unsupported request type";
error("wiki: unrecognized request type: %s", req);
}
END_TIMER2(msg_type);
resp_msg:
snprintf(response, sizeof(response),
"SC=%d RESPONSE=%s", err_code, err_msg);
_send_reply(new_fd, response);
return;
free_resp_msg:
/* Message is pre-formatted by get_jobs and get_nodes
* ONLY if no error. Send message and xfree the buffer. */
_send_reply(new_fd, err_msg);
xfree(err_msg);
return;
}
int shinkos2145_cmdline_arg(void *vctx, int argc, char **argv)
{
struct shinkos2145_ctx *ctx = vctx;
int i, j = 0;
if (!ctx)
return -1;
/* Reset arg parsing */
optind = 1;
opterr = 0;
while ((i = getopt(argc, argv, GETOPT_LIST_GLOBAL "b:c:C:eFil:L:mr:R:suU:X:")) >= 0) {
switch(i) {
GETOPT_PROCESS_GLOBAL
case 'b':
if (optarg[0] == '1')
j = button_set(ctx, BUTTON_ENABLED);
else if (optarg[0] == '0')
j = button_set(ctx, BUTTON_DISABLED);
else
return -1;
break;
case 'c':
j = get_tonecurve(ctx, TONECURVE_USER, optarg);
break;
case 'C':
j = set_tonecurve(ctx, TONECURVE_USER, optarg);
break;
case 'e':
j = get_errorlog(ctx);
break;
case 'F':
j = flash_led(ctx);
break;
case 'i':
j = get_fwinfo(ctx);
break;
case 'l':
j = get_tonecurve(ctx, TONECURVE_CURRENT, optarg);
break;
case 'L':
j = set_tonecurve(ctx, TONECURVE_CURRENT, optarg);
break;
case 'm':
j = get_mediainfo(ctx);
break;
case 'r':
j = reset_curve(ctx, RESET_USER_CURVE);
break;
case 'R':
j = reset_curve(ctx, RESET_PRINTER);
break;
case 's':
j = get_status(ctx);
break;
case 'u':
j = get_user_string(ctx);
break;
case 'U':
j = set_user_string(ctx, optarg);
break;
case 'X':
j = cancel_job(ctx, optarg);
break;
default:
break; /* Ignore completely */
}
if (j) return j;
}
return 0;
}
/*****************************************************************************\
* Parse, process and respond to a request
\*****************************************************************************/
static void _proc_msg(slurm_fd_t new_fd, char *msg)
{
DEF_TIMERS;
char *req, *cmd_ptr, *msg_type = NULL;
char response[128];
if (new_fd < 0)
return;
START_TIMER;
if (!msg) {
err_code = -300;
err_msg = "NULL request message";
error("wiki: NULL request message");
goto resp_msg;
}
if (_parse_msg(msg, &req) != 0)
goto resp_msg;
cmd_ptr = strstr(req, "CMD=");
if (cmd_ptr == NULL) {
err_code = -300;
err_msg = "request lacks CMD";
error("wiki: request lacks CMD");
goto resp_msg;
}
cmd_ptr +=4;
err_code = 0;
if (strncmp(cmd_ptr, "GETJOBS", 7) == 0) {
msg_type = "wiki:GETJOBS";
if (!get_jobs(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
} else if (strncmp(cmd_ptr, "GETNODES", 8) == 0) {
msg_type = "wiki:GETNODES";
if (!get_nodes(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
} else if (strncmp(cmd_ptr, "STARTJOB", 8) == 0) {
msg_type = "wiki:STARTJOB";
start_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "CANCELJOB", 9) == 0) {
msg_type = "wiki:CANCELJOB";
cancel_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "REQUEUEJOB", 10) == 0) {
msg_type = "wiki:REQUEUEJOB";
job_requeue_wiki(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "SUSPENDJOB", 10) == 0) {
msg_type = "wiki:SUSPENDJOB";
suspend_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "RESUMEJOB", 9) == 0) {
msg_type = "wiki:RESUMEJOB";
resume_job(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "JOBADDTASK", 10) == 0) {
msg_type = "wiki:JOBADDTASK";
job_add_task(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "JOBRELEASETASK", 14) == 0) {
msg_type = "wiki:JOBRELEASETASK";
job_release_task(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "JOBWILLRUN", 10) == 0) {
msg_type = "wiki:JOBWILLRUN";
if (strstr(cmd_ptr, "NODES=")) {
/* Updated format input and output */
if (!job_will_run2(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
} else {
if (!job_will_run(cmd_ptr, &err_code, &err_msg))
goto free_resp_msg;
}
} else if (strncmp(cmd_ptr, "MODIFYJOB", 9) == 0) {
msg_type = "wiki:MODIFYJOB";
job_modify_wiki(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "NOTIFYJOB", 9) == 0) {
msg_type = "wiki:NOTIFYJOB";
job_notify_wiki(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "SIGNALJOB", 9) == 0) {
msg_type = "wiki:SIGNALJOB";
job_signal_wiki(cmd_ptr, &err_code, &err_msg);
} else if (strncmp(cmd_ptr, "INITIALIZE", 10) == 0) {
msg_type = "wiki:INITIALIZE";
initialize_wiki(cmd_ptr, &err_code, &err_msg);
} else {
err_code = -300;
err_msg = "unsupported request type";
error("wiki: unrecognized request type: %s", req);
}
END_TIMER2(msg_type);
resp_msg:
snprintf(response, sizeof(response),
"SC=%d RESPONSE=%s", err_code, err_msg);
_send_reply(new_fd, response);
return;
free_resp_msg:
/* Message is pre-formatted by get_jobs and get_nodes
* ONLY if no error. Send message and xfree the buffer. */
_send_reply(new_fd, err_msg);
xfree(err_msg);
return;
}
/*
* Check for duplicate jobs.
* Returns: true if current job should continue
* false if current job should terminate
*/
bool allow_duplicate_job(JCR *jcr)
{
JCR *djcr; /* possible duplicate job */
JOBRES *job = jcr->res.job;
bool cancel_dup = false;
bool cancel_me = false;
/*
* See if AllowDuplicateJobs is set or
* if duplicate checking is disabled for this job.
*/
if (job->AllowDuplicateJobs || jcr->IgnoreDuplicateJobChecking) {
return true;
}
Dmsg0(800, "Enter allow_duplicate_job\n");
/*
* After this point, we do not want to allow any duplicate
* job to run.
*/
foreach_jcr(djcr) {
if (jcr == djcr || djcr->JobId == 0) {
continue; /* do not cancel this job or consoles */
}
/*
* See if this Job has the IgnoreDuplicateJobChecking flag set, ignore it
* for any checking against other jobs.
*/
if (djcr->IgnoreDuplicateJobChecking) {
continue;
}
if (bstrcmp(job->name(), djcr->res.job->name())) {
if (job->DuplicateJobProximity > 0) {
utime_t now = (utime_t)time(NULL);
if ((now - djcr->start_time) > job->DuplicateJobProximity) {
continue; /* not really a duplicate */
}
}
if (job->CancelLowerLevelDuplicates &&
djcr->getJobType() == 'B' && jcr->getJobType() == 'B') {
switch (jcr->getJobLevel()) {
case L_FULL:
if (djcr->getJobLevel() == L_DIFFERENTIAL ||
djcr->getJobLevel() == L_INCREMENTAL) {
cancel_dup = true;
}
break;
case L_DIFFERENTIAL:
if (djcr->getJobLevel() == L_INCREMENTAL) {
cancel_dup = true;
}
if (djcr->getJobLevel() == L_FULL) {
cancel_me = true;
}
break;
case L_INCREMENTAL:
if (djcr->getJobLevel() == L_FULL ||
djcr->getJobLevel() == L_DIFFERENTIAL) {
cancel_me = true;
}
}
/*
* cancel_dup will be done below
*/
if (cancel_me) {
/* Zap current job */
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("JobId %d already running. Duplicate job not allowed.\n"),
djcr->JobId);
break; /* get out of foreach_jcr */
}
}
/*
* Cancel one of the two jobs (me or dup)
* If CancelQueuedDuplicates is set do so only if job is queued.
*/
if (job->CancelQueuedDuplicates) {
switch (djcr->JobStatus) {
case JS_Created:
case JS_WaitJobRes:
case JS_WaitClientRes:
case JS_WaitStoreRes:
case JS_WaitPriority:
case JS_WaitMaxJobs:
case JS_WaitStartTime:
cancel_dup = true; /* cancel queued duplicate */
break;
default:
break;
}
}
if (cancel_dup || job->CancelRunningDuplicates) {
/*
* Zap the duplicated job djcr
*/
UAContext *ua = new_ua_context(jcr);
Jmsg(jcr, M_INFO, 0, _("Cancelling duplicate JobId=%d.\n"), djcr->JobId);
cancel_job(ua, djcr);
bmicrosleep(0, 500000);
djcr->setJobStatus(JS_Canceled);
cancel_job(ua, djcr);
free_ua_context(ua);
Dmsg2(800, "Cancel dup %p JobId=%d\n", djcr, djcr->JobId);
} else {
/*
* Zap current job
*/
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("JobId %d already running. Duplicate job not allowed.\n"),
djcr->JobId);
Dmsg2(800, "Cancel me %p JobId=%d\n", jcr, jcr->JobId);
}
Dmsg4(800, "curJobId=%d use_cnt=%d dupJobId=%d use_cnt=%d\n",
jcr->JobId, jcr->use_count(), djcr->JobId, djcr->use_count());
break; /* did our work, get out of foreach loop */
}
}
endeach_jcr(djcr);
return true;
}
int main(int argc, char *argv[])
{
int fd, sfd, err, c;
struct stat sbuf;
char *host, *file;
struct addrinfo *ailist, *aip;
char *orient;
long jobid;
int text;
int sides; /* 0=default 1=one-sided */
/* 2=two-sided-long-edge 3=two-sided-short-edge */
sides = 0;
text = 0;
err = 0;
jobid = -1;
while ((c = getopt(argc, argv, "is:to:c:h")) != -1) {
switch (c) {
case 'h':
usage();
exit(0);
case 'c':
jobid = atol(optarg);
break;
case 'i':
job_status();
exit(0);
case 's':
sides = atol(optarg);
if (sides < 1 || sides > 3)
err_sys("print: invalid sides option");
break;
case 'o':
orient = optarg;
break;
case 't':
text = 1;
break;
case '?':
err = 1;
break;
}
}
if (err || (optind != argc - 1))
err_quit("usage: print [-t] filename");
file = argv[optind];
if ((fd = open(file, O_RDONLY)) < 0)
err_sys("print: can't open %s", file);
if (fstat(fd, &sbuf) < 0)
err_sys("print: can't stat %s", file);
if (!S_ISREG(sbuf.st_mode))
err_quit("print: %s must be a regular file", file);
/*
* Get the hostname of the host acting as the print server.
*/
if ((host = get_printserver()) == NULL)
err_quit("print: no print server defined");
if ((err = getaddrlist(host, "print", &ailist)) != 0)
err_quit("print: getaddrinfo error: %s", gai_strerror(err));
for (aip = ailist; aip != NULL; aip = aip->ai_next) {
if ((sfd = connect_retry(AF_INET, SOCK_STREAM, 0,
aip->ai_addr, aip->ai_addrlen)) < 0) {
err = errno;
} else {
if (jobid != -1) /* cancel job */
cancel_job(sfd, jobid);
else
submit_file(fd, sfd, file, sbuf.st_size,
text, orient, sides);
exit(0);
}
}
err_exit(err, "print: can't contact %s", host);
}
