git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/runscript.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2006-2007 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Manipulation routines for RunScript list
  30  *
  31  *  Eric Bollengier, May 2006
  32  *
  33  *  Version $Id$
  34  *
  35  */
  36
  37
  38 #include "bacula.h"
  39 #include "jcr.h"
  40
  41 #include "runscript.h"
  42
  43 RUNSCRIPT *new_runscript()
  44 {
  45    Dmsg0(500, "runscript: creating new RUNSCRIPT object\n");
  46    RUNSCRIPT *cmd = (RUNSCRIPT *)malloc(sizeof(RUNSCRIPT));
  47    memset(cmd, 0, sizeof(RUNSCRIPT));
  48    cmd->reset_default();
  49
  50    return cmd;
  51 }
  52
  53 void RUNSCRIPT::reset_default(bool free_strings)
  54 {
  55    if (free_strings && command) {
  56      free_pool_memory(command);
  57    }
  58    if (free_strings && target) {
  59      free_pool_memory(target);
  60    }
  61
  62    target = NULL;
  63    command = NULL;
  64    on_success = true;
  65    on_failure = false;
  66    fail_on_error = true;
  67    when = SCRIPT_Never;
  68    old_proto = false;        /* TODO: drop this with bacula 1.42 */
  69    job_code_callback = NULL;
  70 }
  71
  72 RUNSCRIPT *copy_runscript(RUNSCRIPT *src)
  73 {
  74    Dmsg0(500, "runscript: creating new RUNSCRIPT object from other\n");
  75
  76    RUNSCRIPT *dst = (RUNSCRIPT *)malloc(sizeof(RUNSCRIPT));
  77    memcpy(dst, src, sizeof(RUNSCRIPT));
  78
  79    dst->command = NULL;
  80    dst->target = NULL;
  81
  82    dst->set_command(src->command);
  83    dst->set_target(src->target);
  84
  85    return dst;
  86 }
  87
  88 void free_runscript(RUNSCRIPT *script)
  89 {
  90    Dmsg0(500, "runscript: freeing RUNSCRIPT object\n");
  91
  92    if (script->command) {
  93       free_pool_memory(script->command);
  94    }
  95    if (script->target) {
  96       free_pool_memory(script->target);
  97    }
  98    free(script);
  99 }
 100
 101 int run_scripts(JCR *jcr, alist *runscripts, const char *label)
 102 {
 103    Dmsg2(200, "runscript: running all RUNSCRIPT object (%s) JobStatus=%c\n", label, jcr->JobStatus);
 104
 105    RUNSCRIPT *script;
 106    bool runit;
 107
 108    int when;
 109
 110    if (strstr(label, NT_("Before"))) {
 111       when = SCRIPT_Before;
 112    } else {
 113       when = SCRIPT_After;
 114    }
 115
 116    if (runscripts == NULL) {
 117       Dmsg0(100, "runscript: WARNING RUNSCRIPTS list is NULL\n");
 118       return 0;
 119    }
 120
 121    foreach_alist(script, runscripts) {
 122       Dmsg2(200, "runscript: try to run %s:%s\n", NPRT(script->target), NPRT(script->command));
 123       runit = false;
 124
 125       if ((script->when & SCRIPT_Before) && (when & SCRIPT_Before)) {
 126          if ((script->on_success
 127             && (jcr->JobStatus == JS_Running || jcr->JobStatus == JS_Created))
 128             || (script->on_failure && job_canceled(jcr))
 129             )
 130          {
 131             Dmsg4(200, "runscript: Run it because SCRIPT_Before (%s,%i,%i,%c)\n",
 132                   script->command, script->on_success, script->on_failure,
 133                   jcr->JobStatus );
 134             runit = true;
 135          }
 136       }
 137
 138       if ((script->when & SCRIPT_After) && (when & SCRIPT_After)) {
 139          if ((script->on_success && (jcr->JobStatus == JS_Terminated))
 140              || (script->on_failure && job_canceled(jcr))
 141             )
 142          {
 143             Dmsg4(200, "runscript: Run it because SCRIPT_After (%s,%i,%i,%c)\n",
 144                   script->command, script->on_success, script->on_failure,
 145                   jcr->JobStatus );
 146             runit = true;
 147          }
 148       }
 149
 150       if (!script->is_local()) {
 151          runit = false;
 152       }
 153
 154       /* we execute it */
 155       if (runit) {
 156          script->run(jcr, label);
 157       }
 158    }
 159    return 1;
 160 }
 161
 162 bool RUNSCRIPT::is_local()
 163 {
 164    if (!target || (strcmp(target, "") == 0)) {
 165       return true;
 166    } else {
 167       return false;
 168    }
 169 }
 170
 171 /* set this->command to cmd */
 172 void RUNSCRIPT::set_command(const POOLMEM *cmd)
 173 {
 174    Dmsg1(500, "runscript: setting command = %s\n", NPRT(cmd));
 175
 176    if (!cmd) {
 177       return;
 178    }
 179
 180    if (!command) {
 181       command = get_pool_memory(PM_FNAME);
 182    }
 183
 184    pm_strcpy(command, cmd);
 185 }
 186
 187 /* set this->target to client_name */
 188 void RUNSCRIPT::set_target(const POOLMEM *client_name)
 189 {
 190    Dmsg1(500, "runscript: setting target = %s\n", NPRT(client_name));
 191
 192    if (!client_name) {
 193       return;
 194    }
 195
 196    if (!target) {
 197       target = get_pool_memory(PM_FNAME);
 198    }
 199
 200    pm_strcpy(target, client_name);
 201 }
 202
 203 bool RUNSCRIPT::run(JCR *jcr, const char *name)
 204 {
 205    Dmsg0(200, "runscript: running a RUNSCRIPT object\n");
 206    POOLMEM *ecmd = get_pool_memory(PM_FNAME);
 207    int status;
 208    BPIPE *bpipe;
 209    char line[MAXSTRING];
 210
 211    ecmd = edit_job_codes(jcr, ecmd, this->command, "", this->job_code_callback);
 212    Dmsg1(100, "runscript: running '%s'...\n", ecmd);
 213    Jmsg(jcr, M_INFO, 0, _("%s: run command \"%s\"\n"), name, ecmd);
 214
 215    bpipe = open_bpipe(ecmd, 0, "r");
 216    free_pool_memory(ecmd);
 217    if (bpipe == NULL) {
 218       berrno be;
 219       Jmsg(jcr, M_ERROR, 0, _("Runscript: %s could not execute. ERR=%s\n"), name,
 220          be.bstrerror());
 221       goto bail_out;
 222    }
 223    while (fgets(line, sizeof(line), bpipe->rfd)) {
 224       int len = strlen(line);
 225       if (len > 0 && line[len-1] == '\n') {
 226          line[len-1] = 0;
 227       }
 228       Jmsg(jcr, M_INFO, 0, _("%s: %s\n"), name, line);
 229    }
 230    status = close_bpipe(bpipe);
 231    if (status != 0) {
 232       berrno be;
 233       Jmsg(jcr, M_ERROR, 0, _("Runscript: %s returned non-zero status=%d. ERR=%s\n"), name,
 234          be.code(status), be.bstrerror(status));
 235       goto bail_out;
 236    }
 237    Dmsg0(100, "runscript OK\n");
 238    return true;
 239
 240 bail_out:
 241    /* cancel running job properly */
 242    if (fail_on_error) {
 243       set_jcr_job_status(jcr, JS_ErrorTerminated);
 244    }
 245    Dmsg1(100, "runscript failed. fail_on_error=%d\n", fail_on_error);
 246    return false;
 247 }
 248
 249 void free_runscripts(alist *runscripts)
 250 {
 251    Dmsg0(500, "runscript: freeing all RUNSCRIPTS object\n");
 252
 253    RUNSCRIPT *elt;
 254    foreach_alist(elt, runscripts) {
 255       free_runscript(elt);
 256    }
 257 }
 258
 259 void RUNSCRIPT::debug()
 260 {
 261    Dmsg0(200, "runscript: debug\n");
 262    Dmsg0(200,  _(" --> RunScript\n"));
 263    Dmsg1(200,  _("  --> Command=%s\n"), NPRT(command));
 264    Dmsg1(200,  _("  --> Target=%s\n"),  NPRT(target));
 265    Dmsg1(200,  _("  --> RunOnSuccess=%u\n"),  on_success);
 266    Dmsg1(200,  _("  --> RunOnFailure=%u\n"),  on_failure);
 267    Dmsg1(200,  _("  --> FailJobOnError=%u\n"),  fail_on_error);
 268    Dmsg1(200,  _("  --> RunWhen=%u\n"),  when);
 269 }
 270
 271 void RUNSCRIPT::set_job_code_callback(job_code_callback_t arg_job_code_callback)
 272
 273 {
 274    this->job_code_callback = arg_job_code_callback;
 275 }