X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fjob.c;h=e387dd9255193a5622c35c6b9c1e1b9dae96508b;hb=976bb75e86bee77eb79b97a20ff152454badbe9f;hp=7c9678f60e6c2d88043b6c602033ed9ff4473634;hpb=5483b82f16f28424ca126db50f7bf71e53023e3e;p=bacula%2Fbacula diff --git a/bacula/src/dird/job.c b/bacula/src/dird/job.c index 7c9678f60e..e387dd9255 100644 --- a/bacula/src/dird/job.c +++ b/bacula/src/dird/job.c @@ -7,7 +7,7 @@ * Version $Id$ */ /* - Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker + Copyright (C) 2000-2004 Kern Sibbald and John Walker This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as @@ -30,138 +30,180 @@ #include "dird.h" /* Forward referenced subroutines */ -static void job_thread(void *arg); -static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg); +static void *job_thread(void *arg); +static void job_monitor_watchdog(watchdog_t *self); +static void job_monitor_destructor(watchdog_t *self); +static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr); +static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr); /* Exported subroutines */ -void run_job(JCR *jcr); -void init_job_server(int max_workers); - /* Imported subroutines */ extern void term_scheduler(); extern void term_ua_server(); extern int do_backup(JCR *jcr); +extern int do_admin(JCR *jcr); extern int do_restore(JCR *jcr); extern int do_verify(JCR *jcr); -extern void backup_cleanup(void); -extern void start_UA_server(int port); -/* Queue of jobs to be run */ -static workq_t job_wq; /* our job work queue */ +/* Imported variables */ +extern time_t watchdog_time; +jobq_t job_queue; void init_job_server(int max_workers) { int stat; - - if ((stat = workq_init(&job_wq, max_workers, job_thread)) != 0) { - Emsg1(M_ABORT, 0, _("Could not init job work queue: ERR=%s\n"), strerror(stat)); + watchdog_t *wd; + + if ((stat = jobq_init(&job_queue, max_workers, job_thread)) != 0) { + berrno be; + be.set_errno(stat); + Emsg1(M_ABORT, 0, _("Could not init job queue: ERR=%s\n"), be.strerror()); + } + if ((wd = new_watchdog()) == NULL) { + Emsg0(M_ABORT, 0, _("Could not init job monitor watchdogs\n")); } - return; + wd->callback = job_monitor_watchdog; + wd->destructor = job_monitor_destructor; + wd->one_shot = false; + wd->interval = 60; + wd->data = new_control_jcr("*JobMonitor*", JT_SYSTEM); + register_watchdog(wd); } /* * Run a job -- typically called by the scheduler, but may also * be called by the UA (Console program). * + * Returns: 0 on failure + * JobId on success + * */ -void run_job(JCR *jcr) +JobId_t run_job(JCR *jcr) { int stat, errstat; + JobId_t JobId = 0; - init_msg(jcr, jcr->msgs); - create_unique_job_name(jcr, jcr->job->hdr.name); - jcr->jr.SchedTime = jcr->sched_time; - jcr->jr.StartTime = jcr->start_time; - jcr->jr.Type = jcr->JobType; - jcr->jr.Level = jcr->JobLevel; - jcr->jr.JobStatus = jcr->JobStatus; - strcpy(jcr->jr.Name, jcr->job->hdr.name); - strcpy(jcr->jr.Job, jcr->Job); + P(jcr->mutex); + sm_check(__FILE__, __LINE__, true); + init_msg(jcr, jcr->messages); /* Initialize termination condition variable */ if ((errstat = pthread_cond_init(&jcr->term_wait, NULL)) != 0) { - Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), strerror(errstat)); - jcr->JobStatus = JS_ErrorTerminated; - free_jcr(jcr); - return; + berrno be; + be.set_errno(errstat); + Jmsg1(jcr, M_FATAL, 0, _("Unable to init job cond variable: ERR=%s\n"), be.strerror()); + goto bail_out; } + jcr->term_wait_inited = true; /* * Open database */ Dmsg0(50, "Open database\n"); - jcr->db=db_init_database(jcr->catalog->db_name, jcr->catalog->db_user, - jcr->catalog->db_password); - if (!db_open_database(jcr->db)) { - Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); - db_close_database(jcr->db); - jcr->JobStatus = JS_ErrorTerminated; - free_jcr(jcr); - return; + jcr->db=db_init_database(jcr, jcr->catalog->db_name, jcr->catalog->db_user, + jcr->catalog->db_password, jcr->catalog->db_address, + jcr->catalog->db_port, jcr->catalog->db_socket); + if (!jcr->db || !db_open_database(jcr, jcr->db)) { + Jmsg(jcr, M_FATAL, 0, _("Could not open database \"%s\".\n"), + jcr->catalog->db_name); + if (jcr->db) { + Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); + } + goto bail_out; } Dmsg0(50, "DB opened\n"); /* * Create Job record */ - jcr->jr.JobStatus = jcr->JobStatus; - if (!db_create_job_record(jcr->db, &jcr->jr)) { + create_unique_job_name(jcr, jcr->job->hdr.name); + set_jcr_job_status(jcr, JS_Created); + init_jcr_job_record(jcr); + if (!db_create_job_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db)); - db_close_database(jcr->db); - jcr->JobStatus = JS_ErrorTerminated; - free_jcr(jcr); - return; + goto bail_out; } - jcr->JobId = jcr->jr.JobId; - ASSERT(jcr->jr.JobId > 0); + JobId = jcr->JobId = jcr->jr.JobId; - Dmsg4(30, "Created job record JobId=%d Name=%s Type=%c Level=%c\n", - jcr->JobId, jcr->Job, jcr->jr.Type, jcr->jr.Level); + Dmsg4(100, "Created job record JobId=%d Name=%s Type=%c Level=%c\n", + jcr->JobId, jcr->Job, jcr->jr.JobType, jcr->jr.JobLevel); Dmsg0(200, "Add jrc to work queue\n"); - /* Queue the job to be run */ - if ((stat = workq_add(&job_wq, (void *)jcr)) != 0) { - Emsg1(M_ABORT, 0, _("Could not add job to work queue: ERR=%s\n"), strerror(stat)); + if ((stat = jobq_add(&job_queue, jcr)) != 0) { + berrno be; + be.set_errno(stat); + Jmsg(jcr, M_FATAL, 0, _("Could not add job queue: ERR=%s\n"), be.strerror()); + JobId = 0; + goto bail_out; } - Dmsg0(200, "Done run_job()\n"); + Dmsg0(100, "Done run_job()\n"); + + V(jcr->mutex); + return JobId; + +bail_out: + set_jcr_job_status(jcr, JS_ErrorTerminated); + V(jcr->mutex); + return JobId; + } + /* - * This is the engine called by workq_add() when we were pulled + * 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 + * 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) +static void *job_thread(void *arg) { - time_t now; JCR *jcr = (JCR *)arg; - time(&now); - - Dmsg0(100, "=====Start Job=========\n"); - jcr->start_time = now; /* set the real start time */ - if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < - (btime_t)(jcr->start_time - jcr->sched_time)) { - Jmsg(jcr, M_FATAL, 0, _("Job cancelled because max delay time exceeded.\n")); - jcr->JobStatus = JS_ErrorTerminated; - update_job_end_record(jcr); - } else { - - /* Run Job */ - jcr->JobStatus = JS_Running; + jcr->my_thread_id = pthread_self(); + pthread_detach(jcr->my_thread_id); + sm_check(__FILE__, __LINE__, true); + + for ( ;; ) { + Dmsg0(200, "=====Start Job=========\n"); + jcr->start_time = time(NULL); /* set the real start time */ + set_jcr_job_status(jcr, JS_Running); + + if (job_canceled(jcr)) { + update_job_end_record(jcr); + } else if (jcr->job->MaxStartDelay != 0 && jcr->job->MaxStartDelay < + (utime_t)(jcr->start_time - jcr->sched_time)) { + Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n")); + set_jcr_job_status(jcr, JS_Canceled); + update_job_end_record(jcr); + } else { - if (jcr->job->RunBeforeJob) { - POOLMEM *before = get_pool_memory(PM_FNAME); - int status; - - before = edit_run_codes(jcr, before, jcr->job->RunBeforeJob); - status = run_program(before, 0, NULL); - free_pool_memory(before); - } - switch (jcr->JobType) { + /* Run Job */ + if (jcr->job->RunBeforeJob) { + POOLMEM *before = get_pool_memory(PM_FNAME); + int status; + BPIPE *bpipe; + char line[MAXSTRING]; + + before = edit_job_codes(jcr, before, jcr->job->RunBeforeJob, ""); + bpipe = open_bpipe(before, 0, "r"); + free_pool_memory(before); + while (fgets(line, sizeof(line), bpipe->rfd)) { + Jmsg(jcr, M_INFO, 0, _("RunBefore: %s"), line); + } + status = close_bpipe(bpipe); + if (status != 0) { + berrno be; + be.set_errno(status); + Jmsg(jcr, M_FATAL, 0, _("RunBeforeJob error: ERR=%s\n"), be.strerror()); + set_jcr_job_status(jcr, JS_FatalError); + update_job_end_record(jcr); + goto bail_out; + } + } + switch (jcr->JobType) { case JT_BACKUP: do_backup(jcr); if (jcr->JobStatus == JS_Terminated) { @@ -181,65 +223,380 @@ static void job_thread(void *arg) } break; case JT_ADMIN: - /* No actual job */ - do_autoprune(jcr); - jcr->JobStatus = JS_Terminated; + do_admin(jcr); + if (jcr->JobStatus == JS_Terminated) { + do_autoprune(jcr); + } break; default: - Dmsg1(0, "Unimplemented job type: %d\n", jcr->JobType); + Pmsg1(0, "Unimplemented job type: %d\n", jcr->JobType); break; } + if ((jcr->job->RunAfterJob && jcr->JobStatus == JS_Terminated) || + (jcr->job->RunAfterFailedJob && jcr->JobStatus != JS_Terminated)) { + POOLMEM *after = get_pool_memory(PM_FNAME); + int status; + BPIPE *bpipe; + char line[MAXSTRING]; + + if (jcr->JobStatus == JS_Terminated) { + after = edit_job_codes(jcr, after, jcr->job->RunAfterJob, ""); + } else { + after = edit_job_codes(jcr, after, jcr->job->RunAfterFailedJob, ""); + } + bpipe = open_bpipe(after, 0, "r"); + free_pool_memory(after); + while (fgets(line, sizeof(line), bpipe->rfd)) { + Jmsg(jcr, M_INFO, 0, _("RunAfter: %s"), line); + } + status = close_bpipe(bpipe); + /* + * Note, if we get an error here, do not mark the + * job in error, simply report the error condition. + */ + if (status != 0) { + berrno be; + be.set_errno(status); + if (jcr->JobStatus == JS_Terminated) { + Jmsg(jcr, M_WARNING, 0, _("RunAfterJob error: ERR=%s\n"), be.strerror()); + } else { + Jmsg(jcr, M_FATAL, 0, _("RunAfterFailedJob error: ERR=%s\n"), be.strerror()); + } + } + } + /* Send off any queued messages */ + if (jcr->msg_queue->size() > 0) { + dequeue_messages(jcr); + } + } +bail_out: + break; } - if (jcr->job->RunAfterJob) { - POOLMEM *after = get_pool_memory(PM_FNAME); - int status; - - after = edit_run_codes(jcr, after, jcr->job->RunAfterJob); - status = run_program(after, 0, NULL); - free_pool_memory(after); - } - Dmsg0(50, "Before free jcr\n"); - free_jcr(jcr); + Dmsg0(50, "======== End Job ==========\n"); + sm_check(__FILE__, __LINE__, true); + return NULL; } + +/* + * Cancel a job -- typically called by the UA (Console program), but may also + * be called by the job watchdog. + * + * Returns: 1 if cancel appears to be successful + * 0 on failure. Message sent to ua->jcr. + */ +int cancel_job(UAContext *ua, JCR *jcr) +{ + BSOCK *sd, *fd; + + switch (jcr->JobStatus) { + case JS_Created: + case JS_WaitJobRes: + case JS_WaitClientRes: + case JS_WaitStoreRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + set_jcr_job_status(jcr, JS_Canceled); + bsendmsg(ua, _("JobId %d, Job %s marked to be canceled.\n"), + jcr->JobId, jcr->Job); + jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */ + return 1; + + default: + set_jcr_job_status(jcr, JS_Canceled); + + /* Cancel File daemon */ + if (jcr->file_bsock) { + ua->jcr->client = jcr->client; + if (!connect_to_file_daemon(ua->jcr, 10, FDConnectTimeout, 1)) { + bsendmsg(ua, _("Failed to connect to File daemon.\n")); + return 0; + } + Dmsg0(200, "Connected to file daemon\n"); + fd = ua->jcr->file_bsock; + bnet_fsend(fd, "cancel Job=%s\n", jcr->Job); + while (bnet_recv(fd) >= 0) { + bsendmsg(ua, "%s", fd->msg); + } + bnet_sig(fd, BNET_TERMINATE); + bnet_close(fd); + ua->jcr->file_bsock = NULL; + } + + /* Cancel Storage daemon */ + if (jcr->store_bsock) { + ua->jcr->store = jcr->store; + if (!connect_to_storage_daemon(ua->jcr, 10, SDConnectTimeout, 1)) { + bsendmsg(ua, _("Failed to connect to Storage daemon.\n")); + return 0; + } + Dmsg0(200, "Connected to storage daemon\n"); + sd = ua->jcr->store_bsock; + bnet_fsend(sd, "cancel Job=%s\n", jcr->Job); + while (bnet_recv(sd) >= 0) { + bsendmsg(ua, "%s", sd->msg); + } + bnet_sig(sd, BNET_TERMINATE); + bnet_close(sd); + ua->jcr->store_bsock = NULL; + } + } + + return 1; +} + + +static void job_monitor_destructor(watchdog_t *self) +{ + JCR *control_jcr = (JCR *) self->data; + + free_jcr(control_jcr); +} + +static void job_monitor_watchdog(watchdog_t *self) +{ + JCR *control_jcr, *jcr; + + control_jcr = (JCR *)self->data; + + Dmsg1(400, "job_monitor_watchdog %p called\n", self); + + lock_jcr_chain(); + + foreach_jcr(jcr) { + bool cancel; + + if (jcr->JobId == 0) { + Dmsg2(400, "Skipping JCR %p (%s) with JobId 0\n", + jcr, jcr->Job); + /* Keep reference counts correct */ + free_locked_jcr(jcr); + continue; + } + + /* check MaxWaitTime */ + cancel = job_check_maxwaittime(control_jcr, jcr); + + /* check MaxRunTime */ + cancel |= job_check_maxruntime(control_jcr, jcr); + + if (cancel) { + Dmsg3(200, "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); + + Dmsg1(200, "Have cancelled JCR %p\n", jcr); + } + + /* Keep reference counts correct */ + free_locked_jcr(jcr); + } + unlock_jcr_chain(); +} + +/* + * Check if the maxwaittime has expired and it is possible + * to cancel the job. + */ +static bool job_check_maxwaittime(JCR *control_jcr, JCR *jcr) +{ + bool cancel = false; + + if (jcr->job->MaxWaitTime == 0) { + return false; + } + if ((watchdog_time - jcr->start_time) < jcr->job->MaxWaitTime) { + Dmsg3(200, "Job %p (%s) with MaxWaitTime %d not expired\n", + jcr, jcr->Job, jcr->job->MaxWaitTime); + return false; + } + Dmsg3(200, "Job %d (%s): MaxWaitTime of %d seconds exceeded, " + "checking status\n", + jcr->JobId, jcr->Job, jcr->job->MaxWaitTime); + switch (jcr->JobStatus) { + case JS_Created: + case JS_Blocked: + case JS_WaitFD: + case JS_WaitSD: + case JS_WaitStoreRes: + case JS_WaitClientRes: + case JS_WaitJobRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + cancel = true; + Dmsg0(200, "JCR blocked in #1\n"); + break; + case JS_Running: + Dmsg0(200, "JCR running, checking SD status\n"); + switch (jcr->SDJobStatus) { + case JS_WaitMount: + case JS_WaitMedia: + case JS_WaitFD: + cancel = true; + Dmsg0(200, "JCR blocked in #2\n"); + break; + default: + Dmsg0(200, "JCR not blocked in #2\n"); + break; + } + break; + case JS_Terminated: + case JS_ErrorTerminated: + case JS_Canceled: + case JS_FatalError: + Dmsg0(200, "JCR already dead in #3\n"); + break; + default: + Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), + jcr->JobStatus); + } + Dmsg3(200, "MaxWaitTime result: %scancel JCR %p (%s)\n", + cancel ? "" : "do not ", jcr, jcr->job); + + return cancel; +} + +/* + * Check if maxruntime has expired and if the job can be + * canceled. + */ +static bool job_check_maxruntime(JCR *control_jcr, JCR *jcr) +{ + bool cancel = false; + + if (jcr->job->MaxRunTime == 0) { + return false; + } + if ((watchdog_time - jcr->start_time) < jcr->job->MaxRunTime) { + Dmsg3(200, "Job %p (%s) with MaxRunTime %d not expired\n", + jcr, jcr->Job, jcr->job->MaxRunTime); + return false; + } + + switch (jcr->JobStatus) { + case JS_Created: + case JS_Running: + case JS_Blocked: + case JS_WaitFD: + case JS_WaitSD: + case JS_WaitStoreRes: + case JS_WaitClientRes: + case JS_WaitJobRes: + case JS_WaitPriority: + case JS_WaitMaxJobs: + case JS_WaitStartTime: + case JS_Differences: + cancel = true; + break; + case JS_Terminated: + case JS_ErrorTerminated: + case JS_Canceled: + case JS_FatalError: + cancel = false; + break; + default: + Jmsg1(jcr, M_ERROR, 0, _("Unhandled job status code %d\n"), + jcr->JobStatus); + } + + Dmsg3(200, "MaxRunTime result: %scancel JCR %p (%s)\n", + cancel ? "" : "do not ", jcr, jcr->job); + + return cancel; +} + + /* * Get or create a Client record for this Job */ -int get_or_create_client_record(JCR *jcr) +bool get_or_create_client_record(JCR *jcr) { CLIENT_DBR cr; memset(&cr, 0, sizeof(cr)); - strcpy(cr.Name, jcr->client->hdr.name); + bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name)); cr.AutoPrune = jcr->client->AutoPrune; cr.FileRetention = jcr->client->FileRetention; cr.JobRetention = jcr->client->JobRetention; - if (jcr->client_name) { - free_pool_memory(jcr->client_name); + if (!jcr->client_name) { + jcr->client_name = get_pool_memory(PM_NAME); } - jcr->client_name = get_memory(strlen(jcr->client->hdr.name) + 1); - strcpy(jcr->client_name, jcr->client->hdr.name); - if (!db_create_client_record(jcr->db, &cr)) { - Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. %s"), + pm_strcpy(&jcr->client_name, jcr->client->hdr.name); + if (!db_create_client_record(jcr, jcr->db, &cr)) { + Jmsg(jcr, M_FATAL, 0, _("Could not create Client record. ERR=%s\n"), db_strerror(jcr->db)); - return 0; + return false; } jcr->jr.ClientId = cr.ClientId; - Dmsg2(9, "Created Client %s record %d\n", jcr->client->hdr.name, + if (cr.Uname[0]) { + if (!jcr->client_uname) { + jcr->client_uname = get_pool_memory(PM_NAME); + } + pm_strcpy(&jcr->client_uname, cr.Uname); + } + Dmsg2(100, "Created Client %s record %d\n", jcr->client->hdr.name, jcr->jr.ClientId); - return 1; + return true; } +bool get_or_create_fileset_record(JCR *jcr, FILESET_DBR *fsr) +{ + /* + * Get or Create FileSet record + */ + memset(fsr, 0, sizeof(FILESET_DBR)); + bstrncpy(fsr->FileSet, jcr->fileset->hdr.name, sizeof(fsr->FileSet)); + if (jcr->fileset->have_MD5) { + struct MD5Context md5c; + unsigned char signature[16]; + memcpy(&md5c, &jcr->fileset->md5c, sizeof(md5c)); + MD5Final(signature, &md5c); + bin_to_base64(fsr->MD5, (char *)signature, 16); /* encode 16 bytes */ + bstrncpy(jcr->fileset->MD5, fsr->MD5, sizeof(jcr->fileset->MD5)); + } else { + Jmsg(jcr, M_WARNING, 0, _("FileSet MD5 signature not found.\n")); + } + if (!db_create_fileset_record(jcr, jcr->db, fsr)) { + Jmsg(jcr, M_ERROR, 0, _("Could not create FileSet \"%s\" record. ERR=%s\n"), + fsr->FileSet, db_strerror(jcr->db)); + return false; + } + jcr->jr.FileSetId = fsr->FileSetId; + if (fsr->created) { + Jmsg(jcr, M_INFO, 0, _("Created new FileSet record \"%s\" %s\n"), + fsr->FileSet, fsr->cCreateTime); + } + Dmsg2(119, "Created FileSet %s record %u\n", jcr->fileset->hdr.name, + jcr->jr.FileSetId); + return true; +} + +void init_jcr_job_record(JCR *jcr) +{ + jcr->jr.SchedTime = jcr->sched_time; + jcr->jr.StartTime = jcr->start_time; + jcr->jr.EndTime = 0; /* perhaps rescheduled, clear it */ + jcr->jr.JobType = jcr->JobType; + jcr->jr.JobLevel = jcr->JobLevel; + jcr->jr.JobStatus = jcr->JobStatus; + jcr->jr.JobId = jcr->JobId; + bstrncpy(jcr->jr.Name, jcr->job->hdr.name, sizeof(jcr->jr.Name)); + bstrncpy(jcr->jr.Job, jcr->Job, sizeof(jcr->jr.Job)); +} /* * Write status and such in DB */ void update_job_end_record(JCR *jcr) { - if (jcr->jr.EndTime == 0) { - jcr->jr.EndTime = time(NULL); - } + jcr->jr.EndTime = time(NULL); jcr->end_time = jcr->jr.EndTime; jcr->jr.JobId = jcr->JobId; jcr->jr.JobStatus = jcr->JobStatus; @@ -247,7 +604,7 @@ void update_job_end_record(JCR *jcr) jcr->jr.JobBytes = jcr->JobBytes; jcr->jr.VolSessionId = jcr->VolSessionId; jcr->jr.VolSessionTime = jcr->VolSessionTime; - if (!db_update_job_end_record(jcr->db, &jcr->jr)) { + if (!db_update_job_end_record(jcr, jcr->db, &jcr->jr)) { Jmsg(jcr, M_WARNING, 0, _("Error updating job record. %s"), db_strerror(jcr->db)); } @@ -260,7 +617,7 @@ void update_job_end_record(JCR *jcr) * Returns: unique job name in jcr->Job * date/time in jcr->start_time */ -void create_unique_job_name(JCR *jcr, char *base_name) +void create_unique_job_name(JCR *jcr, const char *base_name) { /* Job start mutex */ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; @@ -275,20 +632,21 @@ void create_unique_job_name(JCR *jcr, char *base_name) * thus unique Job Name */ P(mutex); /* lock creation of jobs */ - time(&now); + now = time(NULL); while (now == last_start_time) { - sleep(1); - time(&now); + bmicrosleep(0, 500000); + now = time(NULL); } last_start_time = now; V(mutex); /* allow creation of jobs */ jcr->start_time = now; /* Form Unique JobName */ localtime_r(&now, &tm); - strftime(dt, sizeof(dt), "%Y-%m-%d.%H:%M:%S", &tm); - strncpy(name, base_name, sizeof(name)); + /* Use only characters that are permitted in Windows filenames */ + strftime(dt, sizeof(dt), "%Y-%m-%d_%H.%M.%S", &tm); + bstrncpy(name, base_name, sizeof(name)); name[sizeof(name)-22] = 0; /* truncate if too long */ - sprintf(jcr->Job, "%s.%s", name, dt); /* add date & time */ + bsnprintf(jcr->Job, sizeof(jcr->Job), "%s.%s", name, dt); /* add date & time */ /* Convert spaces into underscores */ for (p=jcr->Job; *p; p++) { if (*p == ' ') { @@ -306,32 +664,46 @@ void dird_free_jcr(JCR *jcr) { Dmsg0(200, "Start dird free_jcr\n"); + if (jcr->sd_auth_key) { + free(jcr->sd_auth_key); + jcr->sd_auth_key = NULL; + } + if (jcr->where) { + free(jcr->where); + jcr->where = NULL; + } if (jcr->file_bsock) { Dmsg0(200, "Close File bsock\n"); bnet_close(jcr->file_bsock); + jcr->file_bsock = NULL; } if (jcr->store_bsock) { Dmsg0(200, "Close Store bsock\n"); bnet_close(jcr->store_bsock); + jcr->store_bsock = NULL; } if (jcr->fname) { Dmsg0(200, "Free JCR fname\n"); free_pool_memory(jcr->fname); + jcr->fname = NULL; } if (jcr->stime) { Dmsg0(200, "Free JCR stime\n"); free_pool_memory(jcr->stime); - } - if (jcr->db) { - Dmsg0(200, "Close DB\n"); - db_close_database(jcr->db); - } - if (jcr->RestoreWhere) { - free(jcr->RestoreWhere); + jcr->stime = NULL; } if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); + jcr->RestoreBootstrap = NULL; + } + if (jcr->client_uname) { + free_pool_memory(jcr->client_uname); + jcr->client_uname = NULL; + } + if (jcr->term_wait_inited) { + pthread_cond_destroy(&jcr->term_wait); } + jcr->job_end_push.destroy(); Dmsg0(200, "End dird free_jcr\n"); } @@ -346,20 +718,33 @@ void set_jcr_defaults(JCR *jcr, JOB *job) { jcr->job = job; jcr->JobType = job->JobType; - jcr->JobLevel = job->level; + switch (jcr->JobType) { + case JT_ADMIN: + case JT_RESTORE: + jcr->JobLevel = L_NONE; + break; + default: + jcr->JobLevel = job->level; + break; + } + jcr->JobPriority = job->Priority; jcr->store = job->storage; jcr->client = job->client; - if (jcr->client_name) { - free_pool_memory(jcr->client_name); + if (!jcr->client_name) { + jcr->client_name = get_pool_memory(PM_NAME); } - jcr->client_name = get_memory(strlen(jcr->client->hdr.name) + 1); - strcpy(jcr->client_name, jcr->client->hdr.name); + pm_strcpy(&jcr->client_name, jcr->client->hdr.name); jcr->pool = job->pool; + jcr->full_pool = job->full_pool; + jcr->inc_pool = job->inc_pool; + jcr->dif_pool = job->dif_pool; jcr->catalog = job->client->catalog; - jcr->fileset = job->fs; - jcr->msgs = job->messages; + jcr->fileset = job->fileset; + jcr->messages = job->messages; + jcr->spool_data = job->spool_data; if (jcr->RestoreBootstrap) { free(jcr->RestoreBootstrap); + jcr->RestoreBootstrap = NULL; } /* This can be overridden by Console program */ if (job->RestoreBootstrap) { @@ -374,89 +759,12 @@ void set_jcr_defaults(JCR *jcr, JOB *job) case JT_BACKUP: jcr->JobLevel = L_INCREMENTAL; break; + case JT_RESTORE: + case JT_ADMIN: + jcr->JobLevel = L_NONE; + break; default: break; } } } - -/* - * Edit codes into Run command - * %% = % - * %c = Client's name - * %d = Director's name - * %i = JobId - * %e = Job Exit - * %j = Job - * %l = Job Level - * %n = Job name - * %t = Job type - * - * omsg = edited output message - * imsg = input string containing edit codes (%x) - * - */ -static char *edit_run_codes(JCR *jcr, char *omsg, char *imsg) -{ - char *p, *o; - const char *str; - char add[20]; - - Dmsg1(200, "edit_run_codes: %s\n", imsg); - add[2] = 0; - o = omsg; - for (p=imsg; *p; p++) { - if (*p == '%') { - switch (*++p) { - case '%': - add[0] = '%'; - add[1] = 0; - str = add; - break; - case 'c': - str = jcr->client_name; - if (!str) { - str = ""; - } - break; - case 'd': - str = my_name; - break; - case 'e': - str = job_status_to_str(jcr->JobStatus); - break; - case 'i': - sprintf(add, "%d", jcr->JobId); - str = add; - break; - case 'j': /* Job */ - str = jcr->Job; - break; - case 'l': - str = job_level_to_str(jcr->JobLevel); - break; - case 'n': - str = jcr->job->hdr.name; - break; - case 't': - str = job_type_to_str(jcr->JobType); - break; - default: - add[0] = '%'; - add[1] = *p; - str = add; - break; - } - } else { - add[0] = *p; - add[1] = 0; - str = add; - } - Dmsg1(200, "add_str %s\n", str); - add_str_to_pool_mem(&omsg, &o, (char *)str); - *o = 0; - Dmsg1(200, "omsg=%s\n", omsg); - } - *o = 0; - return omsg; -}