Man Linux: Main Page and Category List

bbackupquery. Example:

    .PP
           bbackupquery "list home-dirs" quit

           .PP Note that commands that contain spaces are enclosed in double
       quotes. If the quit command is omitted, after the preceding commands
       are completed, bbackupquery will enter interactive mode.

         .SH "OPTIONS"

           .PP

               .PP -q

                       Quiet. Suppresses status output while running.

                   .RE

                   .PP -c configfile

                           Use configfile instead of the default bbackupd.conf
               file. Can be a relative or full path.

                       .RE

                 .SH "COMMANDS"

                   .PP The commands that can be used in bbackupquery are
               listed below.

                     .PP help

                             Displays the basic help message, which gives
                   information about the commands available in bbackupquery.
                   Use the form help command to get help on a specific
                   command.

                         .RE

                         .PP quit

                                 End the session with the store server, and
                       quit bbackupquery.

                             .RE

                             .PP cd [options] directory-name

                                     Change directory. Options:

                                         .PP -d

                                                 consider deleted directories
                               for traversal

                                             .RE

                                             .PP -o

                                                     consider old versions of
                                   directories for traversal. This option
                                   should never be useful in a correctly
                                   formed store.

                                                 .RE
                                               .sp

                                         .RE

                                         .PP lcd local-directory-name

                                                 Change directory on the
                                       client machine. To list the contents of
                                       the local directory, type sh ls (on
                                       Unix-like machines).

                                             .RE

                                             .PP list [options]
                                       [directory-name]

                                                     The list (or its synonym
                                           ls) command lists the content of
                                           the current, or specified,
                                           directory. The options are as
                                           follows:

                                                         .PP -r

                                                                 recursively
                                               list all files

                                                             .RE

                                                             .PP -d

                                                                     list
                                                   deleted files and
                                                   directories

                                                                 .RE

                                                                 .PP -o

                                                                         list
                                                       old versions of files
                                                       and directories

                                                                     .RE

                                                                     .PP -I

                                                                             don't
                                                           display object IDs

                                                                         .RE

                                                                         .PP
                                                           -F

                                                                                 don't
                                                               display flags

                                                                             .RE

                                                                             .PP
                                                               -t

                                                                                     show
                                                                   file
                                                                   modification
                                                                   time (and
                                                                   attr mod
                                                                   time, if
                                                                   the object
                                                                   has
                                                                   attributes).

                                                                                 .RE

                                                                                 .PP
                                                                   -s

                                                                                         show
                                                                       file
                                                                       size in
                                                                       blocks
                                                                       used on
                                                                       server.
                                                                       Note
                                                                       that
                                                                       this is
                                                                       only a
                                                                       very
                                                                       approximate
                                                                       indication
                                                                       of
                                                                       local
                                                                       file
                                                                       size.

                                                                                     .RE
                                                                                   .sp

                                                                             .RE

                                                                             .PP
                                                                       ls
                                                                       [options]
                                                                       [directory-name]

                                                                                     Synonym
                                                                           for
                                                                           list.

                                                                                 .RE

                                                                                 .PP
                                                                           pwd

                                                                                         Print
                                                                               current
                                                                               directory,
                                                                               always
                                                                               relative
                                                                               to
                                                                               the
                                                                               backup
                                                                               store
                                                                               root.

                                                                                     .RE

                                                                                     .PP
                                                                               sh
                                                                               shell-command

                                                                                             Everything
                                                                                   after
                                                                                   the
                                                                                   sh
                                                                                   is
                                                                                   passed
                                                                                   to
                                                                                   a
                                                                                   shell
                                                                                   and
                                                                                   run.
                                                                                   All
                                                                                   output
                                                                                   from
                                                                                   the
                                                                                   command
                                                                                   is
                                                                                   displayed
                                                                                   in
                                                                                   the
                                                                                   client.

                                                                                             Example:
                                                                                   to
                                                                                   list
                                                                                   the
                                                                                   contents
                                                                                   of
                                                                                   the
                                                                                   current
                                                                                   directory
                                                                                   on
                                                                                   the
                                                                                   client
                                                                                   machine
                                                                                   type
                                                                                   sh
                                                                                   ls.

                                                                                         .RE

                                                                                         .PP
                                                                                   compare
                                                                                   -a

                                                                                             .RE

                                                                                             .PP
                                                                                       compare
                                                                                       -l
                                                                                       location-name

                                                                                                 .RE

                                                                                                 .PP
                                                                                           compare
                                                                                           store-dir-name
                                                                                           local-dir-name

                                                                                                         Compare
                                                                                               the
                                                                                               current
                                                                                               data
                                                                                               in
                                                                                               the
                                                                                               store
                                                                                               with
                                                                                               the
                                                                                               data
                                                                                               on
                                                                                               the
                                                                                               disc.
                                                                                               Please
                                                                                               note
                                                                                               that
                                                                                               all
                                                                                               the
                                                                                               data
                                                                                               will
                                                                                               be
                                                                                               downloaded
                                                                                               from
                                                                                               the
                                                                                               store,
                                                                                               so
                                                                                               this
                                                                                               can
                                                                                               be
                                                                                               a
                                                                                               very
                                                                                               lengthy
                                                                                               process
                                                                                               depending
                                                                                               on
                                                                                               the
                                                                                               size
                                                                                               of
                                                                                               the
                                                                                               store,
                                                                                               and
                                                                                               the
                                                                                               size
                                                                                               of
                                                                                               the
                                                                                               part
                                                                                               you
                                                                                               are
                                                                                               comparing.

                                                                                                         Options:

                                                                                                             .PP
                                                                                               -a

                                                                                                                     compare
                                                                                                   all
                                                                                                   locations.

                                                                                                                 .RE

                                                                                                                 .PP
                                                                                                   -l

                                                                                                                         compare
                                                                                                       one
                                                                                                       backup
                                                                                                       location
                                                                                                       as
                                                                                                       specified
                                                                                                       in
                                                                                                       the
                                                                                                       configuration
                                                                                                       file.
                                                                                                       This
                                                                                                       compares
                                                                                                       one
                                                                                                       of
                                                                                                       the
                                                                                                       top
                                                                                                       level
                                                                                                       store
                                                                                                       directories.

                                                                                                                     .RE

                                                                                                                     .PP
                                                                                                       -c

                                                                                                                             set
                                                                                                           return
                                                                                                           code.
                                                                                                           The
                                                                                                           return
                                                                                                           code
                                                                                                           is
                                                                                                           set
                                                                                                           to
                                                                                                           the
                                                                                                           following
                                                                                                           values,
                                                                                                           if
                                                                                                           quit
                                                                                                           is
                                                                                                           the
                                                                                                           next
                                                                                                           command.
                                                                                                           So,
                                                                                                           if
                                                                                                           another
                                                                                                           command
                                                                                                           is
                                                                                                           run
                                                                                                           after
                                                                                                           the
                                                                                                           compare,
                                                                                                           the
                                                                                                           return
                                                                                                           code
                                                                                                           will
                                                                                                           not
                                                                                                           refer
                                                                                                           to
                                                                                                           the
                                                                                                           compare.
                                                                                                           This
                                                                                                           option
                                                                                                           is
                                                                                                           very
                                                                                                           useful
                                                                                                           for
                                                                                                           automating
                                                                                                           compares.
                                                                                                           Return
                                                                                                           code
                                                                                                           values:

                                                                                                           o
                                                                                                                                       1
                                                                                                               --
                                                                                                               no
                                                                                                               differences
                                                                                                               were
                                                                                                               found

                                                                                                                                     .RE

                                                                                                               o
                                                                                                                                           2
                                                                                                                   --
                                                                                                                   differences
                                                                                                                   were
                                                                                                                   found

                                                                                                                                         .RE

                                                                                                                   o
                                                                                                                                               3
                                                                                                                       --
                                                                                                                       an
                                                                                                                       error
                                                                                                                       occured

                                                                                                                                             .RE
                                                                                                                                           .sp

                                                                                                                                     .RE
                                                                                                                                   .sp

                                                                                                                             .RE

                                                                                                                             .PP
                                                                                                                       get
                                                                                                                       object-filename
                                                                                                                       [local-filename]

                                                                                                                                 .RE

                                                                                                                                 .PP
                                                                                                                           get
                                                                                                                           -i
                                                                                                                           object-id
                                                                                                                           local-filename

                                                                                                                                         Gets
                                                                                                                               a
                                                                                                                               file
                                                                                                                               from
                                                                                                                               the
                                                                                                                               store.
                                                                                                                               Object
                                                                                                                               is
                                                                                                                               specified
                                                                                                                               as
                                                                                                                               the
                                                                                                                               filename
                                                                                                                               within
                                                                                                                               the
                                                                                                                               current
                                                                                                                               directory.
                                                                                                                               Local
                                                                                                                               filename
                                                                                                                               is
                                                                                                                               optional.
                                                                                                                               Ignores
                                                                                                                               old
                                                                                                                               and
                                                                                                                               deleted
                                                                                                                               files
                                                                                                                               when
                                                                                                                               searching
                                                                                                                               the
                                                                                                                               directory
                                                                                                                               for
                                                                                                                               the
                                                                                                                               file
                                                                                                                               to
                                                                                                                               retrieve.

                                                                                                                                         To
                                                                                                                               get
                                                                                                                               an
                                                                                                                               old
                                                                                                                               or
                                                                                                                               deleted
                                                                                                                               file,
                                                                                                                               use
                                                                                                                               the
                                                                                                                               -i
                                                                                                                               option
                                                                                                                               and
                                                                                                                               select
                                                                                                                               the
                                                                                                                               object
                                                                                                                               as
                                                                                                                               a
                                                                                                                               hex
                                                                                                                               object
                                                                                                                               ID
                                                                                                                               (first
                                                                                                                               column
                                                                                                                               in
                                                                                                                               listing).
                                                                                                                               The
                                                                                                                               local
                                                                                                                               filename
                                                                                                                               must
                                                                                                                               be
                                                                                                                               specified.

                                                                                                                                     .RE

                                                                                                                                     .PP
                                                                                                                               getobject
                                                                                                                               object-id
                                                                                                                               local-filename

                                                                                                                                             Gets
                                                                                                                                   the
                                                                                                                                   object
                                                                                                                                   specified
                                                                                                                                   by
                                                                                                                                   the
                                                                                                                                   object
                                                                                                                                   id
                                                                                                                                   (in
                                                                                                                                   hex)
                                                                                                                                   and
                                                                                                                                   stores
                                                                                                                                   the
                                                                                                                                   raw
                                                                                                                                   contents
                                                                                                                                   in
                                                                                                                                   the
                                                                                                                                   local
                                                                                                                                   file
                                                                                                                                   specified.
                                                                                                                                   Note:
                                                                                                                                   This
                                                                                                                                   is
                                                                                                                                   only
                                                                                                                                   useful
                                                                                                                                   for
                                                                                                                                   debugging
                                                                                                                                   as
                                                                                                                                   it
                                                                                                                                   does
                                                                                                                                   not
                                                                                                                                   decode
                                                                                                                                   files
                                                                                                                                   from
                                                                                                                                   the
                                                                                                                                   stored
                                                                                                                                   format,
                                                                                                                                   which
                                                                                                                                   is
                                                                                                                                   encrypted
                                                                                                                                   and
                                                                                                                                   compressed.

                                                                                                                                         .RE

                                                                                                                                         .PP
                                                                                                                                   restore
                                                                                                                                   [-d]
                                                                                                                                   directory-name
                                                                                                                                   local-directory-name

                                                                                                                                             .RE

                                                                                                                                             .PP
                                                                                                                                       restore
                                                                                                                                       -r

                                                                                                                                                     Restores
                                                                                                                                           a
                                                                                                                                           directory
                                                                                                                                           to
                                                                                                                                           the
                                                                                                                                           local
                                                                                                                                           disc.
                                                                                                                                           The
                                                                                                                                           local
                                                                                                                                           directory
                                                                                                                                           specified
                                                                                                                                           must
                                                                                                                                           not
                                                                                                                                           exist
                                                                                                                                           (unless
                                                                                                                                           a
                                                                                                                                           previous
                                                                                                                                           restore
                                                                                                                                           is
                                                                                                                                           being
                                                                                                                                           restarted).
                                                                                                                                           The
                                                                                                                                           root
                                                                                                                                           cannot
                                                                                                                                           be
                                                                                                                                           restored
                                                                                                                                           --
                                                                                                                                           restore
                                                                                                                                           locations
                                                                                                                                           individually.

                                                                                                                                                     Options:

                                                                                                                                                         .PP
                                                                                                                                           -d

                                                                                                                                                                 restore
                                                                                                                                               a
                                                                                                                                               deleted
                                                                                                                                               directory

                                                                                                                                                             .RE

                                                                                                                                                             .PP
                                                                                                                                               -r

                                                                                                                                                                     resume
                                                                                                                                                   an
                                                                                                                                                   interrupted
                                                                                                                                                   restore

                                                                                                                                                                 .RE
                                                                                                                                                               .sp
                                                                                                                                                   If
                                                                                                                                                   a
                                                                                                                                                   restore
                                                                                                                                                   operation
                                                                                                                                                   is
                                                                                                                                                   interrupted
                                                                                                                                                   for
                                                                                                                                                   any
                                                                                                                                                   reason,
                                                                                                                                                   it
                                                                                                                                                   can
                                                                                                                                                   be
                                                                                                                                                   restarted
                                                                                                                                                   using
                                                                                                                                                   the
                                                                                                                                                   -r
                                                                                                                                                   switch.
                                                                                                                                                   Restore
                                                                                                                                                   progress
                                                                                                                                                   information
                                                                                                                                                   is
                                                                                                                                                   saved
                                                                                                                                                   in
                                                                                                                                                   a
                                                                                                                                                   file
                                                                                                                                                   at
                                                                                                                                                   regular
                                                                                                                                                   intervals
                                                                                                                                                   during
                                                                                                                                                   the
                                                                                                                                                   restore
                                                                                                                                                   operation
                                                                                                                                                   to
                                                                                                                                                   allow
                                                                                                                                                   restarts.

                                                                                                                                                         .RE

                                                                                                                                                         .PP
                                                                                                                                                   usage
                                                                                                                                                   [-m]

                                                                                                                                                                 Show
                                                                                                                                                       space
                                                                                                                                                       used
                                                                                                                                                       on
                                                                                                                                                       the
                                                                                                                                                       server
                                                                                                                                                       for
                                                                                                                                                       this
                                                                                                                                                       account.
                                                                                                                                                       Display
                                                                                                                                                       fields:

                                                                                                                                                       o
                                                                                                                                                                           Used:
                                                                                                                                                           Total
                                                                                                                                                           amount
                                                                                                                                                           of
                                                                                                                                                           space
                                                                                                                                                           used
                                                                                                                                                           on
                                                                                                                                                           the
                                                                                                                                                           server

                                                                                                                                                                         .RE

                                                                                                                                                           o
                                                                                                                                                                               Old
                                                                                                                                                               files:
                                                                                                                                                               Space
                                                                                                                                                               used
                                                                                                                                                               by
                                                                                                                                                               old
                                                                                                                                                               files

                                                                                                                                                                             .RE

                                                                                                                                                               o
                                                                                                                                                                                   Deleted
                                                                                                                                                                   files:
                                                                                                                                                                   Space
                                                                                                                                                                   used
                                                                                                                                                                   by
                                                                                                                                                                   deleted
                                                                                                                                                                   files

                                                                                                                                                                                 .RE

                                                                                                                                                                   o
                                                                                                                                                                                       Directories:
                                                                                                                                                                       Space
                                                                                                                                                                       used
                                                                                                                                                                       by
                                                                                                                                                                       the
                                                                                                                                                                       directory
                                                                                                                                                                       structure

                                                                                                                                                                                     .RE
                                                                                                                                                                                   .sp

                                                                                                                                                                                 When
                                                                                                                                                                       Used
                                                                                                                                                                       exceeds
                                                                                                                                                                       the
                                                                                                                                                                       soft
                                                                                                                                                                       limit,
                                                                                                                                                                       the
                                                                                                                                                                       server
                                                                                                                                                                       will
                                                                                                                                                                       start
                                                                                                                                                                       to
                                                                                                                                                                       remove
                                                                                                                                                                       old
                                                                                                                                                                       and
                                                                                                                                                                       deleted
                                                                                                                                                                       files
                                                                                                                                                                       until
                                                                                                                                                                       the
                                                                                                                                                                       usage
                                                                                                                                                                       drops
                                                                                                                                                                       below
                                                                                                                                                                       the
                                                                                                                                                                       soft
                                                                                                                                                                       limit.
                                                                                                                                                                       After
                                                                                                                                                                       a
                                                                                                                                                                       while,
                                                                                                                                                                       you
                                                                                                                                                                       should
                                                                                                                                                                       expect
                                                                                                                                                                       to
                                                                                                                                                                       see
                                                                                                                                                                       the
                                                                                                                                                                       usage
                                                                                                                                                                       stay
                                                                                                                                                                       at
                                                                                                                                                                       just
                                                                                                                                                                       below
                                                                                                                                                                       the
                                                                                                                                                                       soft
                                                                                                                                                                       limit.
                                                                                                                                                                       You
                                                                                                                                                                       only
                                                                                                                                                                       need
                                                                                                                                                                       more
                                                                                                                                                                       space
                                                                                                                                                                       if
                                                                                                                                                                       the
                                                                                                                                                                       space
                                                                                                                                                                       used
                                                                                                                                                                       by
                                                                                                                                                                       old
                                                                                                                                                                       and
                                                                                                                                                                       deleted
                                                                                                                                                                       files
                                                                                                                                                                       is
                                                                                                                                                                       near
                                                                                                                                                                       zero.

                                                                                                                                                                                 The
                                                                                                                                                                       -m
                                                                                                                                                                       option
                                                                                                                                                                       displays
                                                                                                                                                                       output
                                                                                                                                                                       in
                                                                                                                                                                       machine-readable
                                                                                                                                                                       form.

                                                                                                                                                                             .RE

                                                                                                                                                                         .SH
                                                                                                                                                                       "BUGS"

                                                                                                                                                                           .PP
                                                                                                                                                                       If
                                                                                                                                                                       you
                                                                                                                                                                       find
                                                                                                                                                                       a
                                                                                                                                                                       bug
                                                                                                                                                                       in
                                                                                                                                                                       Box
                                                                                                                                                                       Backup
                                                                                                                                                                       and
                                                                                                                                                                       you
                                                                                                                                                                       want
                                                                                                                                                                       to
                                                                                                                                                                       let
                                                                                                                                                                       us
                                                                                                                                                                       know
                                                                                                                                                                       about
                                                                                                                                                                       it,
                                                                                                                                                                       join
                                                                                                                                                                       the
                                                                                                                                                                       mailing
                                                                                                                                                                       list[1]
                                                                                                                                                                       and
                                                                                                                                                                       send
                                                                                                                                                                       us
                                                                                                                                                                       a
                                                                                                                                                                       description
                                                                                                                                                                       of
                                                                                                                                                                       the
                                                                                                                                                                       problem
                                                                                                                                                                       there.

                                                                                                                                                                           .PP
                                                                                                                                                                       To
                                                                                                                                                                       report
                                                                                                                                                                       a
                                                                                                                                                                       bug,
                                                                                                                                                                       give
                                                                                                                                                                       us
                                                                                                                                                                       at
                                                                                                                                                                       least
                                                                                                                                                                       the
                                                                                                                                                                       following
                                                                                                                                                                       information:

                                                                                                                                                                       o
                                                                                                                                                                                   The
                                                                                                                                                                           version
                                                                                                                                                                           of
                                                                                                                                                                           Box
                                                                                                                                                                           Backup
                                                                                                                                                                           you
                                                                                                                                                                           are
                                                                                                                                                                           running

                                                                                                                                                                                 .RE

                                                                                                                                                                           o
                                                                                                                                                                                       The
                                                                                                                                                                               platform
                                                                                                                                                                               you
                                                                                                                                                                               are
                                                                                                                                                                               running
                                                                                                                                                                               on
                                                                                                                                                                               (hardware
                                                                                                                                                                               and
                                                                                                                                                                               OS),
                                                                                                                                                                               for
                                                                                                                                                                               both
                                                                                                                                                                               client
                                                                                                                                                                               and
                                                                                                                                                                               server.

                                                                                                                                                                                     .RE

                                                                                                                                                                               o
                                                                                                                                                                                           If
                                                                                                                                                                                   possible
                                                                                                                                                                                   attach
                                                                                                                                                                                   your
                                                                                                                                                                                   config
                                                                                                                                                                                   files
                                                                                                                                                                                   (bbstored.conf,
                                                                                                                                                                                   bbackupd.conf)
                                                                                                                                                                                   to
                                                                                                                                                                                   the
                                                                                                                                                                                   bug
                                                                                                                                                                                   report.

                                                                                                                                                                                         .RE

                                                                                                                                                                                   o
                                                                                                                                                                                               Also
                                                                                                                                                                                       attach
                                                                                                                                                                                       any
                                                                                                                                                                                       log
                                                                                                                                                                                       file
                                                                                                                                                                                       output
                                                                                                                                                                                       that
                                                                                                                                                                                       helps
                                                                                                                                                                                       shed
                                                                                                                                                                                       light
                                                                                                                                                                                       on
                                                                                                                                                                                       the
                                                                                                                                                                                       problem
                                                                                                                                                                                       you
                                                                                                                                                                                       are
                                                                                                                                                                                       seeing.

                                                                                                                                                                                             .RE

                                                                                                                                                                                       o
                                                                                                                                                                                                   And
                                                                                                                                                                                           last
                                                                                                                                                                                           but
                                                                                                                                                                                           certainly
                                                                                                                                                                                           not
                                                                                                                                                                                           least,
                                                                                                                                                                                           a
                                                                                                                                                                                           description
                                                                                                                                                                                           of
                                                                                                                                                                                           what
                                                                                                                                                                                           you
                                                                                                                                                                                           are
                                                                                                                                                                                           seeing,
                                                                                                                                                                                           in
                                                                                                                                                                                           as
                                                                                                                                                                                           much
                                                                                                                                                                                           detail
                                                                                                                                                                                           as
                                                                                                                                                                                           possible.

                                                                                                                                                                                                 .RE

                                                                                                                                                                                             .SH
                                                                                                                                                                                           "AUTHORS"

                                                                                                                                                                                               .PP
                                                                                                                                                                                           Ben
                                                                                                                                                                                           Summers

                                                                                                                                                                                               .PP
                                                                                                                                                                                           Per
                                                                                                                                                                                           Thomsen

                                                                                                                                                                                               .PP
                                                                                                                                                                                           James
                                                                                                                                                                                           O'Gorman

NOTES

        1. mailing list
           http://lists.warhead.org.uk/mailman/listinfo/boxbackup