Provided by: rdup_1.1.11-1build1_i386 bug

NAME

       rdup-backups - introduction into making backups with rdup

INTRODUCTION

       rdup  is  a  simple  program  that  prints  out  a  list  of  files and
       directories that are changed  changed  on  a  filesystem.  It  is  more
       sophisticated than for instance find, because rdup will find files that
       are removed or directories that are renamed.

       A long time ago rdup included a bunch of shell and  Perl  scripts  that
       implemented  a  backup  policy.  These  could  be used in a pipeline to
       perform a backup.

       Currently rdup consists out of three basic utilities:

       rdup   With rdup you create the file list on which  later  programs  in
              the  pipeline  can work. The default output format also includes
              the files' content. rdup can be seen as  a  tar  replacement  in
              this   respect,   but   rdup   also  allows  for  all  kinds  of
              transformations  of  the   content   (encryption,   compression,
              reversal), see the -P switch in rdup(1) for more information.

       rdup-tr
              With  rdup-tr  you can transform the files rdup delivers to you.
              You  can  create  tar,  cpio  or  pax  files.  You  can  encrypt
              pathnames.  rdup-tr is filter that reads from standard input and
              writes to standard output.  See rdup-tr(1) for more information.
              With  rdup and rdup-tr you can create an encrypted archive which
              is put in a directory structure that is also encrypted.

       rdup-up
              With rdup-up you can update an existing directory structure with
              the updates as described by rdup.

              rdup-up  reads  rdup  input  and will create the files, symbolic
              links, hard  links  and  directories  (and  sockets,  pipes  and
              devices)   in   the   file   system.  See  rdup-up(1)  for  more
              information.

       So the general backup pipeline for rdup will look something like this:

           create filelist  |  transform |  update filesystem
           ( rdup           |  rdup-tr   |  rdup-up )

       Note 1:
              The same sequence is used for restoring. In both cases you  want
              to  move files from location A to B. The only difference is that
              the transformation is reversed when you restore.

       Note 2:
              The use of rdup-tr is optional.

BACKUPS AND RESTORES

       For rdup there is no difference between backups and  restores.  If  you
       think about this for a minute you understand why.

       Making a backup means copying a list of files somewhere else. Restoring
       files is copying a list of files back to the place they came from. Same
       difference. So rdup can be used for both, if you did any transformation
       with rdup during the backup you just need to reverse  those  operations
       during the restore.

BACKUPS

       It  is always best to backup to another medium, be it a different local
       harddisk or a NFS/CIFS mounted filesystem.  You can  also  use  ssh  to
       store  file  on  a  remote  server,  ala rsync (although not as network
       efficient).

       If you backup to a local disk you can just as well use rsync  or  plain
       old  tar,  but if you store your files at somebody else's disk you will
       need encryption. This is where you go beyond rsync and rdup  comes  in.
       Rsync  cannot  do per-file encryption, sure you can encrypt the network
       traffic with ssh, but at the remote side your files are kept  in  plain
       view.          If  you  implement  remote backups, the easy route is to
       allow root access on the backup medium. If the backup runs without root
       access  the  created files will not have their original ownership.  For
       NFS this can be achieved by using no_root_squash,  for  ssh  you  could
       enable PermitRootLogin. Note that this may be a security risk.

SNAPSHOT BACKUPS

       We need a little help here in the form of the rdup-simple script.  Keep
       in mind that the following scripts can also be run  remotely  with  the
       help of ssh.

       The following script implements the algorithm of rdup-simple.

              #!/bin/bash
              # some tmp files are saved in ~/.rdup. This directory must exist
              DIR=/home     # what to backup
              BACKUP=/vol/backup
              TODAY=$(date +%Y%m/%d)
              LIST=~/.rdup/list-$HOSTNAME
              STAMP=~/.rdup/timestamp-$HOSTNAME

              # for remote backup, this has to run on the remote host!
              BUGBUG
              RET=$?

              case $RET in
                  2|*)
                   echo Error >&2
                   exit 1
                   ;;
                  1)
                   # full dump, remove file-list and time-stamp file
                   rm $LIST $STAMP
                   ;;
                  0)
                   # inc dump
                   # do nothing here
                   ;;
              esac
              # this is the place where you want to modify the command line
              # right now, nothing is translated we just use 'cat'
              rdup -N $STAMP -Pcat $LIST $DIR | rdup-up $BACKUP/$HOSTNAME/$TODAY

              # or do a remote backup
              #rdup -N $STAMP -Pcat $LIST $DIR | ssh root@remotehost \
              #    rdup-up $BACKUP/$HOSTNAME/$TODAY

LOCAL BACKUPS

       With  rdup-simple  you  can  easily create backups.  Backing up my home
       directory to a backup directory:

              rdup-simple ~ /vol/backup/$HOSTNAME

       This will create a backup in /vol/backup/$HOSTNAME/200705/15.  So  each
       day will have its own directory. Multiple sources are allowed, so:

              rdup-simple ~ /etc/ /var/lib /vol/backup/$HOSTNAME

       Will  backup  your  home  directory,  /etc  and  /var/lib to the backup
       location. Also if you need to compress your backup, simple add  a  '-z'
       switch:

              rdup-simple -z ~ /etc/ /var/lib /vol/backup/$HOSTNAME

REMOTE BACKUPS

       For a remote backup to work, both the sending machine and the receiving
       machine must have rdup installed. The currently implemented protocol is
       ssh.

       Dumping my homedir to the remote server:

              rdup-simple ~ ssh://miekg@remote/vol/backup/$HOSTNAME

       The  syntax  is  almost identical, only the destination starts with the
       magic string 'ssh://'. Compression and encryption are  just  as  easily
       enabled  as  with  a  local backup, just add '-z' and/or a '-k keyfile'
       argument:

              rdup-simple        -z         -k         'secret-file'         ~
              ssh://miekg@remote/vol/backup/$HOSTNAME

       Remember  though, that because of these advanced features (compression,
       encryption, etc, ...) the network transfer can never be as efficient as
       rsync.

ALSO SEE

       rdup(1), rdup-tr(1), rdup-up(1) and http://www.miek.nl/projects/rdup/