This chapter presents the new features added to the development 2.5.x
versions to be released as Bacula version 3.0.0 near the end of 2008.
-\section{Accurate}
+\section{Accurate Backup}
\index[general]{Accurate Backup}
-As with most other backup programs, Bacula decides what files to backup for
-Incremental and Differental backup by comparing the change (st\_ctime) and
-modification (st\_mtime) times of the file to the time the last backup
-completed. If one of those two times is different than from last backup time,
-then the file will be backed up. This does not, however, permit tracking what
-files have been deleted and will miss any file with an old time that may have
-been restored or moved on the client filesystem.
+As with most other backup programs, by default Bacula decides what files to
+backup for Incremental and Differental backup by comparing the change
+(st\_ctime) and modification (st\_mtime) times of the file to the time the last
+backup completed. If one of those two times is later than the last backup
+time, then the file will be backed up. This does not, however, permit tracking
+what files have been deleted and will miss any file with an old time that may
+have been restored to or moved onto the client filesystem.
\subsection{Accurate = \lt{}yes|no\gt{}}
If the {\bf Accurate = \lt{}yes|no\gt{}} directive is enabled (default no) in
\section{Copy Jobs}
\index[general]{Copy Jobs}
-A new {\bf Copy} job type has been implemented. It is essentially
-identical to the existing Migration feature with the exception that
-the Job that is copied is left unchanged. This essentially creates
-two identical copies of the same backup. The Copy Job runs without
-using the File daemon by copying the data from the old backup Volume to
-a different Volume in a different Pool. See the Migration documentation
-for additional details.
+
+A new {\bf Copy} job type 'C' has been implemented. It is similar to the
+existing Migration feature with the exception that the Job that is copied is
+left unchanged. This essentially creates two identical copies of the same
+backup. However, the copy is treated as a copy rather than a backup job, and
+hence is not directly available for restore. The {\bf restore} command lists
+copy jobs and allows selection of copies by using \texttt{jobid=}
+option. If the keyword {\bf copies} is present on the command line, Bacula will
+display the list of all copies for selected jobs.
+
+\begin{verbatim}
+* restore copies
+[...]
+These JobIds have copies as follows:
++-------+------------------------------------+-----------+------------------+
+| JobId | Job | CopyJobId | MediaType |
++-------+------------------------------------+-----------+------------------+
+| 2 | CopyJobSave.2009-02-17_16.31.00.11 | 7 | DiskChangerMedia |
++-------+------------------------------------+-----------+------------------+
++-------+-------+----------+----------+---------------------+------------------+
+| JobId | Level | JobFiles | JobBytes | StartTime | VolumeName |
++-------+-------+----------+----------+---------------------+------------------+
+| 19 | F | 6274 | 76565018 | 2009-02-17 16:30:45 | ChangerVolume002 |
+| 2 | I | 1 | 5 | 2009-02-17 16:30:51 | FileVolume001 |
++-------+-------+----------+----------+---------------------+------------------+
+You have selected the following JobIds: 19,2
+
+Building directory tree for JobId(s) 19,2 ... ++++++++++++++++++++++++++++++++++++++++++++
+5,611 files inserted into the tree.
+...
+\end{verbatim}
+
+
+The Copy Job runs without using the File daemon by copying the data from the
+old backup Volume to a different Volume in a different Pool. See the Migration
+documentation for additional details. For copy Jobs there is a new selection
+criterium named PoolUncopiedJobs which copies all jobs from a pool to an other
+pool which were not copied before. Next to that the client, volume, job or sql
+query are possible ways of selecting jobs which should be copied. Selection
+types like smallestvolume, oldestvolume, pooloccupancy and pooltime are
+probably more suited for migration jobs only. But we could imagine some people
+have a valid use for those kind of copy jobs too.
+
+If bacula founds a copy when a job record is purged (deleted) from the catalog,
+it will promote the copy as \textsl{real} backup and will make it available for
+automatic restore. If more than one copy is available, it will promote the copy
+with the smallest jobid.
+
+A nice solution which can be build with the new copy jobs is what is
+called the disk-to-disk-to-tape backup (DTDTT). A sample config could
+look somethings like the one below:
+
+\begin{verbatim}
+Pool {
+ Name = FullBackupsVirtualPool
+ Pool Type = Backup
+ Purge Oldest Volume = Yes
+ Storage = vtl
+ NextPool = FullBackupsTapePool
+}
+
+Pool {
+ Name = FullBackupsTapePool
+ Pool Type = Backup
+ Recycle = Yes
+ AutoPrune = Yes
+ Volume Retention = 365 days
+ Storage = superloader
+}
+
+#
+# Fake fileset for copy jobs
+#
+Fileset {
+ Name = None
+ Include {
+ Options {
+ signature = MD5
+ }
+ }
+}
+
+#
+# Fake client for copy jobs
+#
+Client {
+ Name = None
+ Address = localhost
+ Password = "NoNe"
+ Catalog = MyCatalog
+}
+
+#
+# Default template for a CopyDiskToTape Job
+#
+JobDefs {
+ Name = CopyDiskToTape
+ Type = Copy
+ Messages = StandardCopy
+ Client = None
+ FileSet = None
+ Selection Type = PoolUncopiedJobs
+ Maximum Concurrent Jobs = 10
+ SpoolData = No
+ Allow Duplicate Jobs = Yes
+ Allow Higher Duplicates = No
+ Cancel Queued Duplicates = No
+ Cancel Running Duplicates = No
+ Priority = 13
+}
+
+Schedule {
+ Name = DaySchedule7:00
+ Run = Level=Full daily at 7:00
+}
+
+Job {
+ Name = CopyDiskToTapeFullBackups
+ Enabled = Yes
+ Schedule = DaySchedule7:00
+ Pool = FullBackupsVirtualPool
+ JobDefs = CopyDiskToTape
+}
+\end{verbatim}
+
+The example above had 2 pool which are copied using the PoolUncopiedJobs
+selection criteria. Normal Full backups go to the Virtual pool and are copied
+to the Tape pool the next morning.
+
+The command \texttt{list copies [jobid=x,y,z]} lists copies for a given
+\textbf{jobid}.
+
+\begin{verbatim}
+*list copies
++-------+------------------------------------+-----------+------------------+
+| JobId | Job | CopyJobId | MediaType |
++-------+------------------------------------+-----------+------------------+
+| 9 | CopyJobSave.2008-12-20_22.26.49.05 | 11 | DiskChangerMedia |
++-------+------------------------------------+-----------+------------------+
+\end{verbatim}
+
+\section{ACL Updates}
+The whole ACL code had been overhauled and in this version each platforms has
+different streams for each type of acl available on such an platform. As acls
+between platforms tend to be not that portable (most implement POSIX acls but
+some use an other draft or a completely different format) we currently only
+allow certain platform specific ACL streams to be decoded and restored on the
+same platform that they were created on. The old code allowed to restore ACL
+cross platform but the comments already mention that not being to wise. For
+backward compatability the new code will accept the 2 old ACL streams and
+handle those with the platform specific handler. But for all new backups it
+will save the ACLs using the new streams.
+
+Currently the following platforms support ACLs:
+
+\begin{itemize}
+ \item {\bf AIX}
+ \item {\bf Darwin/OSX}
+ \item {\bf FreeBSD}
+ \item {\bf HPUX}
+ \item {\bf IRIX}
+ \item {\bf Linux}
+ \item {\bf Tru64}
+ \item {\bf Solaris}
+\end{itemize}
+
+Currently we support the following ACL types (these ACL streams use a reserved
+part of the stream numbers):
+
+\begin{itemize}
+\item {\bf STREAM\_ACL\_AIX\_TEXT} 1000 AIX specific string representation from
+ acl\_get
+ \item {\bf STREAM\_ACL\_DARWIN\_ACCESS\_ACL} 1001 Darwin (OSX) specific acl\_t
+ string representation from acl\_to\_text (POSIX acl)
+ \item {\bf STREAM\_ACL\_FREEBSD\_DEFAULT\_ACL} 1002 FreeBSD specific acl\_t
+ string representation from acl\_to\_text (POSIX acl) for default acls.
+ \item {\bf STREAM\_ACL\_FREEBSD\_ACCESS\_ACL} 1003 FreeBSD specific acl\_t
+ string representation from acl\_to\_text (POSIX acl) for access acls.
+ \item {\bf STREAM\_ACL\_HPUX\_ACL\_ENTRY} 1004 HPUX specific acl\_entry
+ string representation from acltostr (POSIX acl)
+ \item {\bf STREAM\_ACL\_IRIX\_DEFAULT\_ACL} 1005 IRIX specific acl\_t string
+ representation from acl\_to\_text (POSIX acl) for default acls.
+ \item {\bf STREAM\_ACL\_IRIX\_ACCESS\_ACL} 1006 IRIX specific acl\_t string
+ representation from acl\_to\_text (POSIX acl) for access acls.
+ \item {\bf STREAM\_ACL\_LINUX\_DEFAULT\_ACL} 1007 Linux specific acl\_t
+ string representation from acl\_to\_text (POSIX acl) for default acls.
+ \item {\bf STREAM\_ACL\_LINUX\_ACCESS\_ACL} 1008 Linux specific acl\_t string
+ representation from acl\_to\_text (POSIX acl) for access acls.
+ \item {\bf STREAM\_ACL\_TRU64\_DEFAULT\_ACL} 1009 Tru64 specific acl\_t
+ string representation from acl\_to\_text (POSIX acl) for default acls.
+ \item {\bf STREAM\_ACL\_TRU64\_DEFAULT\_DIR\_ACL} 1010 Tru64 specific acl\_t
+ string representation from acl\_to\_text (POSIX acl) for default acls.
+ \item {\bf STREAM\_ACL\_TRU64\_ACCESS\_ACL} 1011 Tru64 specific acl\_t string
+ representation from acl\_to\_text (POSIX acl) for access acls.
+ \item {\bf STREAM\_ACL\_SOLARIS\_ACLENT} 1012 Solaris specific aclent\_t
+ string representation from acltotext or acl\_totext (POSIX acl)
+ \item {\bf STREAM\_ACL\_SOLARIS\_ACE} 1013 Solaris specific ace\_t string
+ representation from from acl\_totext (NFSv4 or ZFS acl)
+\end{itemize}
+
+In future versions we might support conversion functions from one type of acl
+into an other for types that are either the same or easily convertable. For now
+the streams are seperate and restoring them on a platform that doesn't
+recognize them will give you a warning.
+
+\section{Extended Attributes}
+Something that was on the project list for some time is now implemented for
+platforms that support a similar kind of interface. Its the support for backup
+and restore of so called extended attributes. As extended attributes are so
+platform specific these attributes are saved in seperate streams for each
+platform. Restores can only be performed on the same platform the backup was
+done. There is support for all types of extended attributes, but restoring from
+one type of filesystem onto an other type of filesystem on the same platform
+may lead to supprises. As extended attributes can contain any type of data they
+are stored as a series of so called value-pairs. This data must be seen as
+mostly binary and is stored as such. As security labels from selinux are also
+extended attributes this option also stores those labels and no specific code
+is enabled for handling selinux security labels.
+
+Currently the following platforms support extended attributes:
+\begin{itemize}
+ \item {\bf Darwin/OSX}
+ \item {\bf FreeBSD}
+ \item {\bf Linux}
+ \item {\bf NetBSD}
+\end{itemize}
+
+On linux acls are also extended attributes, as such when you enable ACLs on a
+Linux platform it will NOT save the same data twice e.g. it will save the ACLs
+and not the same exteneded attribute.
+
+To enable the backup of extended attributes please add the following to your
+fileset definition.
+\begin{verbatim}
+ FileSet {
+ Name = "MyFileSet"
+ Include {
+ Options {
+ signature = MD5
+ xattrsupport = yes
+ }
+ File = ...
+ }
+ }
+\end{verbatim}
+
+\section{Shared objects}
+A default build of Bacula will now create the libraries as shared objects
+(.so) rather than static libraries as was previously the case.
+The shared libraries are built using {\bf libtool} so it should be quite
+portable.
+
+An important advantage of using shared objects is that on a machine with the
+Directory, File daemon, the Storage daemon, and a console, you will have only
+one copy of the code in memory rather than four copies. Also the total size of
+the binary release is smaller since the library code appears only once rather
+than once for every program that uses it; this results in significant reduction
+in the size of the binaries particularly for the utility tools.
+
+In order for the system loader to find the shared objects when loading the
+Bacula binaries, the Bacula shared objects must either be in a shared object
+directory known to the loader (typically /usr/lib) or they must be in the
+directory that may be specified on the {\bf ./configure} line using the {\bf
+ {-}{-}libdir} option as:
+
+\begin{verbatim}
+ ./configure --libdir=/full-path/dir
+\end{verbatim}
+
+the default is /usr/lib. If {-}{-}libdir is specified, there should be
+no need to modify your loader configuration provided that
+the shared objects are installed in that directory (Bacula
+does this with the make install command). The shared objects
+that Bacula references are:
+
+\begin{verbatim}
+libbaccfg.so
+libbacfind.so
+libbacpy.so
+libbac.so
+\end{verbatim}
+
+These files are symbolically linked to the real shared object file,
+which has a version number to permit running multiple versions of
+the libraries if desired (not normally the case).
+
+If you have problems with libtool or you wish to use the old
+way of building static libraries, you can do so by disabling
+libtool on the configure command line with:
+
+\begin{verbatim}
+ ./configure --disable-libtool
+\end{verbatim}
+
\section{Virtual Backup (Vbackup)}
\index[general]{Virtual Backup}
And it would produce a new Full backup without using the client, and the output
would be written to the {\bf Full} Pool which uses the Diskchanger Storage.
+If the Virtual Full is run, and there are no prior Jobs, the Virtual Full will
+fail with an error.
+
+\section{Catalog format}
+Bacula 3.0 comes with some changes on the catalog format. The upgrade operation
+will convert an essential field of the File table that permits to handle more
+than 4 billion objects over the time, and this operation will take TIME and
+will DOUBLE THE SIZE of your catalog temporarily. Depending on your catalog
+backend, you won't be able to run jobs during this period. For example, a 3
+million files catalog will take 2mins to upgrade on a normal machine. Don't
+forget to have a valid backup of it before executing the script.
+
\section{Duplicate Job Control}
\index[general]{Duplicate Jobs}
The new version of Bacula provides four new directives that
The default value is {\bf no}.
-\section{Ignore Dir = \lt{}filename-string\gt{}}
+\section{Exclude Dirs Containing = \lt{}filename-string\gt{}}
\index[general]{IgnoreDir}
-The {\bf Ignore Dir = \lt{}filename\gt{}} is a new directive that can be added to the Include
-section of the FileSet resource. If the specified
-filename is found on the Client in any directory to be backed up,
-the whole directory will be ignored (not backed up).
-For example:
+The {\bf ExcludeDirsContaining = \lt{}filename\gt{}} is a new directive that
+can be added to the Include section of the FileSet resource. If the specified
+filename ({\bf filename-string}) is found on the Client in any directory to be
+backed up, the whole directory will be ignored (not backed up). For example:
\begin{verbatim}
# List of files to be backed up
signature = MD5
}
File = /home
- IgnoreDir = .excludeme
+ Exclude Dirs Containing = .excludeme
}
}
\end{verbatim}
\section{Bacula Plugins}
\index[general]{Plugin}
-Support for shared object plugins has been implemented in the Linux
-(and Unix) File daemon. The API will be documented separately in
+Support for shared object plugins has been implemented in the Linux, Unix
+and Win32 File daemons. The API will be documented separately in
the Developer's Guide or in a new document. For the moment, there is
a single plugin named {\bf bpipe} that allows an external program to
get control to backup and restore a file.
Plugins are also planned (partially implemented) in the Director and the
-Storage daemon. The code is also implemented to work on Win32 machines,
-but it has not yet been tested.
+Storage daemon.
\subsection{Plugin Directory}
Each daemon (DIR, FD, SD) has a new {\bf Plugin Directory} directive that may
load any plugins. Since each plugin has a distinctive name, all the daemons
can share the same plugin directory.
-
-
\subsection{Plugin Options}
The {\bf Plugin Options} directive takes a quoted string
arguement (after the equal sign) and may be specified in the
you can backup any kind of data (ASCII or binary) depending
on the program called.
-\section{Microsoft Exchange Server 2003/2007 plugin}
+\section{Microsoft Exchange Server 2003/2007 Plugin}
\subsection{Concepts}
+Although it is possible to backup Exchange using Bacula VSS the Exchange
+plugin adds a good deal of functionality, because while Bacula VSS
+completes a full backup (snapshot) of Exchange, it does
+not support Incremental or Differential backups, restoring is more
+complicated, and a single database restore is not possible.
Microsoft Exchange organises its storage into Storage Groups with
Databases inside them. A default installation of Exchange will have a
single Storage Group called 'First Storage Group', with two Databases
-inside it, 'Mailbox Store (SERVER NAME)' and 'Public Folder Store
-(SERVER NAME)', which hold user email and public folders respectively.
+inside it, "Mailbox Store (SERVER NAME)" and
+"Public Folder Store (SERVER NAME)",
+which hold user email and public folders respectively.
In the default configuration, Exchange logs everything that happens to
log files, such that if you have a backup, and all the log files since,
you can restore to the present time. Each Storage Group has its own set
of log files and operates independently of any other Storage Groups. At
the Storage Group level, the logging can be turned off by enabling a
-function called 'Enable circular logging'. At this time the Exchange
+function called "Enable circular logging". At this time the Exchange
plugin will not function if this option is enabled.
The plugin allows backing up of entire storage groups, and the restoring
of entire storage groups or individual databases. Backing up and
restoring at the individual mailbox or email item is not supported but
-can be simulate by use of the Recovery Storage Group (see below).
+can be simulated by use of the "Recovery" Storage Group (see below).
\subsection{Installing}
-
-Once the bacula-fd is installed on your Windows server, the Exchange API
-DLL must be copied to the bin directory in the Bacula installation
-directory (eg C:\\Program Files\\Bacula\\bin). The Exchange API DLL is
-named esebcli2.dll and is found in C:\\Program Files\\Exchsrvr\\bin on a
+The Exchange plugin requires a DLL that is shipped with Microsoft
+Exchanger Server called {\bf esebcli2.dll}. Assuming Exchange is installed
+correctly the Exchange plugin should find this automatically and run
+without any additional installation.
+
+If the DLL can not be found automatically it will need to be copied into
+the Bacula installation
+directory (eg C:\verb+\+Program Files\verb+\+Bacula\verb+\+bin). The Exchange API DLL is
+named esebcli2.dll and is found in C:\verb+\+Program Files\verb+\+Exchsrvr\verb+\+bin on a
default Exchange installation.
-We plan to make the plugin a bit smarter about finding the
-esebcli2.dll file, so the step here will ultimately only be as a last
-resort, but for now it is required.
-
-
\subsection{Backup up}
-
To back up an Exchange server the Fileset definition must contain at
-least 'Plugin = "exchange:/@EXCHANGE/Microsoft Information Store"' for
+least {\bf Plugin = "exchange:/@EXCHANGE/Microsoft Information Store"} for
the backup to work correctly. The 'exchange:' bit tells Bacula to look
for the exchange plugin, the '@EXCHANGE' bit makes sure all the backed
up files are prefixed with something that isn't going to share a name
with something outside the plugin, and the 'Microsoft Information Store'
bit is required also. It is also possible to add the name of a storage
-group to the 'Plugin =' line, eg 'Plugin =
-"exchange:/@EXCHANGE/Microsoft Information Store/First Storage Group"'
+group to the "Plugin =" line, eg \\
+{\bf Plugin = "exchange:/@EXCHANGE/Microsoft Information Store/First Storage Group"} \\
if you want only a single storage group backed up.
Additionally, you can suffix the 'Plugin =' directive with
-':notrunconfull' which will tell the plugin not to truncate the Exchange
+":notrunconfull" which will tell the plugin not to truncate the Exchange
database at the end of a full backup.
An Incremental or Differential backup will backup only the database logs
-for each Storage Group by inspecting the 'modified date' on each
+for each Storage Group by inspecting the "modified date" on each
physical log file. Because of the way the Exchange API works, the last
logfile backed up on each backup will always be backed up by the next
Incremental or Differential backup too. This adds 5MB to each
Incremental or Differential backup size but otherwise does not cause any
problems.
+By default, a normal VSS fileset containing all the drive letters will
+also back up the Exchange databases using VSS. This will interfere with
+the plugin and Exchange's shared ideas of when the last full backup was
+done, and may also truncate log files incorrectly. It is important,
+therefore, that the Exchange database files be excluded from the backup,
+although the folders the files are in should be included, or they will
+have to be recreated manually if a baremetal restore is done.
+
+\begin{verbatim}
+FileSet {
+ Include {
+ File = C:/Program Files/Exchsrvr/mdbdata
+ Plugin = "exchange:..."
+ }
+ Exclude {
+ File = C:/Program Files/Exchsrvr/mdbdata/E00.chk
+ File = C:/Program Files/Exchsrvr/mdbdata/E00.log
+ File = C:/Program Files/Exchsrvr/mdbdata/E000000F.log
+ File = C:/Program Files/Exchsrvr/mdbdata/E0000010.log
+ File = C:/Program Files/Exchsrvr/mdbdata/E0000011.log
+ File = C:/Program Files/Exchsrvr/mdbdata/E00tmp.log
+ File = C:/Program Files/Exchsrvr/mdbdata/priv1.edb
+ }
+}
+\end{verbatim}
+
+The advantage of excluding the above files is that you can significantly
+reduce the size of your backup since all the important Exchange files
+will be properly saved by the Plugin.
+
+
\subsection{Restoring}
The restore operation is much the same as a normal Bacula restore, with
the following provisos:
\begin{itemize}
-\item The 'Where' restore option must not be specified
+\item The {\bf Where} restore option must not be specified
\item Each Database directory must be marked as a whole. You cannot just
select (say) the .edb file and not the others.
\item If a Storage Group is restored, the directory of the Storage Group
\item It is possible to restore only a subset of the available log files,
but they {\bf must} be contiguous. Exchange will fail to restore correctly
if a log file is missing from the sequence of log files
-\item Each database to be restored must be dismounted and marked as 'Can be
- overwritten by restore'
+\item Each database to be restored must be dismounted and marked as "Can be
+ overwritten by restore"
\item If an entire Storage Group is to be restored (eg all databases and
logs in the Storage Group), then it is best to manually delete the
- database files from the server (eg C:\\Program Files\\Exchsrvr\\mdbdata\\*)
+ database files from the server (eg C:\verb+\+Program Files\verb+\+Exchsrvr\verb+\+mdbdata\verb+\+*)
as Exchange can get confused by stray log files lying around.
\end{itemize}
\subsection{Restoring to the Recovery Storage Group}
The concept of the Recovery Storage Group is well documented by
-Microsoft (find a link and put it here), but to briefly summarise...
+Microsoft
+\elink{http://support.microsoft.com/kb/824126}{http://support.microsoft.com/kb/824126},
+but to briefly summarize...
Microsoft Exchange allows the creation of an additional Storage Group
called the Recovery Storage Group, which is used to restore an older
-copy of a database (eg before a mailbox was deleted) into without
+copy of a database (e.g. before a mailbox was deleted) into without
messing with the current live data. This is required as the Standard and
Small Business Server versions of Exchange can not ordinarily have more
than one Storage Group.
-To create the Recovery Storage Group, drill down to the Server in
-Exchange System Manager, right click, and select 'New -> Recovery
-Storage Group...'. Accept or change the file locations and click OK. On
-the Recovery Storage Group, right click and select 'Add Database to
-Recover...' and select the database you will be restoring.
-
-In Bacula, select the Database and the log files, making sure to mark
-the Storage Group directory itself too. Once you have selected the files
-to back up, use the RegexWhere clause to remove the prefix of
-'/@EXCHANGE/Microsoft Information Store/<storage group name>/' and
-replace it with '/@EXCHANGE/Microsoft Information Store/Recovery Storage
-Group/'. Then run the restore.
-
-\subsection{}Caveats
-
-The 'Enable Circular Logging' option cannot be enabled or the plugin
+To create the Recovery Storage Group, drill down to the Server in Exchange
+System Manager, right click, and select
+{\bf "New -> Recovery Storage Group..."}. Accept or change the file
+locations and click OK. On the Recovery Storage Group, right click and
+select {\bf "Add Database to Recover..."} and select the database you will
+be restoring.
+
+Restore only the single database nominated as the database in the
+Recovery Storage Group. Exchange will redirect the restore to the
+Recovery Storage Group automatically.
+Then run the restore.
+
+\subsection{Restoring on Microsoft Server 2007}
+Apparently the {\bf Exmerge} program no longer exists in Microsoft Server
+2007, and henc you use a new proceedure for recovering a single mail box.
+This procedure is ducomented by Microsoft at:
+\elink{http://technet.microsoft.com/en-us/library/aa997694.aspx}{http://technet.microsoft.com/en-us/library/aa997694.aspx},
+and involves using the {\bf Restore-Mailbox} and {\bf
+Get-MailboxStatistics} shell commands.
+
+\subsection{Caveats}
+This plugin is still being developed, so you should consider it
+currently in BETA test, and thus use in a production environment
+should be done only after very careful testing.
+
+When doing a full backup, the Exchange database logs are truncated by
+Exchange as soon as the plugin has completed the backup. If the data
+never makes it to the backup medium (eg because of spooling) then the
+logs will still be truncated, but they will also not have been backed
+up. A solution to this is being worked on.
+
+The "Enable Circular Logging" option cannot be enabled or the plugin
will fail.
Exchange insists that a successful Full backup must have taken place if
(eg NTBACKUP) is backing up the Exchange database, especially if the
other backup application is truncating the log files.
+The Exchange plugin has not been tested with the {\bf Accurate} option, so
+we recommend either carefully testing or that you avoid this option for
+the current time.
+
+The Exchange plugin is not called during processing the bconsole {\bf
+estimate} command, and so anything that would be backed up by the plugin
+will not be added to the estimate total that is displayed.
-\section{libdbi framework}
+\section{libdbi Framework}
As a general guideline, Bacula has support for a few catalog database drivers
+(MySQL, PostgreSQL, SQLite)
coded natively by the Bacula team. With the libdbi implementation, which is a
Bacula driver that uses libdbi to access the catalog, we have an open field to
use many different kinds database engines following the needs of users.
You can download them and compile them on your system or install the packages
from your OS distribution.
+\section{Console Command Additions and Enhancements}
-\section{Display Autochanger Content}
+\subsection{Display Autochanger Content}
\index[general]{StatusSlots}
-The {\bf status slots storage=\lt{}storage-name\gt{}} command displays autochanger content.
+The {\bf status slots storage=\lt{}storage-name\gt{}} command displays
+autochanger content.
\footnotesize
\begin{verbatim}
{\bf update slots} command to synchronize autochanger content with your
catalog.
+\subsection{list joblog job=xxx or jobid=nnn}
+A new list command has been added that allows you to list the contents
+of the Job Log stored in the catalog for either a Job Name (fully qualified)
+or for a particular JobId. The {\bf llist} command will include a line with
+the time and date of the entry.
+
+Note for the catalog to have Job Log entries, you must have a directive
+such as:
+
+\begin{verbatim}
+ catalog = all
+\end{verbatim}
+
+In your Director's {\bf Messages} resource.
+
+
\section{Miscellaneous}
\index[general]{Misc New Features}
With this new command, Bacula will ask if you want to specify a Regex
expression for extracting only a part of the full backup.
+\subsection{Bootstrap File Optimization Changes}
+In order to permit proper seeking on disk files, we have extended the bootstrap
+file format to include a {\bf VolStartAddr} and {\bf VolEndAddr} records. Each
+takes a 64 bit unsigned integer range (i.e. nnn-mmm) which defines the start
+address range and end address range respectively. These two directives replace
+the {\bf VolStartFile}, {\bf VolEndFile}, {\bf VolStartBlock} and {\bf
+ VolEndBlock} directives. Bootstrap files containing the old directives will
+still work, but will not properly take advantage of proper disk seeking, and
+may read completely to the end of a disk volume during a restore. With the new
+format (automatically generated by the new Director), restores will seek
+properly and stop reading the volume when all the files have been restored.
+
+\subsection{Solaris ZFS/NFSv4 ACLs}
+This is an upgrade of the previous Solaris ACL backup code
+to the new library format, which will backup both the old
+POSIX(UFS) ACLs as well as the ZFS ACLs.
+
+The new code can also restore POSIX(UFS) ACLs to a ZFS filesystem
+(it will translate the POSIX(UFS)) ACL into a ZFS/NFSv4 one) it can also
+be used to transfer from UFS to ZFS filesystems.
+
\subsection{Virtual Tape Emulation}
We now have a Virtual Tape emulator that allows us to run though 99.9\% of
}
\end{verbatim}
-A new Client RunScript {\bf RunsWhen} keyword of {\bf AfterVSS} has been implemented, which
-runs the command after the Volume Shadow Copy has been made.
+A new Client RunScript {\bf RunsWhen} keyword of {\bf AfterVSS} has been
+implemented, which runs the command after the Volume Shadow Copy has been made.
Console commands can be specified within a RunScript by using:
{\bf Console = \lt{}command\gt{}}, however, this command has not been
be able to use them.
Now, you can use the \textbf{update stats [days=num]} console command to fill
-the JobStat table with new Job records. If you want to be sure to take in
+the JobHistory table with new Job records. If you want to be sure to take in
account only \textbf{good jobs}, ie if one of your important job has failed but
you have fixed the problem and restarted it on time, you probably want to
delete the first \textit{bad} job record and keep only the successful one. For
-that simply let your staff do the job, and update JobStat table after two or
+that simply let your staff do the job, and update JobHistory table after two or
three days depending on your organization using the \textbf{[days=num]} option.
These statistics records aren't used for restoring, but mainly for
The {\textbf Statistics Retention = \lt{}time\gt{}} director directive defines
the length of time that Bacula will keep statistics job records in the Catalog
-database after the Job End time. (In \texttt{JobStat} table) When this time
+database after the Job End time. (In \texttt{JobHistory} table) When this time
period expires, and if user runs \texttt{prune stats} command, Bacula will
prune (remove) Job records that are older than the specified period.
}
\end{verbatim}
+\subsection{ScratchPool = \lt{}pool-resource-name\gt{}}
+This directive permits to specify a dedicate \textsl{Scratch} pool for the
+current pool. This is useful when using multiple storage sharing the same
+mediatype or when you want to dedicate volumes to a particular set of pool.
+
+\subsection{Enhance attributes despooling}
+If the storage daemon and the director are on the same machine, the spool file
+that contains attributes is read directly by the director instead of being
+transmitted by the network. That should reduce load and speedup insertion.
+
\subsection{SpoolSize = \lt{}size-specification-in-bytes\gt{}}
A new job directive permits to specify the spool size per job. This is used
in advanced job tunning. {\bf SpoolSize={\it bytes}}
+\subsection{MaxConsoleConnections = \lt{}number\gt{}}
+A new director directive permits to specify the maximum number of Console
+Connections that could run concurrently. The default is set to 20, but you may
+set it to a larger number.
\section{Building Bacula Plugins}
There is currently one sample program {\bf example-plugin-fd.c} and
%%
\chapter{Bacula FD Plugin API}
-To write a Bacula plugin, you create a dynamic shared object
-program (or dll on Win32) with a particular name and two
-exported entry points, place it in the {\bf Plugins Directory}, which is defined in the
-{\bf bacula-fd.conf} file in the {\bf Client} resource, and when the FD
-starts, it will load all the plugins that end with {\bf -fd.so} (or {\bf -fd.dll}
-on Win32) found in that directory.
+To write a Bacula plugin, you create a dynamic shared object program (or dll on
+Win32) with a particular name and two exported entry points, place it in the
+{\bf Plugins Directory}, which is defined in the {\bf bacula-fd.conf} file in
+the {\bf Client} resource, and when the FD starts, it will load all the plugins
+that end with {\bf -fd.so} (or {\bf -fd.dll} on Win32) found in that directory.
\section{Normal vs Command Plugins}
-In general, there are two ways that plugins are called. The first way,
-is when a particular event is detected in Bacula, it will transfer control
-to each plugin that is loaded in turn informing the plugin of the event.
-This is very similar to how a {\bf RunScript} works, and the events are very similar.
-Once the plugin gets control, it can interact with Bacula by getting and
-setting Bacula variables. In this way, it behaves much like a RunScript.
-Currently very few Bacula variables are defined, but they will be implemented
-as the need arrises, and it is very extensible.
+In general, there are two ways that plugins are called. The first way, is when
+a particular event is detected in Bacula, it will transfer control to each
+plugin that is loaded in turn informing the plugin of the event. This is very
+similar to how a {\bf RunScript} works, and the events are very similar. Once
+the plugin gets control, it can interact with Bacula by getting and setting
+Bacula variables. In this way, it behaves much like a RunScript. Currently
+very few Bacula variables are defined, but they will be implemented as the need
+arrises, and it is very extensible.
We plan to have plugins register to receive events that they normally would
not receive, such as an event for each file examined for backup or restore.
This feature is not yet implemented.
-The second type of plugin, which is more useful and fully implemented
-in the current version is what we call a command plugin. As with all
-plugins, it gets notified of important events as noted above (details described below),
-but in addition, this kind of plugin can accept a command line, which
-is a:
+The second type of plugin, which is more useful and fully implemented in the
+current version is what we call a command plugin. As with all plugins, it gets
+notified of important events as noted above (details described below), but in
+addition, this kind of plugin can accept a command line, which is a:
\begin{verbatim}
Plugin = <command-string>
\end{verbatim}
directive that is placed in the Include section of a FileSet and is very
-similar to the "File = " directive. When this Plugin directive is encountered
+similar to the "File = " directive. When this Plugin directive is encountered
by Bacula during backup, it passes the "command" part of the Plugin directive
-only to the plugin that is explicitly named in the first field of that command string.
-This allows that plugin to backup any file or files on the system that it wants. It can
-even create "virtual files" in the catalog that contain data to be restored but do
-not necessarily correspond to actual files on the filesystem.
+only to the plugin that is explicitly named in the first field of that command
+string. This allows that plugin to backup any file or files on the system that
+it wants. It can even create "virtual files" in the catalog that contain data
+to be restored but do not necessarily correspond to actual files on the
+filesystem.
The important features of the command plugin entry points are:
\begin{itemize}
bRC unloadPlugin()
\end{verbatim}
-both these external entry points to the shared object are defined as C entry points
-to avoid name mangling complications with C++. However, the shared object
-can actually be written in any language (preferrably C or C++) providing that it
-follows C language calling conventions.
+both these external entry points to the shared object are defined as C entry
+points to avoid name mangling complications with C++. However, the shared
+object can actually be written in any language (preferrably C or C++) providing
+that it follows C language calling conventions.
The definitions for {\bf bRC} and the arguments are {\bf
src/filed/fd-plugins.h} and so this header file needs to be included in
#include <sys/stat.h>
\end{verbatim}
-Aside from the {\bf bc\_types.h} and {\bf confit.h} headers, the plugin definition uses the
-minimum code from Bacula. The bc\_types.h file is required to ensure that
-the data type defintions in arguments correspond to the Bacula core code.
+Aside from the {\bf bc\_types.h} and {\bf confit.h} headers, the plugin
+definition uses the minimum code from Bacula. The bc\_types.h file is required
+to ensure that the data type defintions in arguments correspond to the Bacula
+core code.
The return codes are defined as:
\begin{verbatim}
int type, time_t mtime, const char *fmt, ...);
bRC (*DebugMessage)(bpContext *ctx, const char *file, int line,
int level, const char *fmt, ...);
- void *(*malloc)(bpContext *ctx, const char *file, int line,
+ void *(*baculaMalloc)(bpContext *ctx, const char *file, int line,
size_t size);
- void (*free)(bpContext *ctx, const char *file, int line, void *mem);
+ void (*baculaFree)(bpContext *ctx, const char *file, int line, void *mem);
} bFuncs;
\end{verbatim}
\end{description}
During each of the above calls, the plugin receives either no specific value or
-only one value, which in some cases may not be sufficient. However, knowing the
-context of the event, the plugin can call back to the Bacula entry points it
-was passed during the {\bf loadPlugin} call and get to a number of Bacula variables.
-(at the current time few Bacula variables are implemented, but it easily extended
-at a future time and as needs require).
+only one value, which in some cases may not be sufficient. However, knowing
+the context of the event, the plugin can call back to the Bacula entry points
+it was passed during the {\bf loadPlugin} call and get to a number of Bacula
+variables. (at the current time few Bacula variables are implemented, but it
+easily extended at a future time and as needs require).
\subsection{startBackupFile(bpContext *ctx, struct save\_pkt *sp)}
This entry point is called only if your plugin is a command plugin, and
does not conflict with a real file on the system, and you need to
artifically create values in the statp packet.
-Example programs such as {\bf bpipe-fd.c} show how to set these fields.
-You must take care not to store pointers the stack in the pointer fields such
-as fname and link, because when you return from your function, your stack entries
-will be destroyed. The solution in that case is to malloc() and return the pointer
-to it. In order to not have memory leaks, you should store a pointer to all memory
-allocated in your pContext structure so that in subsequent calls or at termination,
-you can release it back to the system.
+Example programs such as {\bf bpipe-fd.c} show how to set these fields. You
+must take care not to store pointers the stack in the pointer fields such as
+fname and link, because when you return from your function, your stack entries
+will be destroyed. The solution in that case is to malloc() and return the
+pointer to it. In order to not have memory leaks, you should store a pointer to
+all memory allocated in your pContext structure so that in subsequent calls or
+at termination, you can release it back to the system.
Once the backup has begun, Bacula will call your plugin at the {\bf pluginIO}
entry point to "read" the data to be backed up. Please see the {\bf bpipe-fd.c}
\subsection{endBackupFile(bpContext *ctx)}
-Called at the end of backing up a file for a command plugin. If the plugin's work
-is done, it should return bRC\_OK. If the plugin wishes to create another
-file and back it up, then it must return bRC\_More (not yet implemented).
-This is probably a good time to release any malloc()ed memory you used to
-pass back filenames.
+Called at the end of backing up a file for a command plugin. If the plugin's
+work is done, it should return bRC\_OK. If the plugin wishes to create another
+file and back it up, then it must return bRC\_More (not yet implemented). This
+is probably a good time to release any malloc()ed memory you used to pass back
+filenames.
\subsection{startRestoreFile(bpContext *ctx, const char *cmd)}
Called when the first record is read from the Volume that was
Called when a command plugin is done restoring a file.
\subsection{pluginIO(bpContext *ctx, struct io\_pkt *io)}
-Called to do the input (backup) or output (restore) of data from or to a
-file for a command plugin. These routines simulate the Unix read(), write(), open(), close(),
-and lseek() I/O calls, and the arguments are passed in the packet and
-the return values are also placed in the packet. In addition for Win32
-systems the plugin must return two additional values (described below).
+Called to do the input (backup) or output (restore) of data from or to a file
+for a command plugin. These routines simulate the Unix read(), write(), open(),
+close(), and lseek() I/O calls, and the arguments are passed in the packet and
+the return values are also placed in the packet. In addition for Win32 systems
+the plugin must return two additional values (described below).
\begin{verbatim}
enum {
};
\end{verbatim}
-The particular Unix function being simulated is indicated by the {\bf func},
-which will have one of the IO\_OPEN, IO\_READ, ... codes listed above.
-The status code that would be returned from a Unix call is returned in
-{\bf status} for IO\_OPEN, IO\_CLOSE, IO\_READ, and IO\_WRITE. The return value for
-IO\_SEEK is returned in {\bf offset} which in general is a 64 bit value.
+The particular Unix function being simulated is indicated by the {\bf func},
+which will have one of the IO\_OPEN, IO\_READ, ... codes listed above. The
+status code that would be returned from a Unix call is returned in {\bf status}
+for IO\_OPEN, IO\_CLOSE, IO\_READ, and IO\_WRITE. The return value for IO\_SEEK
+is returned in {\bf offset} which in general is a 64 bit value.
When there is an error on Unix systems, you must always set io\_error, and
on a Win32 system, you must always set win32, and the returned value from
\end{description}
+\section{Bacula Plugin Entrypoints}
+When Bacula calls one of your plugin entrypoints, you can call back to
+the entrypoints in Bacula that were supplied during the xxx plugin call
+to get or set information within Bacula.
+
+\subsection{bRC registerBaculaEvents(bpContext *ctx, ...)}
+This Bacula entrypoint will allow you to register to receive events
+that are not autmatically passed to your plugin by default. This
+entrypoint currently is unimplemented.
+
+\subsection{bRC getBaculaValue(bpContext *ctx, bVariable var, void *value)}
+Calling this entrypoint, you can obtain specific values that are available
+in Bacula.
+
+\subsection{bRC setBaculaValue(bpContext *ctx, bVariable var, void *value)}
+Calling this entrypoint allows you to set particular values in
+Bacula.
+
+\subsection{bRC JobMessage(bpContext *ctx, const char *file, int line,
+ int type, time\_t mtime, const char *fmt, ...)}
+This call permits you to put a message in the Job Report.
+
+
+\subsection{bRC DebugMessage(bpContext *ctx, const char *file, int line,
+ int level, const char *fmt, ...)}
+This call permits you to print a debug message.
+
+
+\subsection{void baculaMalloc(bpContext *ctx, const char *file, int line,
+ size\_t size)}
+This call permits you to obtain memory from Bacula's memory allocator.
+
+\subsection{void baculaFree(bpContext *ctx, const char *file, int line, void *mem)}
+This call permits you to free memory obtained from Bacula's memory allocator.
projects / bacula / docs / blobdiff