Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Bacula® is a registered trademark of John Walker.
+ Bacula® is a registered trademark of Kern Sibbald.
The licensor of Bacula is the Free Software Foundation Europe
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
* types. Note, these should be unique for each
* daemon though not a requirement.
*/
-int r_first = R_FIRST;
-int r_last = R_LAST;
+int32_t r_first = R_FIRST;
+int32_t r_last = R_LAST;
static RES *sres_head[R_LAST - R_FIRST + 1];
RES **res_head = sres_head;
*/
#if defined(_MSC_VER)
extern "C" { // work around visual compiler mangling variables
- URES res_all;
+ URES res_all;
}
#else
URES res_all;
#endif
-int res_all_size = sizeof(res_all);
+int32_t res_all_size = sizeof(res_all);
/* Definition of records permitted within each
{"scriptsdirectory", store_dir, ITEM(res_dir.scripts_directory), 0, 0, 0},
{"piddirectory",store_dir, ITEM(res_dir.pid_directory), 0, ITEM_REQUIRED, 0},
{"subsysdirectory", store_dir, ITEM(res_dir.subsys_directory), 0, 0, 0},
- {"maximumconcurrentjobs", store_pint, ITEM(res_dir.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
+ {"maximumconcurrentjobs", store_pint32, ITEM(res_dir.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
{"password", store_password, ITEM(res_dir.password), 0, ITEM_REQUIRED, 0},
- {"fdconnecttimeout", store_time,ITEM(res_dir.FDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30},
- {"sdconnecttimeout", store_time,ITEM(res_dir.SDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30},
+ {"fdconnecttimeout", store_time,ITEM(res_dir.FDConnectTimeout), 0, ITEM_DEFAULT, 3 * 60},
+ {"sdconnecttimeout", store_time,ITEM(res_dir.SDConnectTimeout), 0, ITEM_DEFAULT, 30 * 60},
{"heartbeatinterval", store_time, ITEM(res_dir.heartbeat_interval), 0, ITEM_DEFAULT, 0},
{"tlsauthenticate", store_bool, ITEM(res_dir.tls_authenticate), 0, 0, 0},
{"tlsenable", store_bool, ITEM(res_dir.tls_enable), 0, 0, 0},
{"tlskey", store_dir, ITEM(res_dir.tls_keyfile), 0, 0, 0},
{"tlsdhfile", store_dir, ITEM(res_dir.tls_dhfile), 0, 0, 0},
{"tlsallowedcn", store_alist_str, ITEM(res_dir.tls_allowed_cns), 0, 0, 0},
+ {"statisticsretention", store_time, ITEM(res_dir.stats_retention), 0, ITEM_DEFAULT, 60*60*24*31*12*5},
+ {"verid", store_str, ITEM(res_dir.verid), 0, 0, 0},
{NULL, NULL, {0}, 0, 0, 0}
};
{"filesetacl", store_acl, ITEM(res_con.ACL_lists), FileSet_ACL, 0, 0},
{"catalogacl", store_acl, ITEM(res_con.ACL_lists), Catalog_ACL, 0, 0},
{"whereacl", store_acl, ITEM(res_con.ACL_lists), Where_ACL, 0, 0},
+ {"pluginoptionsacl", store_acl, ITEM(res_con.ACL_lists), PluginOptions_ACL, 0, 0},
{"tlsauthenticate", store_bool, ITEM(res_con.tls_authenticate), 0, 0, 0},
{"tlsenable", store_bool, ITEM(res_con.tls_enable), 0, 0, 0},
{"tlsrequire", store_bool, ITEM(res_con.tls_require), 0, 0, 0},
{"description", store_str, ITEM(res_client.hdr.desc), 0, 0, 0},
{"address", store_str, ITEM(res_client.address), 0, ITEM_REQUIRED, 0},
{"fdaddress", store_str, ITEM(res_client.address), 0, 0, 0},
- {"fdport", store_pint, ITEM(res_client.FDport), 0, ITEM_DEFAULT, 9102},
+ {"fdport", store_pint32, ITEM(res_client.FDport), 0, ITEM_DEFAULT, 9102},
{"password", store_password, ITEM(res_client.password), 0, ITEM_REQUIRED, 0},
- {"fdpassword", store_password, ITEM(res_client.password), 0, 0, 0},
+ {"fdpassword", store_password, ITEM(res_client.password), 0, 0, 0},
{"catalog", store_res, ITEM(res_client.catalog), R_CATALOG, ITEM_REQUIRED, 0},
{"fileretention", store_time, ITEM(res_client.FileRetention), 0, ITEM_DEFAULT, 60*60*24*60},
{"jobretention", store_time, ITEM(res_client.JobRetention), 0, ITEM_DEFAULT, 60*60*24*180},
{"heartbeatinterval", store_time, ITEM(res_client.heartbeat_interval), 0, ITEM_DEFAULT, 0},
{"autoprune", store_bool, ITEM(res_client.AutoPrune), 0, ITEM_DEFAULT, true},
- {"maximumconcurrentjobs", store_pint, ITEM(res_client.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
+ {"maximumconcurrentjobs", store_pint32, ITEM(res_client.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
{"tlsauthenticate", store_bool, ITEM(res_client.tls_authenticate), 0, 0, 0},
{"tlsenable", store_bool, ITEM(res_client.tls_enable), 0, 0, 0},
{"tlsrequire", store_bool, ITEM(res_client.tls_require), 0, 0, 0},
static RES_ITEM store_items[] = {
{"name", store_name, ITEM(res_store.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_store.hdr.desc), 0, 0, 0},
- {"sdport", store_pint, ITEM(res_store.SDport), 0, ITEM_DEFAULT, 9103},
+ {"sdport", store_pint32, ITEM(res_store.SDport), 0, ITEM_DEFAULT, 9103},
{"address", store_str, ITEM(res_store.address), 0, ITEM_REQUIRED, 0},
{"sdaddress", store_str, ITEM(res_store.address), 0, 0, 0},
{"password", store_password, ITEM(res_store.password), 0, ITEM_REQUIRED, 0},
{"autochanger", store_bool, ITEM(res_store.autochanger), 0, ITEM_DEFAULT, 0},
{"enabled", store_bool, ITEM(res_store.enabled), 0, ITEM_DEFAULT, true},
{"heartbeatinterval", store_time, ITEM(res_store.heartbeat_interval), 0, ITEM_DEFAULT, 0},
- {"maximumconcurrentjobs", store_pint, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
- {"sddport", store_pint, ITEM(res_store.SDDport), 0, 0, 0}, /* deprecated */
+ {"maximumconcurrentjobs", store_pint32, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
+ {"sddport", store_pint32, ITEM(res_store.SDDport), 0, 0, 0}, /* deprecated */
{"tlsauthenticate", store_bool, ITEM(res_store.tls_authenticate), 0, 0, 0},
{"tlsenable", store_bool, ITEM(res_store.tls_enable), 0, 0, 0},
{"tlsrequire", store_bool, ITEM(res_store.tls_require), 0, 0, 0},
{"description", store_str, ITEM(res_cat.hdr.desc), 0, 0, 0},
{"address", store_str, ITEM(res_cat.db_address), 0, 0, 0},
{"dbaddress", store_str, ITEM(res_cat.db_address), 0, 0, 0},
- {"dbport", store_pint, ITEM(res_cat.db_port), 0, 0, 0},
+ {"dbport", store_pint32, ITEM(res_cat.db_port), 0, 0, 0},
/* keep this password as store_str for the moment */
{"password", store_str, ITEM(res_cat.db_password), 0, 0, 0},
{"dbpassword", store_str, ITEM(res_cat.db_password), 0, 0, 0},
+ {"dbuser", store_str, ITEM(res_cat.db_user), 0, 0, 0},
{"user", store_str, ITEM(res_cat.db_user), 0, 0, 0},
{"dbname", store_str, ITEM(res_cat.db_name), 0, ITEM_REQUIRED, 0},
{"dbdriver", store_str, ITEM(res_cat.db_driver), 0, 0, 0},
{"run", store_alist_str, ITEM(res_job.run_cmds), 0, 0, 0},
/* Root of where to restore files */
{"where", store_dir, ITEM(res_job.RestoreWhere), 0, 0, 0},
- {"regexwhere", store_str, ITEM(res_job.RegexWhere), 0, 0, 0},
- {"stripprefix", store_str, ITEM(res_job.strip_prefix), 0, 0, 0},
+ {"regexwhere", store_str, ITEM(res_job.RegexWhere), 0, 0, 0},
+ {"stripprefix", store_str, ITEM(res_job.strip_prefix), 0, 0, 0},
{"addprefix", store_str, ITEM(res_job.add_prefix), 0, 0, 0},
{"addsuffix", store_str, ITEM(res_job.add_suffix), 0, 0, 0},
/* Where to find bootstrap during restore */
{"bootstrap",store_dir, ITEM(res_job.RestoreBootstrap), 0, 0, 0},
/* Where to write bootstrap file during backup */
{"writebootstrap",store_dir, ITEM(res_job.WriteBootstrap), 0, 0, 0},
- {"writeverifylist",store_dir, ITEM(res_job.WriteVerifyList), 0, 0, 0},
+ {"writeverifylist",store_dir,ITEM(res_job.WriteVerifyList), 0, 0, 0},
{"replace", store_replace, ITEM(res_job.replace), 0, ITEM_DEFAULT, REPLACE_ALWAYS},
+ {"maxrunschedtime", store_time, ITEM(res_job.MaxRunSchedTime), 0, 0, 0},
{"maxruntime", store_time, ITEM(res_job.MaxRunTime), 0, 0, 0},
- {"fullmaxwaittime", store_time, ITEM(res_job.FullMaxWaitTime), 0, 0, 0},
- {"incrementalmaxwaittime", store_time, ITEM(res_job.IncMaxWaitTime), 0, 0, 0},
- {"differentialmaxwaittime", store_time, ITEM(res_job.DiffMaxWaitTime), 0, 0, 0},
+ /* xxxMaxWaitTime are deprecated */
+ {"fullmaxwaittime", store_time, ITEM(res_job.FullMaxRunTime), 0, 0, 0},
+ {"incrementalmaxwaittime", store_time, ITEM(res_job.IncMaxRunTime), 0, 0, 0},
+ {"differentialmaxwaittime", store_time, ITEM(res_job.DiffMaxRunTime), 0, 0, 0},
+ {"fullmaxruntime", store_time, ITEM(res_job.FullMaxRunTime), 0, 0, 0},
+ {"incrementalmaxruntime", store_time, ITEM(res_job.IncMaxRunTime), 0, 0, 0},
+ {"differentialmaxruntime", store_time, ITEM(res_job.DiffMaxRunTime), 0, 0, 0},
{"maxwaittime", store_time, ITEM(res_job.MaxWaitTime), 0, 0, 0},
{"maxstartdelay",store_time, ITEM(res_job.MaxStartDelay), 0, 0, 0},
- {"maxfullage", store_time, ITEM(res_job.MaxFullAge), 0, 0, 0},
+ {"maxfullinterval", store_time, ITEM(res_job.MaxFullInterval), 0, 0, 0},
+ {"maxdiffinterval", store_time, ITEM(res_job.MaxDiffInterval), 0, 0, 0},
{"jobretention", store_time, ITEM(res_job.JobRetention), 0, 0, 0},
{"prefixlinks", store_bool, ITEM(res_job.PrefixLinks), 0, ITEM_DEFAULT, false},
{"prunejobs", store_bool, ITEM(res_job.PruneJobs), 0, ITEM_DEFAULT, false},
{"prunefiles", store_bool, ITEM(res_job.PruneFiles), 0, ITEM_DEFAULT, false},
{"prunevolumes",store_bool, ITEM(res_job.PruneVolumes), 0, ITEM_DEFAULT, false},
{"enabled", store_bool, ITEM(res_job.enabled), 0, ITEM_DEFAULT, true},
- {"optimizejobscheduling",store_bool, ITEM(res_job.OptimizeJobScheduling), 0, ITEM_DEFAULT, false},
{"spoolattributes",store_bool, ITEM(res_job.SpoolAttributes), 0, ITEM_DEFAULT, false},
{"spooldata", store_bool, ITEM(res_job.spool_data), 0, ITEM_DEFAULT, false},
{"spoolsize", store_size, ITEM(res_job.spool_size), 0, 0, 0},
{"runafterfailedjob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0},
{"clientrunbeforejob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0},
{"clientrunafterjob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0},
- {"maximumconcurrentjobs", store_pint, ITEM(res_job.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
+ {"maximumconcurrentjobs", store_pint32, ITEM(res_job.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1},
{"rescheduleonerror", store_bool, ITEM(res_job.RescheduleOnError), 0, ITEM_DEFAULT, false},
{"rescheduleinterval", store_time, ITEM(res_job.RescheduleInterval), 0, ITEM_DEFAULT, 60 * 30},
- {"rescheduletimes", store_pint, ITEM(res_job.RescheduleTimes), 0, 0, 0},
- {"priority", store_pint, ITEM(res_job.Priority), 0, ITEM_DEFAULT, 10},
- {"writepartafterjob", store_bool, ITEM(res_job.write_part_after_job), 0, ITEM_DEFAULT, true},
- {"selectionpattern", store_str, ITEM(res_job.selection_pattern), 0, 0, 0},
- {"runscript", store_runscript, ITEM(res_job.RunScripts), 0, ITEM_NO_EQUALS, 0},
- {"selectiontype", store_migtype, ITEM(res_job.selection_type), 0, 0, 0},
- {"accurate", store_bool, ITEM(res_job.accurate), 0,0,0},
+ {"rescheduletimes", store_pint32, ITEM(res_job.RescheduleTimes), 0, 0, 0},
+ {"priority", store_pint32, ITEM(res_job.Priority), 0, ITEM_DEFAULT, 10},
+ {"allowmixedpriority", store_bool, ITEM(res_job.allow_mixed_priority), 0, ITEM_DEFAULT, false},
+ {"writepartafterjob", store_bool, ITEM(res_job.write_part_after_job), 0, ITEM_DEFAULT, true},
+ {"selectionpattern", store_str, ITEM(res_job.selection_pattern), 0, 0, 0},
+ {"runscript", store_runscript, ITEM(res_job.RunScripts), 0, ITEM_NO_EQUALS, 0},
+ {"selectiontype", store_migtype, ITEM(res_job.selection_type), 0, 0, 0},
+ {"accurate", store_bool, ITEM(res_job.accurate), 0,0,0},
+ {"allowduplicatejobs", store_bool, ITEM(res_job.AllowDuplicateJobs), 0, ITEM_DEFAULT, false},
+ {"allowhigherduplicates", store_bool, ITEM(res_job.AllowHigherDuplicates), 0, ITEM_DEFAULT, true},
+ {"cancelqueuedduplicates", store_bool, ITEM(res_job.CancelQueuedDuplicates), 0, ITEM_DEFAULT, true},
+ {"cancelrunningduplicates", store_bool, ITEM(res_job.CancelRunningDuplicates), 0, ITEM_DEFAULT, false},
+ {"pluginoptions", store_str, ITEM(res_job.PluginOptions), 0, 0, 0},
{NULL, NULL, {0}, 0, 0, 0}
};
{"purgeoldestvolume", store_bool, ITEM(res_pool.purge_oldest_volume), 0, 0, 0},
{"recycleoldestvolume", store_bool, ITEM(res_pool.recycle_oldest_volume), 0, 0, 0},
{"recyclecurrentvolume", store_bool, ITEM(res_pool.recycle_current_volume), 0, 0, 0},
- {"maximumvolumes", store_pint, ITEM(res_pool.max_volumes), 0, 0, 0},
- {"maximumvolumejobs", store_pint, ITEM(res_pool.MaxVolJobs), 0, 0, 0},
- {"maximumvolumefiles", store_pint, ITEM(res_pool.MaxVolFiles), 0, 0, 0},
+ {"maximumvolumes", store_pint32, ITEM(res_pool.max_volumes), 0, 0, 0},
+ {"maximumvolumejobs", store_pint32, ITEM(res_pool.MaxVolJobs), 0, 0, 0},
+ {"maximumvolumefiles", store_pint32, ITEM(res_pool.MaxVolFiles), 0, 0, 0},
{"maximumvolumebytes", store_size, ITEM(res_pool.MaxVolBytes), 0, 0, 0},
{"catalogfiles", store_bool, ITEM(res_pool.catalog_files), 0, ITEM_DEFAULT, true},
{"volumeretention", store_time, ITEM(res_pool.VolRetention), 0, ITEM_DEFAULT, 60*60*24*365},
static RES_ITEM counter_items[] = {
{"name", store_name, ITEM(res_counter.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_counter.hdr.desc), 0, 0, 0},
- {"minimum", store_int, ITEM(res_counter.MinValue), 0, ITEM_DEFAULT, 0},
- {"maximum", store_pint, ITEM(res_counter.MaxValue), 0, ITEM_DEFAULT, INT32_MAX},
+ {"minimum", store_int32, ITEM(res_counter.MinValue), 0, ITEM_DEFAULT, 0},
+ {"maximum", store_pint32, ITEM(res_counter.MaxValue), 0, ITEM_DEFAULT, INT32_MAX},
{"wrapcounter", store_res, ITEM(res_counter.WrapCounter), R_COUNTER, 0, 0},
{"catalog", store_res, ITEM(res_counter.Catalog), R_CATALOG, 0, 0},
{NULL, NULL, {0}, 0, 0, 0}
{"Incremental", L_INCREMENTAL, JT_BACKUP},
{"Differential", L_DIFFERENTIAL, JT_BACKUP},
{"Since", L_SINCE, JT_BACKUP},
+ {"VirtualFull", L_VIRTUAL_FULL, JT_BACKUP},
{"Catalog", L_VERIFY_CATALOG, JT_VERIFY},
{"InitCatalog", L_VERIFY_INIT, JT_VERIFY},
{"VolumeToCatalog", L_VERIFY_VOLUME_TO_CATALOG, JT_VERIFY},
{"verify", JT_VERIFY},
{"restore", JT_RESTORE},
{"migrate", JT_MIGRATE},
+ {"copy", JT_COPY},
{NULL, 0}
};
{"oldestvolume", MT_OLDEST_VOL},
{"pooloccupancy", MT_POOL_OCCUPANCY},
{"pooltime", MT_POOL_TIME},
+ {"pooluncopiedjobs", MT_POOL_UNCOPIED_JOBS},
{"client", MT_CLIENT},
{"volume", MT_VOLUME},
{"job", MT_JOB},
{NULL, 0}
};
+char *CAT::display(POOLMEM *dst) {
+ Mmsg(dst,"catalog=%s\ndb_name=%s\ndb_driver=%s\ndb_user=%s\n"
+ "db_password=%s\ndb_address=%s\ndb_port=%i\n"
+ "db_socket=%s\n",
+ name(), NPRTB(db_name),
+ NPRTB(db_driver), NPRTB(db_user), NPRTB(db_password),
+ NPRTB(db_address), db_port, NPRTB(db_socket));
+ return dst;
+}
+
const char *level_to_str(int level)
{
int i;
bsnprintf(level_no, sizeof(level_no), "%c (%d)", level, level); /* default if not found */
for (i=0; joblevels[i].level_name; i++) {
- if (level == joblevels[i].level) {
+ if (level == (int)joblevels[i].level) {
str = joblevels[i].level_name;
break;
}
if (res->res_job.JobType == JT_BACKUP) {
sendit(sock, _(" Accurate=%d\n"), res->res_job.accurate);
}
- if (res->res_job.JobType == JT_MIGRATE) {
+ if (res->res_job.JobType == JT_MIGRATE || res->res_job.JobType == JT_COPY) {
sendit(sock, _(" SelectionType=%d\n"), res->res_job.selection_type);
}
if (res->res_job.client) {
if (res->res_job.WriteBootstrap) {
sendit(sock, _(" --> WriteBootstrap=%s\n"), NPRT(res->res_job.WriteBootstrap));
}
+ if (res->res_job.PluginOptions) {
+ sendit(sock, _(" --> PluginOptions=%s\n"), NPRT(res->res_job.PluginOptions));
+ }
+ if (res->res_job.MaxRunTime) {
+ sendit(sock, _(" --> MaxRunTime=%u\n"), res->res_job.MaxRunTime);
+ }
+ if (res->res_job.MaxWaitTime) {
+ sendit(sock, _(" --> MaxWaitTime=%u\n"), res->res_job.MaxWaitTime);
+ }
+ if (res->res_job.MaxStartDelay) {
+ sendit(sock, _(" --> MaxStartDelay=%u\n"), res->res_job.MaxStartDelay);
+ }
if (res->res_job.storage) {
STORE *store;
foreach_alist(store, res->res_job.storage) {
if (res->res_dir.tls_allowed_cns) {
delete res->res_dir.tls_allowed_cns;
}
+ if (res->res_dir.verid) {
+ free(res->res_dir.verid);
+ }
break;
case R_DEVICE:
case R_COUNTER:
if (res->res_job.WriteBootstrap) {
free(res->res_job.WriteBootstrap);
}
+ if (res->res_job.PluginOptions) {
+ free(res->res_job.PluginOptions);
+ }
if (res->res_job.selection_pattern) {
free(res->res_job.selection_pattern);
}
}
/*
- * Store JobType (backup, verify, restore)
+ * Store Migration/Copy type
*
*/
void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass)
/* Store the type both pass 1 and pass 2 */
for (i=0; migtypes[i].type_name; i++) {
if (strcasecmp(lc->str, migtypes[i].type_name) == 0) {
- *(int *)(item->value) = migtypes[i].job_type;
+ *(uint32_t *)(item->value) = migtypes[i].job_type;
i = 0;
break;
}
/* Store the type both pass 1 and pass 2 */
for (i=0; jobtypes[i].type_name; i++) {
if (strcasecmp(lc->str, jobtypes[i].type_name) == 0) {
- *(int *)(item->value) = jobtypes[i].job_type;
+ *(uint32_t *)(item->value) = jobtypes[i].job_type;
i = 0;
break;
}
/* Store the level pass 2 so that type is defined */
for (i=0; joblevels[i].level_name; i++) {
if (strcasecmp(lc->str, joblevels[i].level_name) == 0) {
- *(int *)(item->value) = joblevels[i].level;
+ *(uint32_t *)(item->value) = joblevels[i].level;
i = 0;
break;
}
/* Scan Replacement options */
for (i=0; ReplaceOptions[i].name; i++) {
if (strcasecmp(lc->str, ReplaceOptions[i].name) == 0) {
- *(int *)(item->value) = ReplaceOptions[i].token;
+ *(uint32_t *)(item->value) = ReplaceOptions[i].token;
i = 0;
break;
}
lex_get_token(lc, T_NAME);
if (strcasecmp(lc->str, "before") == 0) {
- *(int *)(item->value) = SCRIPT_Before ;
+ *(uint32_t *)(item->value) = SCRIPT_Before ;
} else if (strcasecmp(lc->str, "after") == 0) {
- *(int *)(item->value) = SCRIPT_After;
+ *(uint32_t *)(item->value) = SCRIPT_After;
+ } else if (strcasecmp(lc->str, "aftervss") == 0) {
+ *(uint32_t *)(item->value) = SCRIPT_AfterVSS;
} else if (strcasecmp(lc->str, "always") == 0) {
- *(int *)(item->value) = SCRIPT_Any;
+ *(uint32_t *)(item->value) = SCRIPT_Any;
} else {
- scan_err2(lc, _("Expect %s, got: %s"), "Before, After or Always", lc->str);
+ scan_err2(lc, _("Expect %s, got: %s"), "Before, After, AfterVSS or Always", lc->str);
}
scan_to_eol(lc);
}
}
/*
- * Store a runscript->command as a string
+ * Store a runscript->command as a string and runscript->cmd_type as a pointer
*/
static void store_runscript_cmd(LEX *lc, RES_ITEM *item, int index, int pass)
{
lex_get_token(lc, T_STRING);
if (pass == 2) {
- ((RUNSCRIPT*)item->value)->set_command(lc->str, item->code);
+ Dmsg2(1, "runscript cmd=%s type=%c\n", lc->str, item->code);
+ POOLMEM *c = get_pool_memory(PM_FNAME);
+ /* Each runscript command takes 2 entries in commands list */
+ pm_strcpy(c, lc->str);
+ ((RUNSCRIPT*) item->value)->commands->prepend(c); /* command line */
+ ((RUNSCRIPT*) item->value)->commands->prepend((void *)item->code); /* command type */
}
scan_to_eol(lc);
}
*/
static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass)
{
- int token, i;
+ char *c;
+ int token, i, t;
alist **runscripts = (alist **)(item->value) ;
Dmsg1(200, "store_runscript: begin store_runscript pass=%i\n", pass);
- res_runscript.reset_default(); /* setting on_success, on_failure, fail_on_error */
-
token = lex_get_token(lc, T_SKIP_EOL);
if (token != T_BOB) {
scan_err1(lc, _("Expecting open brace. Got %s"), lc->str);
}
-
+ /* setting on_success, on_failure, fail_on_error */
+ res_runscript.reset_default();
+
+ if (pass == 2) {
+ res_runscript.commands = New(alist(10, not_owned_by_alist));
+ }
+
while ((token = lex_get_token(lc, T_SKIP_EOL)) != T_EOF) {
if (token == T_EOB) {
break;
}
if (pass == 2) {
- if (res_runscript.command == NULL) {
- scan_err2(lc, _("%s item is required in %s resource, but not found.\n"),
- "command", "runscript");
- }
-
/* run on client by default */
if (res_runscript.target == NULL) {
res_runscript.set_target("%c");
}
-
- RUNSCRIPT *script = new_runscript();
- memcpy(script, &res_runscript, sizeof(RUNSCRIPT));
- script->set_job_code_callback(job_code_callback_filesetname);
-
if (*runscripts == NULL) {
- *runscripts = New(alist(10, not_owned_by_alist));
+ *runscripts = New(alist(10, not_owned_by_alist));
}
-
- (*runscripts)->append(script);
- script->debug();
+ /*
+ * commands list contains 2 values per command
+ * - POOLMEM command string (ex: /bin/true)
+ * - int command type (ex: SHELL_CMD)
+ */
+ res_runscript.set_job_code_callback(job_code_callback_filesetname);
+ while ((c=(char*)res_runscript.commands->pop()) != NULL) {
+ t = (long)res_runscript.commands->pop();
+ RUNSCRIPT *script = new_runscript();
+ memcpy(script, &res_runscript, sizeof(RUNSCRIPT));
+ script->command = c;
+ script->cmd_type = t;
+ /* target is taken from res_runscript, each runscript object have
+ * a copy
+ */
+ script->target = NULL;
+ script->set_target(res_runscript.target);
+
+ (*runscripts)->append(script);
+ script->debug();
+ }
+ delete res_runscript.commands;
+ /* setting on_success, on_failure... cleanup target field */
+ res_runscript.reset_default(true);
}
scan_to_eol(lc);
return NULL;
}
}
+
+bool parse_dir_config(CONFIG *config, const char *configfile, int exit_code)
+{
+ config->init(configfile, NULL, exit_code, (void *)&res_all, res_all_size,
+ r_first, r_last, resources, res_head);
+ return config->parse_config();
+}