DataGen::DataGen(ulen n)
: qset(DoReserve,1000)
{
// make qset
SmallPrimesSet spset(n);
do
{
PrimeQ q(spset);
if( q.test() ) qset.append_copy(q);
}
while( spset.next() );
qset.shrink_extra();
Sort(Range(qset));
// make pset
for(ulen ind=0; ind<=n ;ind++) pset.append_fill(ind);
// make Jacobi
{
for(ulen j=0,len=qset.getLen(); j<len ;j++)
{
JobControl ctrl(qset[j],Range(pset));
Job run_job(ctrl.function_job());
}
}
}
/*
* schedule_tasks
*
* Description:
* Schedule tasks using EDF.
*
* Inputs:
* sched_task - an array of tasks to schedule
* n_tasks - number of tasks to schedule
*
* Outputs:
* none
*
* Returns:
* schedule_tasks return 0 upon success.
*
* Side Effects
* Job related fields in sched_task are modified.
*/
int schedule_tasks(task_t *sched_task, int n_tasks)
{
double now; /* current time */
double end; /* time to end simulation */
double energy; /* total energy used */
int index;
task_t *cur; /* pointer to current task */
tasks = sched_task;
ntask = n_tasks;
srandom(599);
/* all tasks are initially released at t = 0 */
for (index = 0 ; index < n_tasks ; index++) {
enqueue(&ready, &tasks[index]);
release(&tasks[index]);
}
wait = NULL;
freq = 1.0;
volts = 1.0;
energy = 0.0;
/* run simulation for 2x the hyperperiod */
end = compute_hyperperiod(tasks, n_tasks) * 2;
now = 0.0;
while(now < end) {
/* run next job in ready queue */
if (wait == NULL
|| (now + (ready->cur_exec - ready->usage)/freq
<= wait->next_evt)) {
/* job runs to completion (i.e., it's not preempted) */
energy += (ready->cur_exec - ready->usage)
* freq * volts * volts;
now = completion(now);
} else {
/* scheduling decision at next_evt */
run_job(ready, ready->job, now, wait->next_evt, freq);
ready->usage += (wait->next_evt - now) * freq;
energy += (wait->next_evt-now) * freq * volts * volts;
now = wait->next_evt;
}
if (ready == NULL) {
/* skip idle time until next release */
now = wait->next_evt;
}
/* release jobs in wait queue that are at release time */
while(wait && wait->next_evt <= now) {
cur = dequeue(&wait);
cur->next_evt += cur->deadline;
release(cur);
enqueue(&ready, cur);
}
}
printf("energy used = %f\n", energy);
return 0;
}
bool run_cmd(JCR *jcr)
{
struct timeval tv;
struct timezone tz;
struct timespec timeout;
int errstat = 0;
Dsm_check(200);
Dmsg1(200, "Run_cmd: %s\n", jcr->dir_bsock->msg);
/* If we do not need the FD, we are doing a migrate, copy, or virtual
* backup.
*/
if (jcr->no_client_used()) {
do_mac(jcr);
return false;
}
jcr->sendJobStatus(JS_WaitFD); /* wait for FD to connect */
gettimeofday(&tv, &tz);
timeout.tv_nsec = tv.tv_usec * 1000;
timeout.tv_sec = tv.tv_sec + me->client_wait;
Dmsg3(50, "%s waiting %d sec for FD to contact SD key=%s\n",
jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key);
Dmsg2(800, "Wait FD for jid=%d %p\n", jcr->JobId, jcr);
/*
* Wait for the File daemon to contact us to start the Job,
* when he does, we will be released, unless the 30 minutes
* expires.
*/
P(mutex);
while ( !jcr->authenticated && !job_canceled(jcr) ) {
errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) {
break;
}
Dmsg1(800, "=== Auth cond errstat=%d\n", errstat);
}
Dmsg3(50, "Auth=%d canceled=%d errstat=%d\n", jcr->authenticated,
job_canceled(jcr), errstat);
V(mutex);
Dmsg2(800, "Auth fail or cancel for jid=%d %p\n", jcr->JobId, jcr);
memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
if (jcr->authenticated && !job_canceled(jcr)) {
Dmsg2(800, "Running jid=%d %p\n", jcr->JobId, jcr);
run_job(jcr); /* Run the job */
}
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
return false;
}
/*
* completion
*
* Description:
* Simulate a job running to completion
* Inputs:
* now - current time before job runs
* Outputs:
* none
* Returns:
* completion returns the time at which the job completes
* Side Effects:
* The current job is removed from the ready queue and placed
* in the wait queue in order of next release time.
*/
double completion(double now)
{
task_t *cur; /* pointer to current task */
double exec_left; /* amount of time left before job completes */
/* simulate job running to completion */
exec_left = (ready->cur_exec - ready->usage);
run_job(ready, ready->job, now, now + exec_left/freq, freq);
now += exec_left/freq;
/* remove job from ready queue and insert in wait queue */
(ready->job)++;
cur = dequeue(&ready);
cur->last_rel += cur->period;
cur->next_evt = cur->last_rel;
enqueue(&wait, cur);
return now;
}
static int perform_test(inv_test_param_t *param)
{
pj_str_t uri;
pjsip_dialog *dlg;
pjmedia_sdp_session *sdp;
pjsip_tx_data *tdata;
pj_status_t status;
PJ_LOG(3,(THIS_FILE, " %s", param->title));
pj_bzero(&inv_test, sizeof(inv_test));
pj_memcpy(&inv_test.param, param, sizeof(*param));
job_cnt = 0;
uri = pj_str(CONTACT);
/*
* Create UAC
*/
status = pjsip_dlg_create_uac(pjsip_ua_instance(),
&uri, &uri, &uri, &uri, &dlg);
PJ_ASSERT_RETURN(status==PJ_SUCCESS, -10);
if (inv_test.param.oa[0] == OFFERER_UAC)
sdp = create_sdp(dlg->pool, oa_sdp[0].offer);
else
sdp = NULL;
status = pjsip_inv_create_uac(dlg, sdp, inv_test.param.inv_option, &inv_test.uac);
PJ_ASSERT_RETURN(status==PJ_SUCCESS, -20);
TRACE_((THIS_FILE, " Sending INVITE %s offer", (sdp ? "with" : "without")));
/*
* Make call!
*/
status = pjsip_inv_invite(inv_test.uac, &tdata);
PJ_ASSERT_RETURN(status==PJ_SUCCESS, -30);
status = pjsip_inv_send_msg(inv_test.uac, tdata);
PJ_ASSERT_RETURN(status==PJ_SUCCESS, -30);
/*
* Wait until test completes
*/
while (!inv_test.complete) {
pj_time_val delay = {0, 20};
pjsip_endpt_handle_events(endpt, &delay);
while (job_cnt) {
job_t j;
j = jobs[0];
pj_array_erase(jobs, sizeof(jobs[0]), job_cnt, 0);
--job_cnt;
run_job(&j);
}
}
flush_events(100);
/*
* Hangup
*/
TRACE_((THIS_FILE, " Disconnecting call"));
status = pjsip_inv_end_session(inv_test.uas, PJSIP_SC_DECLINE, 0, &tdata);
pj_assert(status == PJ_SUCCESS);
status = pjsip_inv_send_msg(inv_test.uas, tdata);
pj_assert(status == PJ_SUCCESS);
flush_events(500);
return 0;
}
int main(int argc, char **argv)
{
int i;
struct sigaction sa, osa;
FILE *pf;
int r;
prog_name= strrchr(argv[0], '/');
if (prog_name == nil) prog_name= argv[0]; else prog_name++;
i= 1;
while (i < argc && argv[i][0] == '-') {
char *opt= argv[i++] + 1;
if (opt[0] == '-' && opt[1] == 0) break; /* -- */
while (*opt != 0) switch (*opt++) {
case 'd':
if (*opt == 0) {
debug= 1;
} else {
debug= strtoul(opt, &opt, 10);
if (*opt != 0) usage();
}
break;
default:
usage();
}
}
if (i != argc) usage();
selectlog(SYSLOG);
openlog(prog_name, LOG_PID, LOG_DAEMON);
setlogmask(LOG_UPTO(LOG_INFO));
/* Save process id. */
if ((pf= fopen(PIDFILE, "w")) == NULL) {
fprintf(stderr, "%s: %s\n", PIDFILE, strerror(errno));
exit(1);
}
fprintf(pf, "%d\n", getpid());
if (ferror(pf) || fclose(pf) == EOF) {
fprintf(stderr, "%s: %s\n", PIDFILE, strerror(errno));
exit(1);
}
sigemptyset(&sa.sa_mask);
sa.sa_flags= 0;
sa.sa_handler= handler;
/* Hangup: Reload crontab files. */
sigaction(SIGHUP, &sa, nil);
/* User signal 1 & 2: Raise or reset debug level. */
sigaction(SIGUSR1, &sa, nil);
sigaction(SIGUSR2, &sa, nil);
/* Interrupt and Terminate: Cleanup and exit. */
if (sigaction(SIGINT, nil, &osa) == 0 && osa.sa_handler != SIG_IGN) {
sigaction(SIGINT, &sa, nil);
}
if (sigaction(SIGTERM, nil, &osa) == 0 && osa.sa_handler != SIG_IGN) {
sigaction(SIGTERM, &sa, nil);
}
/* Alarm: Wake up and run a job. */
sigaction(SIGALRM, &sa, nil);
/* Initialize current time and time next to do something. */
time(&now);
next= NEVER;
/* Table load required first time. */
need_reload= 1;
do {
if (need_reload) {
need_reload= 0;
load_crontabs();
busy= 1;
}
/* Run jobs whose time has come. */
if (next <= now) {
cronjob_t *job;
if ((job= tab_nextjob()) != nil) run_job(job);
busy= 1;
}
if (busy) {
/* Did a job finish? */
r= waitpid(-1, nil, WNOHANG);
busy= 0;
} else {
/* Sleep until the next job must be started. */
if (next == NEVER) {
alarm(0);
} else {
#if __minix_vmd
struct timeval tvnext;
tvnext.tv_sec= next;
tvnext.tv_usec= 0;
sysutime(UTIME_SETALARM, &tvnext);
#else
alarm((next - now) > INT_MAX
? INT_MAX : (next - now));
#endif
}
if (debug >= 1) fprintf(stderr, "%s: sleep until %s",
prog_name, ctime(&next));
closelog(); /* Don't keep resources open. */
/* Wait for a job to exit or a timeout. */
r= waitpid(-1, nil, 0);
if (r == -1 && errno == ECHILD) pause();
alarm(0);
time(&now);
}
if (r > 0) {
/* A job has finished, reschedule it. */
if (debug >= 1) fprintf(stderr, "pid %d has exited\n",
r);
tab_reap_job((pid_t) r);
busy= 1;
}
} while (!need_quit);
/* Remove the pid file to signal that cron is gone. */
unlink(PIDFILE);
return 0;
}
int main (int argc, char *argv[])
{
int ch;
JCR *jcr;
cat_op mode;
bool no_signals = false;
bool test_config = false;
char *uid = NULL;
char *gid = NULL;
start_heap = sbrk(0);
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
my_name_is(argc, argv, "bareos-dir");
init_msg(NULL, NULL); /* initialize message handler */
init_reload();
daemon_start_time = time(NULL);
console_command = run_console_command;
while ((ch = getopt(argc, argv, "c:d:fg:mr:stu:v?")) != -1) {
switch (ch) {
case 'c': /* specify config file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'd': /* set debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
Dmsg1(10, "Debug level = %d\n", debug_level);
break;
case 'f': /* run in foreground */
background = false;
break;
case 'g': /* set group id */
gid = optarg;
break;
case 'm': /* print kaboom output */
prt_kaboom = true;
break;
case 'r': /* run job */
if (runjob != NULL) {
free(runjob);
}
if (optarg) {
runjob = bstrdup(optarg);
}
break;
case 's': /* turn off signals */
no_signals = true;
break;
case 't': /* test config */
test_config = true;
break;
case 'u': /* set uid */
uid = optarg;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (!no_signals) {
init_signals(terminate_dird);
}
if (argc) {
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(*argv);
argc--;
argv++;
}
if (argc) {
usage();
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
/*
* See if we want to drop privs.
*/
if (geteuid() == 0) {
drop(uid, gid, false); /* reduce privileges if requested */
}
my_config = new_config_parser();
parse_dir_config(my_config, configfile, M_ERROR_TERM);
if (init_crypto() != 0) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
goto bail_out;
}
if (!check_resources()) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
goto bail_out;
}
if (!test_config) { /* we don't need to do this block in test mode */
if (background) {
daemon_start();
init_stack_dump(); /* grab new pid */
}
/* Create pid must come after we are a daemon -- so we have our final pid */
create_pid_file(me->pid_directory, "bareos-dir",
get_first_port_host_order(me->DIRaddrs));
read_state_file(me->working_directory, "bareos-dir",
get_first_port_host_order(me->DIRaddrs));
}
set_jcr_in_tsd(INVALID_JCR);
set_thread_concurrency(me->MaxConcurrentJobs * 2 +
4 /* UA */ + 5 /* sched+watchdog+jobsvr+misc */);
lmgr_init_thread(); /* initialize the lockmanager stack */
load_dir_plugins(me->plugin_directory, me->plugin_names);
/*
* If we are in testing mode, we don't try to fix the catalog
*/
mode = (test_config) ? CHECK_CONNECTION : UPDATE_AND_FIX;
if (!check_catalog(mode)) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
goto bail_out;
}
if (test_config) {
terminate_dird(0);
}
if (!initialize_sql_pooling()) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
goto bail_out;
}
my_name_is(0, NULL, me->name()); /* set user defined name */
cleanup_old_files();
p_db_log_insert = (db_log_insert_func)dir_db_log_insert;
#if !defined(HAVE_WIN32)
signal(SIGHUP, reload_config);
#endif
init_console_msg(working_directory);
Dmsg0(200, "Start UA server\n");
start_UA_server(me->DIRaddrs);
start_watchdog(); /* start network watchdog thread */
if (me->jcr_watchdog_time) {
init_jcr_subsystem(me->jcr_watchdog_time); /* start JCR watchdogs etc. */
}
init_job_server(me->MaxConcurrentJobs);
dbg_jcr_add_hook(db_debug_print); /* used to debug B_DB connexion after fatal signal */
// init_device_resources();
Dmsg0(200, "wait for next job\n");
/* Main loop -- call scheduler to get next job to run */
while ( (jcr = wait_for_next_job(runjob)) ) {
run_job(jcr); /* run job */
free_jcr(jcr); /* release jcr */
set_jcr_in_tsd(INVALID_JCR);
if (runjob) { /* command line, run a single job? */
break; /* yes, terminate */
}
}
terminate_dird(0);
bail_out:
return 0;
}
static void
advance_job(td_job_queue *queue, td_node *node, int job_id)
{
td_jobstate state;
while ((state = node->job.state) < TD_JOB_COMPLETED)
{
switch (state)
{
case TD_JOB_INITIAL:
if (node->job.block_count > 0)
{
/* enqueue any blocking jobs and transition to the blocked state */
int i, count, bc = 0;
td_node **deps = node->deps;
for (i = 0, count = node->dep_count; i < count; ++i)
{
td_node *dep = deps[i];
if (!is_completed(dep))
{
++bc;
if (!is_queued(dep) && dep->job.state < TD_JOB_BLOCKED)
enqueue(queue, dep);
}
}
assert(bc == node->job.block_count);
transition_job(queue, node, TD_JOB_BLOCKED);
pthread_cond_broadcast(&queue->work_avail);
return;
}
else
{
/* nothing is blocking this job, so scan implicit deps immediately */
transition_job(queue, node, TD_JOB_SCANNING);
}
break;
case TD_JOB_BLOCKED:
assert(0 == node->job.block_count);
if (0 == node->job.failed_deps)
transition_job(queue, node, TD_JOB_SCANNING);
else
transition_job(queue, node, TD_JOB_FAILED);
break;
case TD_JOB_SCANNING:
if (0 == scan_implicit_deps(queue, node))
{
update_input_signature(queue, node);
if (is_up_to_date(queue, node))
transition_job(queue, node, TD_JOB_UPTODATE);
else
transition_job(queue, node, TD_JOB_RUNNING);
}
else
{
/* implicit dependency scanning failed */
transition_job(queue, node, TD_JOB_FAILED);
}
break;
case TD_JOB_RUNNING:
if (0 != run_job(queue, node, job_id))
transition_job(queue, node, TD_JOB_FAILED);
else
transition_job(queue, node, TD_JOB_COMPLETED);
break;
default:
assert(0);
td_croak("can't get here");
break;
}
}
if (is_completed(node))
{
int qcount = 0;
td_job_chain *chain = node->job.pending_jobs;
if (td_debug_check(queue->engine, TD_DEBUG_QUEUE))
printf("%s completed - enqueing blocked jobs\n", node->annotation);
/* unblock all jobs that are waiting for this job and enqueue them */
while (chain)
{
td_node *n = chain->node;
if (is_failed(node))
n->job.failed_deps++;
/* nodes blocked on this node can't be completed yet */
assert(!is_completed(n));
if (0 == --n->job.block_count)
{
if (!is_queued(n))
enqueue(queue, n);
++qcount;
}
chain = chain->next;
}
if (1 < qcount)
pthread_cond_broadcast(&queue->work_avail);
else if (1 == qcount)
pthread_cond_signal(&queue->work_avail);
}
}
bool do_job_run(JCR *jcr)
{
struct timeval tv;
struct timezone tz;
struct timespec timeout;
int errstat = 0;
jcr->sendJobStatus(JS_WaitFD); /* wait for FD to connect */
gettimeofday(&tv, &tz);
timeout.tv_nsec = tv.tv_usec * 1000;
timeout.tv_sec = tv.tv_sec + me->client_wait;
Dmsg3(50, "%s waiting %d sec for FD to contact SD key=%s\n",
jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key);
Dmsg2(800, "Wait FD for jid=%d %p\n", jcr->JobId, jcr);
/*
* Wait for the File daemon to contact us to start the Job,
* when he does, we will be released, unless the 30 minutes
* expires.
*/
P(mutex);
while (!jcr->authenticated && !job_canceled(jcr)) {
errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) {
break;
}
Dmsg1(800, "=== Auth cond errstat=%d\n", errstat);
}
Dmsg3(50, "Auth=%d canceled=%d errstat=%d\n", jcr->authenticated,
job_canceled(jcr), errstat);
V(mutex);
Dmsg2(800, "Auth fail or cancel for jid=%d %p\n", jcr->JobId, jcr);
memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (jcr->authenticated && !job_canceled(jcr)) {
Dmsg2(800, "Running jid=%d %p\n", jcr->JobId, jcr);
/*
* Wait for the Job to finish. As we want exclusive access to
* things like the connection to the director we suspend this
* thread and let the actual NDMP connection wake us after it
* has performed the backup. E.g. instead of doing a busy wait
* we just hang on a conditional variable.
*/
Dmsg2(800, "Wait for end job jid=%d %p\n", jcr->JobId, jcr);
P(mutex);
pthread_cond_wait(&jcr->job_end_wait, &mutex);
V(mutex);
}
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
/*
* For a NDMP backup we expect the protocol to send us either a nextrun cmd
* or a finish cmd to let us know they are finished.
*/
return true;
default:
/*
* Handle the file daemon session.
*/
if (jcr->authenticated && !job_canceled(jcr)) {
Dmsg2(800, "Running jid=%d %p\n", jcr->JobId, jcr);
run_job(jcr); /* Run the job */
}
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
/*
* After a run cmd of a native backup we are done e.g.
* return false.
*/
return false;
}
}
int main(int argc, char* argv[])
{
char* str, dir[SLSH_MAX_PATH];
char opt_ver[] = "version", opt_comm[] = "command";
char shortopts[] = "c:";
JOB* job = NULL;
struct sigaction chld;
struct option longopts[3];
int opt, is_script = 0;
char doc[] = "SoloSH 1.0 (beta)\nCopyright (C) 2016 Rodrigo Weigert <*****@*****.**>\n"
"This program comes WITHOUT ANY WARRANTY, without even the implied\n"
"warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
"See the GNU General Public License for more details.\n\n"
"This is free software, and you are welcome to redistribute it and/or\n"
"modify it under the terms of the GNU General Public License; either\n"
"version 3 of the License, or (at your option) any later version.\n\n";
longopts[0].name = opt_ver;
longopts[0].has_arg = no_argument;
longopts[0].flag = NULL;
longopts[0].val = 1;
longopts[1].name = opt_comm;
longopts[1].has_arg = required_argument;
longopts[1].flag = NULL;
longopts[1].val = 'c';
memset(longopts+2, 0, sizeof(struct option));
setpgid(0, 0);
memset(&chld, 0, sizeof(struct sigaction));
chld.sa_flags |= SA_SIGINFO;
chld.sa_sigaction = sigchld_handler;
error(sigaction(SIGCHLD, &chld, NULL) < 0, -1);
signal (SIGINT, SIG_IGN);
signal (SIGQUIT, SIG_IGN);
signal (SIGTSTP, SIG_IGN);
signal (SIGTTIN, SIG_IGN);
signal (SIGTTOU, SIG_IGN);
opt = getopt_long(argc, argv, shortopts, longopts, NULL);
if (opt == 'c')
{
job = create_job(optarg);
run_job(job);
job_list(JL_DESTROY);
return 0;
}
if (opt == '?')
return -1;
if (opt == 1)
{
printf("%s", doc);
return 0;
}
if (argc > 2)
{
printf("Too many arguments.\n");
return -1;
}
if (argc == 2)
{
int in = open(argv[1], O_RDONLY);
fatal_error(in < 0, -1);
close(0);
fatal_error(dup(in) < 0, -1);
close(in);
is_script = 1;
}
if (!is_script)
printf("%s", doc);
while (!exit_flag)
{
if (!is_script)
{
char *raux = getcwd(dir, SLSH_MAX_PATH*sizeof(char));
fatal_error (raux == NULL, -1);
printf("@ %s: ", dir);
}
while (str = read_line(), str == NULL)
{
if (feof(stdin))
{
exit_flag = 1;
printf("\n");
break;
}
else if (!is_script)
printf("@ %s: ", dir);
}
if (!exit_flag)
{
job = create_job(str);
run_job(job);
}
free(str);
str = NULL;
}
job_list(JL_DESTROY);
return 0;
}
bool run_cmd(JCR *jcr)
{
struct timeval tv;
struct timezone tz;
struct timespec timeout;
int errstat = 0;
Dsm_check(200);
Dmsg1(200, "Run_cmd: %s\n", jcr->dir_bsock->msg);
/* If we do not need the FD, we are doing a virtual backup. */
if (jcr->no_client_used()) {
do_vbackup(jcr);
return false;
}
jcr->sendJobStatus(JS_WaitFD); /* wait for FD to connect */
Dmsg2(050, "sd_calls_client=%d sd_client=%d\n", jcr->sd_calls_client, jcr->sd_client);
if (jcr->sd_calls_client) {
if (!read_client_hello(jcr)) {
return false;
}
/*
* Authenticate the File daemon
*/
Dmsg0(050, "=== Authenticate FD\n");
if (jcr->authenticated || !authenticate_filed(jcr, jcr->file_bsock, jcr->FDVersion)) {
Dmsg1(050, "Authentication failed Job %s\n", jcr->Job);
Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate File daemon\n"));
} else {
jcr->authenticated = true;
}
} else if (!jcr->sd_client) {
/* We wait to receive connection from Client */
gettimeofday(&tv, &tz);
timeout.tv_nsec = tv.tv_usec * 1000;
timeout.tv_sec = tv.tv_sec + me->client_wait;
Dmsg3(050, "%s waiting %d sec for FD to contact SD key=%s\n",
jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key);
Dmsg3(800, "=== Block Job=%s jid=%d %p\n", jcr->Job, jcr->JobId, jcr);
/*
* Wait for the File daemon to contact us to start the Job,
* when he does, we will be released, unless the 30 minutes
* expires.
*/
P(mutex);
while ( !jcr->authenticated && !job_canceled(jcr) ) {
errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) {
break;
}
Dmsg1(800, "=== Auth cond errstat=%d\n", errstat);
}
Dmsg4(050, "=== Auth=%d jid=%d canceled=%d errstat=%d\n",
jcr->JobId, jcr->authenticated, job_canceled(jcr), errstat);
V(mutex);
Dmsg2(800, "Auth fail or cancel for jid=%d %p\n", jcr->JobId, jcr);
}
memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
if (jcr->authenticated && !job_canceled(jcr)) {
Dmsg2(800, "Running jid=%d %p\n", jcr->JobId, jcr);
run_job(jcr); /* Run the job */
}
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
return false;
}
bool run_cmd(JCR *jcr)
{
struct timeval tv;
struct timezone tz;
struct timespec timeout;
int errstat = 0;
BSOCK *cl;
int fd_version = 0;
int sd_version = 0;
char job_name[500];
int i;
int stat;
Dsm_check(200);
Dmsg1(200, "Run_cmd: %s\n", jcr->dir_bsock->msg);
/* If we do not need the FD, we are doing a virtual backup. */
if (jcr->no_client_used()) {
do_vbackup(jcr);
return false;
}
jcr->sendJobStatus(JS_WaitFD); /* wait for FD to connect */
Dmsg2(050, "sd_calls_client=%d sd_client=%d\n", jcr->sd_calls_client, jcr->sd_client);
if (jcr->sd_calls_client) {
/* We connected to Client, so finish work */
cl = jcr->file_bsock;
if (!cl) {
Jmsg0(jcr, M_FATAL, 0, _("Client socket not open. Could not connect to Client.\n"));
Dmsg0(050, "Client socket not open. Could not connect to Client.\n");
return false;
}
/* Get response to Hello command sent earlier */
Dmsg0(050, "Read Hello command from Client\n");
for (i=0; i<60; i++) {
stat = cl->recv();
if (stat <= 0) {
bmicrosleep(1, 0);
} else {
break;
}
}
if (stat <= 0) {
berrno be;
Jmsg1(jcr, M_FATAL, 0, _("Recv request to Client failed. ERR=%s\n"),
be.bstrerror());
Dmsg1(050, _("Recv request to Client failed. ERR=%s\n"), be.bstrerror());
return false;
}
Dmsg1(050, "Got from FD: %s\n", cl->msg);
if (sscanf(cl->msg, "Hello Bacula SD: Start Job %127s %d %d", job_name, &fd_version, &sd_version) != 3) {
Jmsg1(jcr, M_FATAL, 0, _("Bad Hello from Client: %s.\n"), cl->msg);
Dmsg1(050, _("Bad Hello from Client: %s.\n"), cl->msg);
return false;
}
unbash_spaces(job_name);
jcr->FDVersion = fd_version;
jcr->SDVersion = sd_version;
Dmsg1(050, "FDVersion=%d\n", fd_version);
/*
* Authenticate the File daemon
*/
Dmsg0(050, "=== Authenticate FD\n");
if (jcr->authenticated || !authenticate_filed(jcr)) {
Dmsg1(050, "Authentication failed Job %s\n", jcr->Job);
Jmsg(jcr, M_FATAL, 0, _("Unable to authenticate File daemon\n"));
} else {
jcr->authenticated = true;
}
} else if (!jcr->sd_client) {
/* We wait to receive connection from Client */
gettimeofday(&tv, &tz);
timeout.tv_nsec = tv.tv_usec * 1000;
timeout.tv_sec = tv.tv_sec + me->client_wait;
Dmsg3(050, "%s waiting %d sec for FD to contact SD key=%s\n",
jcr->Job, (int)(timeout.tv_sec-time(NULL)), jcr->sd_auth_key);
Dmsg3(800, "=== Block Job=%s jid=%d %p\n", jcr->Job, jcr->JobId, jcr);
/*
* Wait for the File daemon to contact us to start the Job,
* when he does, we will be released, unless the 30 minutes
* expires.
*/
P(mutex);
while ( !jcr->authenticated && !job_canceled(jcr) ) {
errstat = pthread_cond_timedwait(&jcr->job_start_wait, &mutex, &timeout);
if (errstat == ETIMEDOUT || errstat == EINVAL || errstat == EPERM) {
break;
}
Dmsg1(800, "=== Auth cond errstat=%d\n", errstat);
}
Dmsg4(050, "=== Auth=%d jid=%d canceled=%d errstat=%d\n",
jcr->JobId, jcr->authenticated, job_canceled(jcr), errstat);
V(mutex);
Dmsg2(800, "Auth fail or cancel for jid=%d %p\n", jcr->JobId, jcr);
}
memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
if (jcr->authenticated && !job_canceled(jcr)) {
Dmsg2(800, "Running jid=%d %p\n", jcr->JobId, jcr);
run_job(jcr); /* Run the job */
}
Dmsg2(800, "Done jid=%d %p\n", jcr->JobId, jcr);
return false;
}
