/* return the last timer interval (ms)
* or 0 if something goes wrong
*/
btime_t DEVICE::get_timer_count()
{
btime_t temp = last_timer;
last_timer = get_current_btime();
temp = last_timer - temp; /* get elapsed time */
return (temp>0)?temp:0; /* take care of skewed clock */
}
/*
* 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);
}
/*
* create_volume_label_record
* Serialize label (from dev->VolHdr structure) into device record.
* Assumes that the dev->VolHdr structure is properly
* initialized.
*/
static void create_volume_label_record(DCR *dcr, DEVICE *dev, DEV_RECORD *rec)
{
ser_declare;
struct date_time dt;
JCR *jcr = dcr->jcr;
char buf[100];
/* Serialize the label into the device record. */
rec->data = check_pool_memory_size(rec->data, SER_LENGTH_Volume_Label);
ser_begin(rec->data, SER_LENGTH_Volume_Label);
ser_string(dev->VolHdr.Id);
ser_uint32(dev->VolHdr.VerNum);
if (dev->VolHdr.VerNum >= 11) {
ser_btime(dev->VolHdr.label_btime);
dev->VolHdr.write_btime = get_current_btime();
ser_btime(dev->VolHdr.write_btime);
dev->VolHdr.write_date = 0;
dev->VolHdr.write_time = 0;
} else {
/* OLD WAY DEPRECATED */
ser_float64(dev->VolHdr.label_date);
ser_float64(dev->VolHdr.label_time);
get_current_time(&dt);
dev->VolHdr.write_date = dt.julian_day_number;
dev->VolHdr.write_time = dt.julian_day_fraction;
}
ser_float64(dev->VolHdr.write_date); /* 0 if VerNum >= 11 */
ser_float64(dev->VolHdr.write_time); /* 0 if VerNum >= 11 */
ser_string(dev->VolHdr.VolumeName);
ser_string(dev->VolHdr.PrevVolumeName);
ser_string(dev->VolHdr.PoolName);
ser_string(dev->VolHdr.PoolType);
ser_string(dev->VolHdr.MediaType);
ser_string(dev->VolHdr.HostName);
ser_string(dev->VolHdr.LabelProg);
ser_string(dev->VolHdr.ProgVersion);
ser_string(dev->VolHdr.ProgDate);
ser_end(rec->data, SER_LENGTH_Volume_Label);
bstrncpy(dcr->VolumeName, dev->VolHdr.VolumeName, sizeof(dcr->VolumeName));
rec->data_len = ser_length(rec->data);
rec->FileIndex = dev->VolHdr.LabelType;
rec->VolSessionId = jcr->VolSessionId;
rec->VolSessionTime = jcr->VolSessionTime;
rec->Stream = jcr->NumWriteVolumes;
rec->maskedStream = jcr->NumWriteVolumes;
Dmsg2(150, "Created Vol label rec: FI=%s len=%d\n",
FI_to_ascii(buf, rec->FileIndex), rec->data_len);
}
static void *do_batch(void *jcr)
{
JCR *bjcr = (JCR *)jcr;
char data[1024];
int lineno = 0;
struct ATTR_DBR ar;
memset(&ar, 0, sizeof(ar));
btime_t begin = get_current_btime();
char *datafile = bjcr->where;
FILE *fd = fopen(datafile, "r");
if (!fd) {
Emsg1(M_ERROR_TERM, 0, _("Error opening datafile %s\n"), datafile);
}
while (fgets(data, sizeof(data)-1, fd)) {
strip_trailing_newline(data);
lineno++;
if (verbose && ((lineno % 5000) == 1)) {
printf("\r%i", lineno);
}
fill_attr(&ar, data);
if (!db_create_attributes_record(bjcr, bjcr->db, &ar)) {
Emsg0(M_ERROR_TERM, 0, _("Error while inserting file\n"));
}
}
fclose(fd);
db_write_batch_file_records(bjcr);
btime_t end = get_current_btime();
P(mutex);
char ed1[200], ed2[200];
printf("\rbegin = %s, end = %s\n", edit_int64(begin, ed1),edit_int64(end, ed2));
printf("Insert time = %sms\n", edit_int64((end - begin) / 10000, ed1));
printf("Create %u files at %.2f/s\n", lineno,
(lineno / ((float)((end - begin) / 1000000))));
nb--;
V(mutex);
pthread_exit(NULL);
return NULL;
}
/*
* Create a volume label in memory
*/
void create_volume_label(DEVICE *dev, const char *VolName, const char *PoolName)
{
DEVRES *device = (DEVRES *)dev->device;
Dmsg0(130, "Start create_volume_label()\n");
ASSERT(dev != NULL);
dev->clear_volhdr(); /* clear any old volume info */
if (me->compatible) {
bstrncpy(dev->VolHdr.Id, OldBaculaId, sizeof(dev->VolHdr.Id));
dev->VolHdr.VerNum = OldCompatibleBareosTapeVersion1;
} else {
bstrncpy(dev->VolHdr.Id, BareosId, sizeof(dev->VolHdr.Id));
dev->VolHdr.VerNum = BareosTapeVersion;
}
dev->VolHdr.LabelType = PRE_LABEL; /* Mark tape as unused */
bstrncpy(dev->VolHdr.VolumeName, VolName, sizeof(dev->VolHdr.VolumeName));
bstrncpy(dev->VolHdr.PoolName, PoolName, sizeof(dev->VolHdr.PoolName));
bstrncpy(dev->VolHdr.MediaType, device->media_type, sizeof(dev->VolHdr.MediaType));
bstrncpy(dev->VolHdr.PoolType, "Backup", sizeof(dev->VolHdr.PoolType));
dev->VolHdr.label_btime = get_current_btime();
dev->VolHdr.label_date = 0;
dev->VolHdr.label_time = 0;
if (gethostname(dev->VolHdr.HostName, sizeof(dev->VolHdr.HostName)) != 0) {
dev->VolHdr.HostName[0] = 0;
}
bstrncpy(dev->VolHdr.LabelProg, my_name, sizeof(dev->VolHdr.LabelProg));
sprintf(dev->VolHdr.ProgVersion, "Ver. %s %s", VERSION, BDATE);
sprintf(dev->VolHdr.ProgDate, "Build %s %s", __DATE__, __TIME__);
dev->set_labeled(); /* set has Bareos label */
if (debug_level >= 90) {
dump_volume_label(dev);
}
}
/*
* Get a message
* Call appropriate processing routine
* If it is not a Jmsg or a ReqCat message,
* return it to the caller.
*
* This routine is called to get the next message from
* another daemon. If the message is in canonical message
* format and the type is known, it will be dispatched
* to the appropriate handler. If the message is
* in any other format, it will be returned.
*
* E.g. any message beginning with a digit will be passed
* through to the caller.
* All other messages are expected begin with some identifier
* -- for the moment only the first character is checked, but
* at a later time, the whole identifier (e.g. Jmsg, CatReq, ...)
* could be checked. This is followed by Job=Jobname <user-defined>
* info. The identifier is used to dispatch the message to the right
* place (Job message, catalog request, ...). The Job is used to lookup
* the JCR so that the action is performed on the correct jcr, and
* the rest of the message is up to the user. Note, DevUpd uses
* *System* for the Job name, and hence no JCR is obtained. This
* is a *rare* case where a jcr is not really needed.
*
*/
int bget_dirmsg(BSOCK *bs, bool allow_any_message)
{
int32_t n = BNET_TERMINATE;
char Job[MAX_NAME_LENGTH];
char MsgType[20];
int type;
utime_t mtime; /* message time */
JCR *jcr = bs->jcr();
char *msg;
for ( ; !bs->is_stop() && !bs->is_timed_out(); ) {
n = bs->recv();
Dmsg2(200, "bget_dirmsg %d: %s\n", n, bs->msg);
if (bs->is_stop() || bs->is_timed_out()) {
return n; /* error or terminate */
}
if (n == BNET_SIGNAL) { /* handle signal */
/* BNET_SIGNAL (-1) return from bnet_recv() => network signal */
switch (bs->msglen) {
case BNET_EOD: /* end of data */
return n;
case BNET_EOD_POLL:
bs->fsend(OK_msg);/* send response */
return n; /* end of data */
case BNET_TERMINATE:
bs->set_terminated();
return n;
case BNET_POLL:
bs->fsend(OK_msg); /* send response */
break;
case BNET_HEARTBEAT:
// encode_time(time(NULL), Job);
// Dmsg1(100, "%s got heartbeat.\n", Job);
break;
case BNET_HB_RESPONSE:
break;
case BNET_STATUS:
/* *****FIXME***** Implement more completely */
bs->fsend("Status OK\n");
bs->signal(BNET_EOD);
break;
case BNET_BTIME: /* send BAREOS time */
char ed1[50];
bs->fsend("btime %s\n", edit_uint64(get_current_btime(),ed1));
break;
default:
Jmsg1(jcr, M_WARNING, 0, _("bget_dirmsg: unknown bnet signal %d\n"), bs->msglen);
return n;
}
continue;
}
/*
* Handle normal data
*/
if (n > 0 && B_ISDIGIT(bs->msg[0])) { /* response? */
return n; /* yes, return it */
}
/*
* If we get here, it must be a request. Either
* a message to dispatch, or a catalog request.
* Try to fulfill it.
*/
if (sscanf(bs->msg, "%020s Job=%127s ", MsgType, Job) != 2) {
/*
* If the special flag allow_any_message is given ignore
* the error and just return it as normal data.
*/
if (allow_any_message) {
return n;
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
}
/*
* Skip past "Jmsg Job=nnn"
*/
if (!(msg=find_msg_start(bs->msg))) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
/*
* Here we are expecting a message of the following format:
* Jmsg Job=nnn type=nnn level=nnn Message-string
* Note, level should really be mtime, but that changes
* the protocol.
*/
if (bs->msg[0] == 'J') { /* Job message */
if (sscanf(bs->msg, "Jmsg Job=%127s type=%d level=%lld",
Job, &type, &mtime) != 3) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
Dmsg1(900, "Got msg: %s\n", bs->msg);
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip type=nnn */
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip level=nnn */
if (*msg == ' ') {
msg++; /* skip leading space */
}
Dmsg1(900, "Dispatch msg: %s", msg);
dispatch_message(jcr, type, mtime, msg);
continue;
}
/*
* Here we expact a CatReq message
* CatReq Job=nn Catalog-Request-Message
*/
if (bs->msg[0] == 'C') { /* Catalog request */
Dmsg2(900, "Catalog req jcr 0x%x: %s", jcr, bs->msg);
catalog_request(jcr, bs);
continue;
}
if (bs->msg[0] == 'U') { /* SD sending attributes */
Dmsg2(900, "Catalog upd jcr 0x%x: %s", jcr, bs->msg);
catalog_update(jcr, bs);
continue;
}
if (bs->msg[0] == 'B') { /* SD sending file spool attributes */
Dmsg2(100, "Blast attributes jcr 0x%x: %s", jcr, bs->msg);
char filename[256];
if (sscanf(bs->msg, "BlastAttr Job=%127s File=%255s",
Job, filename) != 2) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
unbash_spaces(filename);
if (despool_attributes_from_file(jcr, filename)) {
bs->fsend("1000 OK BlastAttr\n");
} else {
bs->fsend("1990 ERROR BlastAttr\n");
}
continue;
}
if (bs->msg[0] == 'M') { /* Mount request */
Dmsg1(900, "Mount req: %s", bs->msg);
mount_request(jcr, bs, msg);
continue;
}
if (bs->msg[0] == 'S') { /* Status change */
int JobStatus;
char Job[MAX_NAME_LENGTH];
if (sscanf(bs->msg, Job_status, &Job, &JobStatus) == 2) {
set_jcr_sd_job_status(jcr, JobStatus); /* current status */
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
}
continue;
}
#ifdef needed
/* No JCR for Device Updates! */
if (bs->msg[0] = 'D') { /* Device update */
DEVICE *dev;
POOL_MEM dev_name, changer_name, media_type, volume_name;
int dev_open, dev_append, dev_read, dev_labeled;
int dev_offline, dev_autochanger, dev_autoselect;
int dev_num_writers, dev_max_writers, dev_reserved;
uint64_t dev_read_time, dev_write_time, dev_write_bytes, dev_read_bytes;
uint64_t dev_PoolId;
Dmsg1(100, "<stored: %s", bs->msg);
if (sscanf(bs->msg, Device_update,
&Job, dev_name.c_str(),
&dev_append, &dev_read,
&dev_num_writers, &dev_open,
&dev_labeled, &dev_offline, &dev_reserved,
&dev_max_writers, &dev_autoselect,
&dev_autochanger,
changer_name.c_str(), media_type.c_str(),
volume_name.c_str(),
&dev_read_time, &dev_write_time, &dev_read_bytes,
&dev_write_bytes) != 19) {
Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
} else {
unbash_spaces(dev_name);
dev = (DEVICE *)GetResWithName(R_DEVICE, dev_name.c_str());
if (!dev) {
continue;
}
unbash_spaces(changer_name);
unbash_spaces(media_type);
unbash_spaces(volume_name);
bstrncpy(dev->ChangerName, changer_name.c_str(), sizeof(dev->ChangerName));
bstrncpy(dev->MediaType, media_type.c_str(), sizeof(dev->MediaType));
bstrncpy(dev->VolumeName, volume_name.c_str(), sizeof(dev->VolumeName));
/* Note, these are copied because they are boolean rather than
* integer.
*/
dev->open = dev_open;
dev->append = dev_append;
dev->read = dev_read;
dev->labeled = dev_labeled;
dev->offline = dev_offline;
dev->autoselect = dev_autoselect;
dev->autochanger = dev_autochanger > 0;
dev->num_drives = dev_autochanger; /* does double duty */
dev->PoolId = dev_PoolId;
dev->num_writers = dev_num_writers;
dev->max_writers = dev_max_writers;
dev->reserved = dev_reserved;
dev->found = true;
dev->DevReadTime = dev_read_time; /* TODO : have to update database */
dev->DevWriteTime = dev_write_time;
dev->DevReadBytes = dev_read_bytes;
dev->DevWriteBytes = dev_write_bytes;
}
continue;
}
#endif
return n;
}
return n;
}
int main (int argc, char *argv[])
{
int ch;
bool disable_batch = false;
char *restore_list=NULL;
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
lmgr_init_thread();
char **files = (char **) malloc (10 * sizeof(char *));
int i;
my_name_is(argc, argv, "bbatch");
init_msg(NULL, NULL);
OSDependentInit();
while ((ch = getopt(argc, argv, "bBh:c:d:D:n:P:Su:vf:w:r:?")) != -1) {
switch (ch) {
case 'r':
restore_list=bstrdup(optarg);
break;
case 'B':
disable_batch = true;
break;
case 'b':
disable_batch = false;
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'D':
db_driver = optarg;
break;
case 'h':
db_host = optarg;
break;
case 'n':
db_name = optarg;
break;
case 'w':
working_directory = optarg;
break;
case 'u':
db_user = optarg;
break;
case 'P':
db_password = optarg;
break;
case 'v':
verbose++;
break;
case 'f':
if (nb < 10 ) {
files[nb++] = optarg;
}
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
Pmsg0(0, _("Wrong number of arguments: \n"));
usage();
}
if (restore_list) {
uint64_t nb_file=0;
btime_t start, end;
/* To use the -r option, the catalog should already contains records */
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, disable_batch)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
start = get_current_btime();
db_get_file_list(NULL, db, restore_list, false, false, list_handler, &nb_file);
end = get_current_btime();
Pmsg3(0, _("Computing file list for jobid=%s files=%lld secs=%d\n"),
restore_list, nb_file, (uint32_t)btime_to_unix(end-start));
free(restore_list);
return 0;
}
if (disable_batch) {
printf("Without new Batch mode\n");
} else {
printf("With new Batch mode\n");
}
i = nb;
while (--i >= 0) {
pthread_t thid;
JCR *bjcr = new_jcr(sizeof(JCR), NULL);
bjcr->bsr = NULL;
bjcr->VolSessionId = 1;
bjcr->VolSessionTime = (uint32_t)time(NULL);
bjcr->NumReadVolumes = 0;
bjcr->NumWriteVolumes = 0;
bjcr->JobId = getpid();
bjcr->setJobType(JT_CONSOLE);
bjcr->setJobLevel(L_FULL);
bjcr->JobStatus = JS_Running;
bjcr->where = bstrdup(files[i]);
bjcr->job_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->job_name, "Dummy.Job.Name");
bjcr->client_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->client_name, "Dummy.Client.Name");
bstrncpy(bjcr->Job, "bbatch", sizeof(bjcr->Job));
bjcr->fileset_name = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_name, "Dummy.fileset.name");
bjcr->fileset_md5 = get_pool_memory(PM_FNAME);
pm_strcpy(bjcr->fileset_md5, "Dummy.fileset.md5");
if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
db_host, 0, NULL, false, false)) == NULL) {
Emsg0(M_ERROR_TERM, 0, _("Could not init Bareos database\n"));
}
if (!db_open_database(NULL, db)) {
Emsg0(M_ERROR_TERM, 0, db_strerror(db));
}
Dmsg0(200, "Database opened\n");
if (verbose) {
Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
}
bjcr->db = db;
pthread_create(&thid, NULL, do_batch, bjcr);
}
while (nb > 0) {
bmicrosleep(1,0);
}
return 0;
}
/*
* Try to limit the bandwidth of a network connection
*/
void BSOCK::control_bwlimit(int bytes)
{
btime_t now, temp;
int64_t usec_sleep;
/*
* If nothing written or read nothing todo.
*/
if (bytes == 0) {
return;
}
/*
* See if this is the first time we enter here.
*/
now = get_current_btime();
if (m_last_tick == 0) {
m_nb_bytes = bytes;
m_last_tick = now;
return;
}
/*
* Calculate the number of microseconds since the last check.
*/
temp = now - m_last_tick;
/*
* Less than 0.1ms since the last call, see the next time
*/
if (temp < 100) {
m_nb_bytes += bytes;
return;
}
/*
* Keep track of how many bytes are written in this timeslice.
*/
m_nb_bytes += bytes;
m_last_tick = now;
if (debug_level >= 400) {
Dmsg3(400, "control_bwlimit: now = %lld, since = %lld, nb_bytes = %d\n", now, temp, m_nb_bytes);
}
/*
* Take care of clock problems (>10s)
*/
if (temp > 10000000) {
return;
}
/*
* Remove what was authorised to be written in temp usecs.
*/
m_nb_bytes -= (int64_t)(temp * ((double)m_bwlimit / 1000000.0));
if (m_nb_bytes < 0) {
/*
* If more was authorized then used but bursting is not enabled
* reset the counter as these bytes cannot be used later on when
* we are exceeding our bandwidth.
*/
if (!m_use_bursting) {
m_nb_bytes = 0;
}
return;
}
/*
* What exceed should be converted in sleep time
*/
usec_sleep = (int64_t)(m_nb_bytes /((double)m_bwlimit / 1000000.0));
if (usec_sleep > 100) {
if (debug_level >= 400) {
Dmsg1(400, "control_bwlimit: sleeping for %lld usecs\n", usec_sleep);
}
/*
* Sleep the right number of usecs.
*/
while (1) {
bmicrosleep(0, usec_sleep);
now = get_current_btime();
/*
* See if we slept enough or that bmicrosleep() returned early.
*/
if ((now - m_last_tick) < usec_sleep) {
usec_sleep -= (now - m_last_tick);
continue;
} else {
m_last_tick = now;
break;
}
}
/*
* Subtract the number of bytes we could have sent during the sleep
* time given the bandwidth limit set. We only do this when we are
* allowed to burst e.g. use unused bytes from previous timeslices
* to get an overall bandwidth limiting which may sometimes be below
* the bandwidth and sometimes above it but the average will be near
* the set bandwidth.
*/
if (m_use_bursting) {
m_nb_bytes -= (int64_t)(usec_sleep * ((double)m_bwlimit / 1000000.0));
} else {
m_nb_bytes = 0;
}
}
}