From: Kern Sibbald Date: Sun, 20 Aug 2006 13:27:55 +0000 (+0000) Subject: kes Print JobIds to be migrated in Job Report. X-Git-Tag: Release-2.0.0~599 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=ce0c0525164af818757fbf5fe8f733a1ca4ea5b1;p=bacula%2Fbacula kes Print JobIds to be migrated in Job Report. kes Add additional user supplied notes to the messages part of bacula-dir.conf concerning multiple email addresses. kes Fix an incorrect comment pointed out by a user in dvd_handler.in kes Add more recent Feature requests to Projects file. git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@3309 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/projects b/bacula/projects index 6e126ec186..4af15b1ce7 100644 --- a/bacula/projects +++ b/bacula/projects @@ -903,3 +903,97 @@ Item n: Split documentation Notes: +Item n: Include an option to operate on all pools when doing + update vol parameters + + Origin: Dmitriy Pinchukov + Date: 16 August 2006 + Status: + + What: When I do update -> Volume parameters -> All Volumes + from Pool, then I have to select pools one by one. I'd like + console to have an option like "0: All Pools" in the list of + defined pools. + + Why: I have many pools and therefore unhappy with manually + updating each of them using update -> Volume parameters -> All + Volumes from Pool -> pool #. + +Item n: Automatic promotion of backup levels + Date: 19 January 2006 + Origin: Adam Thornton + Status: Blue sky + + What: Amanda has a feature whereby it estimates the space that a + differential, incremental, and full backup would take. If the + difference in space required between the scheduled level and the next + level up is beneath some user-defined critical threshold, the backup + level is bumped to the next type. Doing this minimizes the number of + volumes necessary during a restore, with a fairly minimal cost in + backup media space. + + Why: I know at least one (quite sophisticated and smart) user + for whom the absence of this feature is a deal-breaker in terms of + using Bacula; if we had it it would eliminate the one cool thing + Amanda can do and we can't (at least, the one cool thing I know of). + + + + +Item n+1: Incorporation of XACML2/SAML2 parsing + Date: 19 January 2006 + Origin: Adam Thornton + Status: Blue sky + + What: XACML is "eXtensible Access Control Markup Language" and + "SAML is the "Security Assertion Markup Language"--an XML standard + for making statements about identity and authorization. Having these + would give us a framework to approach ACLs in a generic manner, and + in a way flexible enough to support the four major sorts of ACLs I + see as a concern to Bacula at this point, as well as (probably) to + deal with new sorts of ACLs that may appear in the future. + + Why: Bacula is beginning to need to back up systems with ACLs + that do not map cleanly onto traditional Unix permissions. I see + four sets of ACLs--in general, mutually incompatible with one + another--that we're going to need to deal with. These are: NTFS + ACLs, POSIX ACLs, NFSv4 ACLS, and AFS ACLS. (Some may question the + relevance of AFS; AFS is one of Sine Nomine's core consulting + businesses, and having a reputable file-level backup and restore + technology for it (as Tivoli is probably going to drop AFS support + soon since IBM no longer supports AFS) would be of huge benefit to + our customers; we'd most likely create the AFS support at Sine Nomine + for inclusion into the Bacula (and perhaps some changes to the + OpenAFS volserver) core code.) + + Now, obviously, Bacula already handles NTFS just fine. However, I + think there's a lot of value in implementing a generic ACL model, so + that it's easy to support whatever particular instances of ACLs come + down the pike: POSIX ACLS (think SELinux) and NFSv4 are the obvious + things arriving in the Linux world in a big way in the near future. + XACML, although overcomplicated for our needs, provides this + framework, and we should be able to leverage other people's + implementations to minimize the amount of work *we* have to do to get + a generic ACL framework. Basically, the costs of implementation are + high, but they're largely both external to Bacula and already sunk. + +Item 1: Add an over-ride in the Schedule configuration to use a + different pool for different backup types. + +Date: 19 Jan 2005 +Origin: Chad Slater +Status: + + What: Adding a FullStorage=BigTapeLibrary in the Schedule resource + would help those of us who use different storage devices for different + backup levels cope with the "auto-upgrade" of a backup. + + Why: Assume I add several new device to be backed up, i.e. several + hosts with 1TB RAID. To avoid tape switching hassles, incrementals are + stored in a disk set on a 2TB RAID. If you add these devices in the + middle of the month, the incrementals are upgraded to "full" backups, + but they try to use the same storage device as requested in the + incremental job, filling up the RAID holding the differentials. If we + could override the Storage parameter for full and/or differential + backups, then the Full job would use the proper Storage device, which + has more capacity (i.e. a 8TB tape library. diff --git a/bacula/scripts/dvd-handler.in b/bacula/scripts/dvd-handler.in index 1aa05e842d..f51e9473d0 100644 --- a/bacula/scripts/dvd-handler.in +++ b/bacula/scripts/dvd-handler.in @@ -52,23 +52,23 @@ class disk: # dvd-writepart doesn't not always need to know the free space). # # The following methods are implemented: -# __init__ we need that... -# __repr__ this seems to be a good idea to have. -# Quite minimalistic implementation, though. -# __str__ For casts to string. Return the current disk information -# is_empty Returns TRUE if the disk is empty, blank... this needs more -# work, especially concerning non-RW media and blank vs. no -# filesystem considerations. Here, we should also look for -# other filesystems - probably we don't want to silently -# overwrite UDF or ext2 or anything not mentioned in fstab... -# (NB: I don't think it is a problem) -# free Returns the available free space. -# write Writes one part file to disk, either starting a new file -# system on disk, or appending to it. -# This method should also prepare a blank disk so that a -# certain part of the disk is used to allow detection of a -# used disk by all / more disk drives. -# blank Blank the device +# __init__ we need that... +# __repr__ this seems to be a good idea to have. +# Quite minimalistic implementation, though. +# __str__ For casts to string. Return the current disk information +# is_empty Returns TRUE if the disk is empty, blank... this needs more +# work, especially concerning non-RW media and blank vs. no +# filesystem considerations. Here, we should also look for +# other filesystems - probably we don't want to silently +# overwrite UDF or ext2 or anything not mentioned in fstab... +# (NB: I don't think it is a problem) +# free Returns the available free space. +# write Writes one part file to disk, either starting a new file +# system on disk, or appending to it. +# This method should also prepare a blank disk so that a +# certain part of the disk is used to allow detection of a +# used disk by all / more disk drives. +# blank Blank the device # ############################################################################### def __init__(self, devicename): @@ -87,10 +87,10 @@ class disk: self.growcmd += " -quiet" if self.is4gbsupported(): - self.growcmd += " -use-the-force-luke=4gms" + self.growcmd += " -use-the-force-luke=4gms" self.growparams = " -A 'Bacula Data' -input-charset=default -iso-level 3 -pad " + \ - "-p 'dvd-handler / growisofs' -sysid 'BACULADATA' -R" + "-p 'dvd-handler / growisofs' -sysid 'BACULADATA' -R" return @@ -99,9 +99,9 @@ class disk: def __str__(self): if not self.freespace_collected: - self.collect_freespace(); + self.collect_freespace(); if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); self.me = "Class disk, initialized with device '" + self.device + "'\n" self.me += "type = '" + self.disktype + "' mode='" + self.diskmode + "' status = '" + self.diskstatus + "'\n" @@ -115,47 +115,47 @@ class disk: processi = popen2.Popen4("uname -s -r") status = processi.wait() if not os.WIFEXITED(status): - return 1 + return 1 if os.WEXITSTATUS(status) != 0: - return 1 + return 1 strres = processi.fromchild.readline()[0:-1] version = re.search(r"Linux (\d+)\.(\d+)\.(\d+)", strres) if not version: # Non-Linux: allow - return 1 + return 1 if (int(version.group(1)) > 2) or (int(version.group(2)) > 6) or ((int(version.group(1)) == 2) and (int(version.group(2)) == 6) and (int(version.group(3)) >= 8)): - return 1 + return 1 else: - return 0 + return 0 def collect_freespace(self): # Collects current free space self.cmd = self.growcmd + " -F " + self.device processi = popen2.Popen4(self.cmd) status = processi.wait() if not os.WIFEXITED(status): - raise DVDError(0, "growisofs process did not exit correctly.") + raise DVDError(0, "growisofs process did not exit correctly.") result = processi.fromchild.read() if os.WEXITSTATUS(status) != 0: - if (os.WEXITSTATUS(status) & 0x7F) == errno.ENOSPC: - # Kludge to force dvd-handler to return a free space of 0 - self.next_session = 1 - self.capacity = 1 - self.freespace_collected = 1 - return - else: - raise DVDError(os.WEXITSTATUS(status), "growisofs returned with an error " + result + ". Please check your are using a patched version of dvd+rw-tools.") + if (os.WEXITSTATUS(status) & 0x7F) == errno.ENOSPC: + # Kludge to force dvd-handler to return a free space of 0 + self.next_session = 1 + self.capacity = 1 + self.freespace_collected = 1 + return + else: + raise DVDError(os.WEXITSTATUS(status), "growisofs returned with an error " + result + ". Please check your are using a patched version of dvd+rw-tools.") next_sess = re.search(r"\snext_session=(\d+)\s", result, re.MULTILINE) capa = re.search(r"\scapacity=(\d+)\s", result, re.MULTILINE) if next_sess and capa: - self.next_session = long(next_sess.group(1)) - self.capacity = long(capa.group(1)) - - # testing cheat (emulate 4GB boundary at 100MB) - #if self.next_session > 100000000: - # self.capacity = self.next_session + self.next_session = long(next_sess.group(1)) + self.capacity = long(capa.group(1)) + + # testing cheat (emulate 4GB boundary at 100MB) + #if self.next_session > 100000000: + # self.capacity = self.next_session else: - raise DVDError(0, "Cannot get next_session and capacity from growisofs.\nReturned: " + result) + raise DVDError(0, "Cannot get next_session and capacity from growisofs.\nReturned: " + result) self.freespace_collected = 1 return @@ -166,10 +166,10 @@ class disk: processi = popen2.Popen4(cmd) status = processi.wait() if not os.WIFEXITED(status): - raise DVDError(0, self.dvdrwmediainfo + " process did not exit correctly.") + raise DVDError(0, self.dvdrwmediainfo + " process did not exit correctly.") if os.WEXITSTATUS(status) != 0: - raise DVDError(0, "Cannot get media info from " + self.dvdrwmediainfo) - return + raise DVDError(0, "Cannot get media info from " + self.dvdrwmediainfo) + return result = processi.fromchild.read() hardware = re.search(r"INQUIRY:\s+(.*)\n", result, re.MULTILINE) @@ -178,23 +178,23 @@ class disk: status = re.search(r"\sDisc status:\s+(.*)\n", result, re.MULTILINE) if hardware: - self.hardwaredevice = hardware.group(1) + self.hardwaredevice = hardware.group(1) if mediatype: - self.disktype = mediatype.group(2) + self.disktype = mediatype.group(2) else: - raise DVDError(0, "Media type not found in " + self.dvdrwmediainfo + " output") + raise DVDError(0, "Media type not found in " + self.dvdrwmediainfo + " output") if self.disktype == "DVD-RW": - if mediamode: - self.diskmode = mediamode.group(1) - else: - raise DVDError(0, "Media mode not found for DVD-RW in " + self.dvdrwmediainfo + " output") + if mediamode: + self.diskmode = mediamode.group(1) + else: + raise DVDError(0, "Media mode not found for DVD-RW in " + self.dvdrwmediainfo + " output") if status: - self.diskstatus = status.group(1) + self.diskstatus = status.group(1) else: - raise DVDError(0, "Disc status not found in " + self.dvdrwmediainfo + " output") + raise DVDError(0, "Disc status not found in " + self.dvdrwmediainfo + " output") self.mediumtype_collected = 1 @@ -202,76 +202,76 @@ class disk: def is_empty(self): if not self.freespace_collected: - self.collect_freespace(); + self.collect_freespace(); return 0 == self.next_session def is_RW(self): if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); return "DVD-RW" == self.disktype or "DVD+RW" == self.disktype or "DVD-RAM" == self.disktype def is_plus_RW(self): if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); return "DVD+RW" == self.disktype def is_minus_RW(self): if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); return "DVD-RW" == self.disktype def is_restricted_overwrite(self): if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); return self.diskmode == "Restricted Overwrite" def is_blank(self): if not self.mediumtype_collected: - self.collect_mediumtype(); + self.collect_mediumtype(); return self.diskstatus == "blank" def free(self): if not self.freespace_collected: - self.collect_freespace(); + self.collect_freespace(); fr = self.capacity-self.next_session-self.margin if fr < 0: - return 0 + return 0 else: - return fr + return fr def term_handler(self, signum, frame): print 'dvd-handler: Signal term_handler called with signal', signum if self.pid != 0: - print "dvd-handler: Sending SIGTERM to pid", self.pid - os.kill(self.pid, signal.SIGTERM) - time.sleep(10) - print "dvd-handler: Sending SIGKILL to pid", self.pid - os.kill(self.pid, signal.SIGKILL) - sys.exit(1) + print "dvd-handler: Sending SIGTERM to pid", self.pid + os.kill(self.pid, signal.SIGTERM) + time.sleep(10) + print "dvd-handler: Sending SIGKILL to pid", self.pid + os.kill(self.pid, signal.SIGKILL) + sys.exit(1) def write(self, newvol, partfile): # Blank DVD+RW when there is no data on it if newvol and self.is_plus_RW() and self.is_blank(): - print "DVD+RW looks brand-new, blank it to fix some DVD-writers bugs." - self.blank() - print "Done, now writing the part file." + print "DVD+RW looks brand-new, blank it to fix some DVD-writers bugs." + self.blank() + print "Done, now writing the part file." if newvol and self.is_minus_RW() and (not self.is_restricted_overwrite()): - print "DVD-RW is in " + self.diskmode + " mode, reformating it to Restricted Overwrite" - self.reformat_minus_RW() - print "Done, now writing the part file." + print "DVD-RW is in " + self.diskmode + " mode, reformating it to Restricted Overwrite" + self.reformat_minus_RW() + print "Done, now writing the part file." cmd = self.growcmd + self.growparams if newvol: - cmd += " -Z " - // Ignore any existing iso9660 filesystem - used for truncate - if newvol == 2: - cmd += "-use-the-force-luke=tty " + cmd += " -Z " + # Ignore any existing iso9660 filesystem - used for truncate + if newvol == 2: + cmd += "-use-the-force-luke=tty " else: - cmd += " -M " + cmd += " -M " cmd += self.device + " " + str(partfile) print "Running " + cmd oldsig = signal.signal(signal.SIGTERM, self.term_handler) @@ -279,38 +279,38 @@ class disk: self.pid = proc.pid status = proc.poll() while status == -1: - line = proc.fromchild.readline() - while len(line) > 0: - print line, - line = proc.fromchild.readline() - time.sleep(1) - status = proc.poll() + line = proc.fromchild.readline() + while len(line) > 0: + print line, + line = proc.fromchild.readline() + time.sleep(1) + status = proc.poll() self.pid = 0 print signal.signal(signal.SIGTERM, oldsig) if os.WEXITSTATUS(status) != 0: - raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) + raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) def prepare(self): if not self.is_RW(): - raise DVDError(0, "I won't prepare a non-rewritable medium") + raise DVDError(0, "I won't prepare a non-rewritable medium") # Blank DVD+RW when there is no data on it if self.is_plus_RW() and self.is_blank(): - print "DVD+RW looks brand-new, blank it to fix some DVD-writers bugs." - self.blank() - return # It has been completely blanked: Medium is ready to be used by Bacula + print "DVD+RW looks brand-new, blank it to fix some DVD-writers bugs." + self.blank() + return # It has been completely blanked: Medium is ready to be used by Bacula if self.is_minus_RW() and (not self.is_restricted_overwrite()): - print "DVD-RW is in " + self.diskmode + " mode, reformating it to Restricted Overwrite" - self.reformat_minus_RW() - return # Reformated: Medium is ready to be used by Bacula + print "DVD-RW is in " + self.diskmode + " mode, reformating it to Restricted Overwrite" + self.reformat_minus_RW() + return # Reformated: Medium is ready to be used by Bacula # TODO: Check if /dev/fd/0 and /dev/zero exists, otherwise, run self.blank() if not os.path.exists("/dev/fd/0") or not os.path.exists("/dev/zero"): - print "/dev/fd/0 or /dev/zero doesn't exist, blank the medium completely." - self.blank() - return + print "/dev/fd/0 or /dev/zero doesn't exist, blank the medium completely." + self.blank() + return cmd = self.dd + " if=/dev/zero bs=1024 count=512 | " + self.growcmd + " -Z " + self.device + "=/dev/fd/0" print "Running " + cmd @@ -319,17 +319,17 @@ class disk: self.pid = proc.pid status = proc.poll() while status == -1: - line = proc.fromchild.readline() - while len(line) > 0: - print line, - line = proc.fromchild.readline() - time.sleep(1) - status = proc.poll() + line = proc.fromchild.readline() + while len(line) > 0: + print line, + line = proc.fromchild.readline() + time.sleep(1) + status = proc.poll() self.pid = 0 print signal.signal(signal.SIGTERM, oldsig) if os.WEXITSTATUS(status) != 0: - raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) + raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) def blank(self): cmd = self.growcmd + " -Z " + self.device + "=/dev/zero" @@ -339,17 +339,17 @@ class disk: self.pid = proc.pid status = proc.poll() while status == -1: - line = proc.fromchild.readline() - while len(line) > 0: - print line, - line = proc.fromchild.readline() - time.sleep(1) - status = proc.poll() + line = proc.fromchild.readline() + while len(line) > 0: + print line, + line = proc.fromchild.readline() + time.sleep(1) + status = proc.poll() self.pid = 0 print signal.signal(signal.SIGTERM, oldsig) if os.WEXITSTATUS(status) != 0: - raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) + raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) def reformat_minus_RW(self): cmd = self.dvdrwformat + " -force " + self.device @@ -359,17 +359,17 @@ class disk: self.pid = proc.pid status = proc.poll() while status == -1: - line = proc.fromchild.readline() - while len(line) > 0: - print line, - line = proc.fromchild.readline() - time.sleep(1) - status = proc.poll() + line = proc.fromchild.readline() + while len(line) > 0: + print line, + line = proc.fromchild.readline() + time.sleep(1) + status = proc.poll() self.pid = 0 print signal.signal(signal.SIGTERM, oldsig) if os.WEXITSTATUS(status) != 0: - raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) + raise DVDError(os.WEXITSTATUS(status), cmd + " exited with status " + str(os.WEXITSTATUS(status)) + ", signal/status " + str(status)) # class disk ends here. @@ -378,7 +378,7 @@ class DVDError(Exception): self.errno = errno self.value = value if self.value[-1] == '\n': - self.value = self.value[0:-1] + self.value = self.value[0:-1] def __str__(self): return str(self.value) + " || errno = " + str(self.errno) + " (" + os.strerror(self.errno & 0x7F) + ")" @@ -395,19 +395,19 @@ dvd-handler DEVICE blank where DEVICE is a device name like /dev/sr0 or /dev/dvd. Operations: -test Scan the device and report the information found. - This operation needs no further arguments. -free Scan the device and report the available space. -write Write a part file to disk. - This operation needs two additional arguments. - The first indicates to append (0), restart the - disk (1) or restart existing disk (2). The second - is the file to write. +test Scan the device and report the information found. + This operation needs no further arguments. +free Scan the device and report the available space. +write Write a part file to disk. + This operation needs two additional arguments. + The first indicates to append (0), restart the + disk (1) or restart existing disk (2). The second + is the file to write. prepare Prepare a DVD+/-RW for being used by Bacula. - Note: This is only useful if you already have some - non-Bacula data on a medium, and you want to use - it with Bacula. Don't run this on blank media, it - is useless. + Note: This is only useful if you already have some + non-Bacula data on a medium, and you want to use + it with Bacula. Don't run this on blank media, it + is useless. """ sys.exit(1) @@ -419,31 +419,31 @@ dvd = disk(sys.argv[1]) if "free" == sys.argv[2]: if len(sys.argv) == 3: try: - free = dvd.free() + free = dvd.free() except DVDError, e: - if e.errno != 0: - print -e.errno - else: - print errno.EPIPE - print str(e) + if e.errno != 0: + print -e.errno + else: + print errno.EPIPE + print str(e) else: - print free - print "No Error reported." + print free + print "No Error reported." else: print "Wrong number of arguments for free operation." usage() elif "prepare" == sys.argv[2]: if len(sys.argv) == 3: try: - dvd.prepare() + dvd.prepare() except DVDError, e: - print "Error while preparing medium: ", str(e) - if e.errno != 0: - sys.exit(e.errno & 0x7F) - else: - sys.exit(errno.EPIPE) + print "Error while preparing medium: ", str(e) + if e.errno != 0: + sys.exit(e.errno & 0x7F) + else: + sys.exit(errno.EPIPE) else: - print "Medium prepared successfully." + print "Medium prepared successfully." else: print "Wrong number of arguments for prepare operation." usage() @@ -457,15 +457,15 @@ elif "test" == sys.argv[2]: elif "write" == sys.argv[2]: if len(sys.argv) == 5: try: - dvd.write(long(sys.argv[3]), sys.argv[4]) + dvd.write(long(sys.argv[3]), sys.argv[4]) except DVDError, e: - print "Error while writing part file: ", str(e) - if e.errno != 0: - sys.exit(e.errno & 0x7F) - else: - sys.exit(errno.EPIPE) + print "Error while writing part file: ", str(e) + if e.errno != 0: + sys.exit(e.errno & 0x7F) + else: + sys.exit(errno.EPIPE) else: - print "Part file " + sys.argv[4] + " successfully written to disk." + print "Part file " + sys.argv[4] + " successfully written to disk." else: print "Wrong number of arguments for write operation." usage() diff --git a/bacula/src/dird/bacula-dir.conf.in b/bacula/src/dird/bacula-dir.conf.in index a6211b4ca9..b1505056e7 100644 --- a/bacula/src/dird/bacula-dir.conf.in +++ b/bacula/src/dird/bacula-dir.conf.in @@ -238,6 +238,13 @@ Messages { # NOTE! If you send to two email or more email addresses, you will need # to replace the %r in the from field (-f part) with a single valid # email address in both the mailcommand and the operatorcommand. +# What this does is, it sets the email address that emails would display +# in the FROM field, which is by default the same email as they're being +# sent to. However, if you send email to more than one address, then +# you'll have to set the FROM address manually, to a single address. +# for example, a 'no-reply@mydomain.com', is better since that tends to +# tell (most) people that its coming from an automated source. + # mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula\) %r\" -s \"Bacula: %t %e of %c %l\" %r" operatorcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula\) %r\" -s \"Bacula: Intervention needed for %j\" %r" diff --git a/bacula/src/dird/migrate.c b/bacula/src/dird/migrate.c index 38f51f31a8..7db104bbcc 100644 --- a/bacula/src/dird/migrate.c +++ b/bacula/src/dird/migrate.c @@ -651,6 +651,8 @@ static bool get_job_to_migrate(JCR *jcr) * for each of them. For the last JobId, we handle it below. */ p = ids.list; + Jmsg(jcr, M_INFO, 0, _("The following %u JobIds will be migrated: %s\n"), + ids.count, ids.list); for (int i=1; i < (int)ids.count; i++) { JobId = 0; stat = get_next_jobid_from_list(&p, &JobId); diff --git a/bacula/src/version.h b/bacula/src/version.h index 5345295d52..21ae96490c 100644 --- a/bacula/src/version.h +++ b/bacula/src/version.h @@ -4,8 +4,8 @@ #undef VERSION #define VERSION "1.39.20" -#define BDATE "19 August 2006" -#define LSMDATE "19Aug06" +#define BDATE "20 August 2006" +#define LSMDATE "20Aug06" #define BYEAR "2006" /* year for copyright messages in progs */ /* Debug flags */ diff --git a/bacula/technotes-1.39 b/bacula/technotes-1.39 index 001893a803..b012f0eaf9 100644 --- a/bacula/technotes-1.39 +++ b/bacula/technotes-1.39 @@ -1,6 +1,12 @@ Technical notes on version 1.39 General: +20Aug06 +kes Print JobIds to be migrated in Job Report. +kes Add additional user supplied notes to the messages part of + bacula-dir.conf concerning multiple email addresses. +kes Fix an incorrect comment pointed out by a user in dvd_handler.in +kes Add more recent Feature requests to Projects file. 19Aug06 kes Apply Maritn's fix to src/win32/Makefile. kes Apply Martin's fix to configure.in for pthreads on FreeBSD 4.x