/* Return Job variables */
PyObject *job_getattr(PyObject *self, char *attrname)
{
JCR *jcr;
bool found = false;
int i;
char buf[10];
char errmsg[200];
Dmsg1(100, "In job_getattr=%s\n", attrname);
jcr = get_jcr_from_PyObject(self);
if (!jcr) {
bstrncpy(errmsg, _("Job pointer not found."), sizeof(errmsg));
goto bail_out;
}
for (i=0; getvars[i].name; i++) {
if (strcmp(getvars[i].name, attrname) == 0) {
found = true;
break;
}
}
if (!found) {
/* Try our methods */
return Py_FindMethod(JobMethods, self, attrname);
}
switch (i) {
case 0: /* Job */
return Py_BuildValue((char *)getvars[i].fmt, jcr->job_name); /* Non-unique name */
case 1: /* SD's name */
return Py_BuildValue((char *)getvars[i].fmt, my_name);
case 2: /* level */
return Py_BuildValue((char *)getvars[i].fmt, job_level_to_str(jcr->getJobLevel()));
case 3: /* type */
return Py_BuildValue((char *)getvars[i].fmt, job_type_to_str(jcr->getJobType()));
case 4: /* JobId */
return Py_BuildValue((char *)getvars[i].fmt, jcr->JobId);
case 5: /* Client */
return Py_BuildValue((char *)getvars[i].fmt, jcr->client_name);
case 6: /* Pool */
return Py_BuildValue((char *)getvars[i].fmt, jcr->dcr->pool_name);
case 7: /* MediaType */
return Py_BuildValue((char *)getvars[i].fmt, jcr->dcr->media_type);
case 8: /* JobName */
return Py_BuildValue((char *)getvars[i].fmt, jcr->Job);
case 9: /* JobStatus */
buf[1] = 0;
buf[0] = jcr->JobStatus;
return Py_BuildValue((char *)getvars[i].fmt, buf);
case 10:
return Py_BuildValue((char *)getvars[i].fmt, jcr->dcr->VolumeName);
case 11:
return Py_BuildValue((char *)getvars[i].fmt, jcr->dcr->dev_name);
}
bsnprintf(errmsg, sizeof(errmsg), _("Attribute %s not found."), attrname);
bail_out:
PyErr_SetString(PyExc_AttributeError, errmsg);
return NULL;
}
/*
* Create session label
* The pool memory must be released by the calling program
*/
void create_session_label(DCR *dcr, DEV_RECORD *rec, int label)
{
JCR *jcr = dcr->jcr;
ser_declare;
rec->VolSessionId = jcr->VolSessionId;
rec->VolSessionTime = jcr->VolSessionTime;
rec->Stream = jcr->JobId;
rec->maskedStream = jcr->JobId;
rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Session_Label);
ser_begin(rec->data, SER_LENGTH_Session_Label);
if (me->compatible) {
ser_string(OldBaculaId);
ser_uint32(OldCompatibleBareosTapeVersion1);
} else {
ser_string(BareosId);
ser_uint32(BareosTapeVersion);
}
ser_uint32(jcr->JobId);
/* Changed in VerNum 11 */
ser_btime(get_current_btime());
ser_float64(0);
ser_string(dcr->pool_name);
ser_string(dcr->pool_type);
ser_string(jcr->job_name); /* base Job name */
ser_string(jcr->client_name);
/* Added in VerNum 10 */
ser_string(jcr->Job); /* Unique name of this Job */
ser_string(jcr->fileset_name);
ser_uint32(jcr->getJobType());
ser_uint32(jcr->getJobLevel());
/* Added in VerNum 11 */
ser_string(jcr->fileset_md5);
if (label == EOS_LABEL) {
ser_uint32(jcr->JobFiles);
ser_uint64(jcr->JobBytes);
ser_uint32(dcr->StartBlock);
ser_uint32(dcr->EndBlock);
ser_uint32(dcr->StartFile);
ser_uint32(dcr->EndFile);
ser_uint32(jcr->JobErrors);
/* Added in VerNum 11 */
ser_uint32(jcr->JobStatus);
}
ser_end(rec->data, SER_LENGTH_Session_Label);
rec->data_len = ser_length(rec->data);
}
/*
* !!! WARNING !!!
*
* This function should be used ONLY after a fatal signal. We walk through the
* JCR chain without doing any lock, BAREOS should not be running.
*/
void dbg_print_jcr(FILE *fp)
{
char buf1[128], buf2[128], buf3[128], buf4[128];
if (!jcrs) {
return;
}
fprintf(fp, "Attempt to dump current JCRs. njcrs=%d\n", jcrs->size());
for (JCR *jcr = (JCR *)jcrs->first(); jcr ; jcr = (JCR *)jcrs->next(jcr)) {
#ifdef HAVE_WIN32
fprintf(fp, "threadid=%p JobId=%d JobStatus=%c jcr=%p name=%s\n",
(void *)&jcr->my_thread_id, (int)jcr->JobId,
jcr->JobStatus, jcr, jcr->Job);
fprintf(fp, "threadid=%p killable=%d JobId=%d JobStatus=%c "
"jcr=%p name=%s\n",
(void *)&jcr->my_thread_id, jcr->is_killable(),
(int)jcr->JobId, jcr->JobStatus, jcr, jcr->Job);
#else
fprintf(fp, "threadid=%p JobId=%d JobStatus=%c jcr=%p name=%s\n",
(void *)jcr->my_thread_id, (int)jcr->JobId,
jcr->JobStatus, jcr, jcr->Job);
fprintf(fp, "threadid=%p killable=%d JobId=%d JobStatus=%c "
"jcr=%p name=%s\n",
(void *)jcr->my_thread_id, jcr->is_killable(),
(int)jcr->JobId, jcr->JobStatus, jcr, jcr->Job);
#endif
fprintf(fp, "\tuse_count=%i\n", jcr->use_count());
fprintf(fp, "\tJobType=%c JobLevel=%c\n",
jcr->getJobType(), jcr->getJobLevel());
bstrftime(buf1, sizeof(buf1), jcr->sched_time);
bstrftime(buf2, sizeof(buf2), jcr->start_time);
bstrftime(buf3, sizeof(buf3), jcr->end_time);
bstrftime(buf4, sizeof(buf4), jcr->wait_time);
fprintf(fp, "\tsched_time=%s start_time=%s\n\tend_time=%s wait_time=%s\n",
buf1, buf2, buf3, buf4);
fprintf(fp, "\tdb=%p db_batch=%p batch_started=%i\n",
jcr->db, jcr->db_batch, jcr->batch_started);
/*
* Call all the jcr debug hooks
*/
for(int i=0; i < dbg_jcr_handler_count; i++) {
dbg_jcr_hook_t *hook = dbg_jcr_hooks[i];
hook(jcr, fp);
}
}
}
void DEVICE::attach_dcr_to_dev(DCR *dcr)
{
JCR *jcr = dcr->jcr;
Lock_dcrs();
jcr = dcr->jcr;
if (jcr) Dmsg1(500, "JobId=%u enter attach_dcr_to_dev\n", (uint32_t)jcr->JobId);
/* ***FIXME*** return error if dev not initiated */
if (!dcr->attached_to_dev && initiated && jcr && jcr->getJobType() != JT_SYSTEM) {
Dmsg4(200, "Attach Jid=%d dcr=%p size=%d dev=%s\n", (uint32_t)jcr->JobId,
dcr, attached_dcrs->size(), print_name());
attached_dcrs->append(dcr); /* attach dcr to device */
dcr->attached_to_dev = true;
}
Unlock_dcrs();
}
static void attach_dcr_to_dev(DCR *dcr)
{
DEVICE *dev;
JCR *jcr;
P(dcr->m_mutex);
dev = dcr->dev;
jcr = dcr->jcr;
if (jcr) Dmsg1(500, "JobId=%u enter attach_dcr_to_dev\n", (uint32_t)jcr->JobId);
/* ***FIXME*** return error if dev not initiated */
if (!dcr->attached_to_dev && dev->initiated && jcr && jcr->getJobType() != JT_SYSTEM) {
dev->Lock();
Dmsg4(200, "Attach Jid=%d dcr=%p size=%d dev=%s\n", (uint32_t)jcr->JobId,
dcr, dev->attached_dcrs->size(), dev->print_name());
dev->attached_dcrs->append(dcr); /* attach dcr to device */
dev->Unlock();
dcr->attached_to_dev = true;
}
V(dcr->m_mutex);
}
void reload_config(int sig)
{
static bool already_here = false;
#if !defined(HAVE_WIN32)
sigset_t set;
#endif
JCR *jcr;
int njobs = 0; /* number of running jobs */
int table, rtable;
bool ok;
if (already_here) {
abort(); /* Oops, recursion -> die */
}
already_here = true;
#if !defined(HAVE_WIN32)
sigemptyset(&set);
sigaddset(&set, SIGHUP);
sigprocmask(SIG_BLOCK, &set, NULL);
#endif
lock_jobs();
LockRes();
table = find_free_reload_table_entry();
if (table < 0) {
Jmsg(NULL, M_ERROR, 0, _("Too many open reload requests. Request ignored.\n"));
goto bail_out;
}
/**
* Flush the sql connection pools.
*/
db_sql_pool_flush();
Dmsg1(100, "Reload_config njobs=%d\n", njobs);
reload_table[table].res_table = my_config->save_resources();
Dmsg1(100, "Saved old config in table %d\n", table);
ok = parse_dir_config(my_config, configfile, M_ERROR);
Dmsg0(100, "Reloaded config file\n");
if (!ok || !check_resources() || !check_catalog(UPDATE_CATALOG) || !initialize_sql_pooling()) {
rtable = find_free_reload_table_entry(); /* save new, bad table */
if (rtable < 0) {
Jmsg(NULL, M_ERROR, 0, _("Please correct configuration file: %s\n"), configfile);
Jmsg(NULL, M_ERROR_TERM, 0, _("Out of reload table entries. Giving up.\n"));
goto bail_out;
} else {
Jmsg(NULL, M_ERROR, 0, _("Please correct configuration file: %s\n"), configfile);
Jmsg(NULL, M_ERROR, 0, _("Resetting previous configuration.\n"));
}
reload_table[rtable].res_table = my_config->save_resources();
/* Now restore old resource values */
int num = my_config->m_r_last - my_config->m_r_first + 1;
RES **res_tab = reload_table[table].res_table;
for (int i=0; i<num; i++) {
my_config->m_res_head[i] = res_tab[i];
}
table = rtable; /* release new, bad, saved table below */
} else {
invalidate_schedules();
/*
* Hook all active jobs so that they release this table
*/
foreach_jcr(jcr) {
if (jcr->getJobType() != JT_SYSTEM) {
reload_table[table].job_count++;
job_end_push(jcr, reload_job_end_cb, (void *)((long int)table));
njobs++;
}
}
endeach_jcr(jcr);
}
/* Reset globals */
set_working_directory(me->working_directory);
Dmsg0(10, "Director's configuration file reread.\n");
/* Now release saved resources, if no jobs using the resources */
if (njobs == 0) {
free_saved_resources(table);
}
bail_out:
UnlockRes();
unlock_jobs();
#if !defined(HAVE_WIN32)
sigprocmask(SIG_UNBLOCK, &set, NULL);
signal(SIGHUP, reload_config);
#endif
already_here = false;
}
/*
* 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;
}
/*
* This is the engine called by jobq.c:jobq_add() when we were pulled
* from the work queue.
* At this point, we are running in our own thread and all
* necessary resources are allocated -- see jobq.c
*/
static void *job_thread(void *arg)
{
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
jcr->start_time = time(NULL); /* set the real start time */
jcr->jr.StartTime = jcr->start_time;
if (jcr->res.job->MaxStartDelay != 0 && jcr->res.job->MaxStartDelay <
(utime_t)(jcr->start_time - jcr->sched_time)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
if (jcr->res.job->RunScripts == NULL) {
Dmsg0(200, "Warning, job->RunScripts is empty\n");
jcr->res.job->RunScripts = New(alist(10, not_owned_by_alist));
}
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/* Run any script BeforeJob on dird */
run_scripts(jcr, jcr->res.job->RunScripts, "BeforeJob");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_plugin_event(jcr, bDirEventJobRun);
switch (jcr->getJobType()) {
case JT_BACKUP:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_backup(jcr)) {
do_autoprune(jcr);
} else {
ndmp_backup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_backup_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
if (do_native_vbackup(jcr)) {
do_autoprune(jcr);
} else {
native_vbackup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
if (do_native_backup(jcr)) {
do_autoprune(jcr);
} else {
native_backup_cleanup(jcr, JS_ErrorTerminated);
}
}
} else {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
native_vbackup_cleanup(jcr, JS_Canceled);
} else {
native_backup_cleanup(jcr, JS_Canceled);
}
}
break;
}
break;
case JT_VERIFY:
if (!job_canceled(jcr)) {
if (do_verify(jcr)) {
do_autoprune(jcr);
} else {
verify_cleanup(jcr, JS_ErrorTerminated);
}
} else {
verify_cleanup(jcr, JS_Canceled);
}
break;
case JT_RESTORE:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_restore(jcr)) {
do_autoprune(jcr);
} else {
ndmp_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_restore_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (do_native_restore(jcr)) {
do_autoprune(jcr);
} else {
native_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
native_restore_cleanup(jcr, JS_Canceled);
}
break;
}
break;
case JT_ADMIN:
if (!job_canceled(jcr)) {
if (do_admin(jcr)) {
do_autoprune(jcr);
} else {
admin_cleanup(jcr, JS_ErrorTerminated);
}
} else {
admin_cleanup(jcr, JS_Canceled);
}
break;
case JT_COPY:
case JT_MIGRATE:
if (!job_canceled(jcr)) {
if (do_migration(jcr)) {
do_autoprune(jcr);
} else {
migration_cleanup(jcr, JS_ErrorTerminated);
}
} else {
migration_cleanup(jcr, JS_Canceled);
}
break;
default:
Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
/* Send off any queued messages */
if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
dequeue_messages(jcr);
}
generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
Dsm_check(100);
return NULL;
}
/* Returns: 0 for OK
* -1 for error
*/
int job_setattr(PyObject *self, char *attrname, PyObject *value)
{
JCR *jcr;
bool found = false;
char *strval = NULL;
int intval = 0;
int i;
Dmsg2(100, "In job_setattr=%s val=%p.\n", attrname, value);
if (value == NULL) { /* Cannot delete variables */
goto bail_out;
}
jcr = get_jcr_from_PyObject(self);
if (!jcr) {
goto bail_out;
}
/* Find attribute name in list */
for (i=0; setvars[i].name; i++) {
if (strcmp(setvars[i].name, attrname) == 0) {
found = true;
break;
}
}
if (!found) {
goto bail_out;
}
/* Get argument value */
if (setvars[i].fmt != NULL) {
switch (setvars[i].fmt[0]) {
case 's':
if (!PyArg_Parse(value, (char *)setvars[i].fmt, &strval)) {
PyErr_SetString(PyExc_TypeError, _("Read-only attribute"));
return -1;
}
break;
case 'i':
if (!PyArg_Parse(value, (char *)setvars[i].fmt, &intval)) {
PyErr_SetString(PyExc_TypeError, _("Read-only attribute"));
return -1;
}
break;
}
}
switch (i) {
case 0: /* JobReport */
Jmsg(jcr, M_INFO, 0, "%s", strval);
return 0;
case 1: /* VolumeName */
/* Make sure VolumeName is valid and we are in VolumeName event */
if (strcmp("NewVolume", jcr->event) == 0 &&
is_volume_name_legal(NULL, strval)) {
pm_strcpy(jcr->VolumeName, strval);
Dmsg1(100, "Set Vol=%s\n", strval);
return 0;
} else {
jcr->VolumeName[0] = 0;
}
break;
case 2: /* Priority */
Dmsg1(000, "Set priority=%d\n", intval);
if (intval >= 1 && intval <= 100) {
jcr->JobPriority = intval;
} else {
PyErr_SetString(PyExc_ValueError, _("Priority must be 1-100"));
return -1;
}
case 3: /* Job Level */
if (strcmp("JobInit", jcr->event) != 0) {
PyErr_SetString(PyExc_RuntimeError, _("Job Level can be set only during JobInit"));
return -1;
}
if (strval != NULL) {
for (i=0; joblevels[i].level_name; i++) {
if (strcmp(strval, joblevels[i].level_name) == 0) {
if (joblevels[i].job_type == jcr->getJobType()) {
jcr->setJobLevel(joblevels[i].level);
jcr->jr.JobLevel = jcr->getJobLevel();
return 0;
}
}
}
}
PyErr_SetString(PyExc_ValueError, _("Bad JobLevel string"));
return -1;
}
bail_out:
PyErr_SetString(PyExc_AttributeError, attrname);
return -1;
}
/* Returns: NULL if error
* PyObject * return value if OK
*/
PyObject *job_getattr(PyObject *self, char *attrname)
{
JCR *jcr;
bool found = false;
int i;
char buf[10];
char errmsg[200];
Dmsg0(100, "In job_getattr.\n");
jcr = get_jcr_from_PyObject(self);
if (!jcr) {
bstrncpy(errmsg, _("Job pointer not found."), sizeof(errmsg));
goto bail_out;
}
for (i=0; getvars[i].name; i++) {
if (strcmp(getvars[i].name, attrname) == 0) {
found = true;
break;
}
}
if (!found) {
/* Try our methods */
return Py_FindMethod(JobMethods, self, attrname);
}
switch (i) {
case 0: /* Job */
return Py_BuildValue((char *)getvars[i].fmt, jcr->job->hdr.name);
case 1: /* level */
return Py_BuildValue((char *)getvars[i].fmt, job_level_to_str(jcr->getJobLevel()));
case 2: /* type */
return Py_BuildValue((char *)getvars[i].fmt, job_type_to_str(jcr->getJobType()));
case 3: /* JobId */
return Py_BuildValue((char *)getvars[i].fmt, jcr->JobId);
case 4: /* Client */
return Py_BuildValue((char *)getvars[i].fmt, jcr->client->hdr.name);
case 5: /* NumVols */
POOL_DBR pr;
memset(&pr, 0, sizeof(pr));
bstrncpy(pr.Name, jcr->pool->hdr.name, sizeof(pr.Name));
if (db_get_pool_record(jcr, jcr->db, &pr)) {
jcr->NumVols = pr.NumVols;
return Py_BuildValue((char *)getvars[i].fmt, jcr->NumVols);
} else {
bsnprintf(errmsg, sizeof(errmsg), _("Pool record not found."));
goto bail_out;
}
case 6: /* Pool */
return Py_BuildValue((char *)getvars[i].fmt, jcr->pool->name());
case 7: /* Storage */
if (jcr->wstore) {
return Py_BuildValue((char *)getvars[i].fmt, jcr->wstore->name());
} else if (jcr->rstore) {
return Py_BuildValue((char *)getvars[i].fmt, jcr->rstore->name());
} else {
goto bail_out;
}
case 8:
return Py_BuildValue((char *)getvars[i].fmt, jcr->catalog->name());
case 9: /* MediaType */
if (jcr->wstore) {
return Py_BuildValue((char *)getvars[i].fmt, jcr->wstore->media_type);
} else if (jcr->rstore) {
return Py_BuildValue((char *)getvars[i].fmt, jcr->rstore->media_type);
} else {
goto bail_out;
}
case 10: /* JobName */
return Py_BuildValue((char *)getvars[i].fmt, jcr->Job);
case 11: /* JobStatus */
buf[1] = 0;
buf[0] = jcr->JobStatus;
return Py_BuildValue((char *)getvars[i].fmt, buf);
case 12: /* Priority */
return Py_BuildValue((char *)getvars[i].fmt, jcr->JobPriority);
case 13:
return Py_BuildValue((char *)getvars[i].fmt, jcr->VolumeName);
case 14: /* CatalogRes */
return Py_BuildValue((char *)getvars[i].fmt,
jcr->catalog->db_name, jcr->catalog->db_address,
jcr->catalog->db_user, jcr->catalog->db_password,
jcr->catalog->db_socket, jcr->catalog->db_port,
db_get_type(jcr->db));
case 15: /* JobErrors */
return Py_BuildValue((char *)getvars[i].fmt, jcr->JobErrors);
case 16: /* JobFiles */
return Py_BuildValue((char *)getvars[i].fmt, jcr->JobFiles);
case 17: /* SDJobFiles */
return Py_BuildValue((char *)getvars[i].fmt, jcr->SDJobFiles);
case 18: /* SDErrors */
return Py_BuildValue((char *)getvars[i].fmt, jcr->SDErrors);
case 19: /* FDJobStatus */
buf[1] = 0;
buf[0] = jcr->FDJobStatus;
return Py_BuildValue((char *)getvars[i].fmt, buf);
case 20: /* SDJobStatus */
buf[1] = 0;
buf[0] = jcr->SDJobStatus;
return Py_BuildValue((char *)getvars[i].fmt, buf);
}
bsnprintf(errmsg, sizeof(errmsg), _("Attribute %s not found."), attrname);
bail_out:
PyErr_SetString(PyExc_AttributeError, errmsg);
return NULL;
}
static void list_running_jobs_api(STATUS_PKT *sp)
{
JCR *njcr;
int len, sec, bps;
POOL_MEM msg(PM_MESSAGE);
char dt[MAX_TIME_LENGTH], b1[32], b2[32], b3[32], b4[32];
/*
* List running jobs for Bat/Bweb (simple to parse)
*/
foreach_jcr(njcr) {
bstrutime(dt, sizeof(dt), njcr->start_time);
if (njcr->JobId == 0) {
len = Mmsg(msg, "DirectorConnected=%s\n", dt);
} else {
len = Mmsg(msg, "JobId=%d\n Job=%s\n",
njcr->JobId, njcr->Job);
sendit(msg, len, sp);
#ifdef WIN32_VSS
len = Mmsg(msg," VSS=%d\n Level=%c\n JobType=%c\n JobStarted=%s\n",
(njcr->pVSSClient && njcr->pVSSClient->IsInitialized()) ? 1 : 0,
njcr->getJobLevel(), njcr->getJobType(), dt);
#else
len = Mmsg(msg," VSS=%d\n Level=%c\n JobType=%c\n JobStarted=%s\n",
0, njcr->getJobLevel(), njcr->getJobType(), dt);
#endif
}
sendit(msg, len, sp);
if (njcr->JobId == 0) {
continue;
}
sec = time(NULL) - njcr->start_time;
if (sec <= 0) {
sec = 1;
}
bps = (int)(njcr->JobBytes / sec);
len = Mmsg(msg, " Files=%s\n Bytes=%s\n Bytes/sec=%s\n Errors=%d\n"
" Bwlimit=%s\n",
edit_uint64(njcr->JobFiles, b1),
edit_uint64(njcr->JobBytes, b2),
edit_uint64(bps, b3),
njcr->JobErrors, edit_int64(njcr->max_bandwidth, b4));
sendit(msg, len, sp);
len = Mmsg(msg, " Files Examined=%s\n",
edit_uint64(njcr->num_files_examined, b1));
sendit(msg, len, sp);
if (njcr->JobFiles > 0) {
njcr->lock();
len = Mmsg(msg, " Processing file=%s\n", njcr->last_fname);
njcr->unlock();
sendit(msg, len, sp);
}
if (njcr->store_bsock) {
len = Mmsg(msg, " SDReadSeqNo=%" lld "\n fd=%d\n",
njcr->store_bsock->read_seqno, njcr->store_bsock->m_fd);
sendit(msg, len, sp);
} else {
len = Mmsg(msg, _(" SDSocket=closed\n"));
sendit(msg, len, sp);
}
}
endeach_jcr(njcr);
}
static void list_running_jobs_plain(STATUS_PKT *sp)
{
JCR *njcr;
int len, sec, bps;
bool found = false;
POOL_MEM msg(PM_MESSAGE);
char dt[MAX_TIME_LENGTH], b1[32], b2[32], b3[32], b4[32];
/*
* List running jobs
*/
Dmsg0(1000, "Begin status jcr loop.\n");
len = Mmsg(msg, _("\nRunning Jobs:\n"));
sendit(msg, len, sp);
foreach_jcr(njcr) {
bstrftime_nc(dt, sizeof(dt), njcr->start_time);
if (njcr->JobId == 0) {
len = Mmsg(msg, _("Director connected at: %s\n"), dt);
} else {
len = Mmsg(msg, _("JobId %d Job %s is running.\n"),
njcr->JobId, njcr->Job);
sendit(msg, len, sp);
#ifdef WIN32_VSS
len = Mmsg(msg, _(" %s%s %s Job started: %s\n"),
(njcr->pVSSClient && njcr->pVSSClient->IsInitialized()) ? "VSS " : "",
level_to_str(njcr->getJobLevel()),
job_type_to_str(njcr->getJobType()), dt);
#else
len = Mmsg(msg, _(" %s %s Job started: %s\n"),
level_to_str(njcr->getJobLevel()),
job_type_to_str(njcr->getJobType()), dt);
#endif
}
sendit(msg, len, sp);
if (njcr->JobId == 0) {
continue;
}
sec = time(NULL) - njcr->start_time;
if (sec <= 0) {
sec = 1;
}
bps = (int)(njcr->JobBytes / sec);
len = Mmsg(msg, _(" Files=%s Bytes=%s Bytes/sec=%s Errors=%d\n"
" Bwlimit=%s\n"),
edit_uint64_with_commas(njcr->JobFiles, b1),
edit_uint64_with_commas(njcr->JobBytes, b2),
edit_uint64_with_commas(bps, b3),
njcr->JobErrors,
edit_uint64_with_commas(njcr->max_bandwidth, b4));
sendit(msg, len, sp);
len = Mmsg(msg, _(" Files Examined=%s\n"),
edit_uint64_with_commas(njcr->num_files_examined, b1));
sendit(msg, len, sp);
if (njcr->JobFiles > 0) {
njcr->lock();
len = Mmsg(msg, _(" Processing file: %s\n"), njcr->last_fname);
njcr->unlock();
sendit(msg, len, sp);
}
found = true;
if (njcr->store_bsock) {
len = Mmsg(msg, " SDReadSeqNo=%" lld " fd=%d\n",
njcr->store_bsock->read_seqno, njcr->store_bsock->m_fd);
sendit(msg, len, sp);
} else {
len = Mmsg(msg, _(" SDSocket closed.\n"));
sendit(msg, len, sp);
}
}
endeach_jcr(njcr);
if (!found) {
len = Mmsg(msg, _("No Jobs running.\n"));
sendit(msg, len, sp);
}
len = pm_strcpy(msg, _("====\n"));
sendit(msg, len, sp);
}