Release 1.1.2.

[rsync-backup] / rsync-backup.in

diff --git a/rsync-backup.in b/rsync-backup.in
index 5c9a54cefff2570bd87ba48b8cebb010202e2390..a48d58ac368825959ade894986c3e9c2da889964 100644 (file)
--- a/rsync-backup.in
+++ b/rsync-backup.in
@@ -27,14 +27,10 @@ set -e
 
 thishost=$(hostname -s)
 quis=${0##*/}
 
 thishost=$(hostname -s)
 quis=${0##*/}

-
-VERSION=@VERSION@
-mntbkpdir=@mntbkpdir@
-logdir=@logdir@
-fshashdir=@fshashdir@
-conf=@sysconfdir@/rsync-backup.conf
+. @pkgdatadir@/lib.sh

 
 verbose=:
 
 verbose=:

+dryrun=nil

 
 ###--------------------------------------------------------------------------
 ### Utility functions.
 
 ###--------------------------------------------------------------------------
 ### Utility functions.


@@ -57,30 +53,82 @@ do_rsync () {
 }
 
 log () {
 }
 
 log () {

-  now=$(date +"%Y-%m-%d %H:%M:%S %z")
-  echo >&9 "$now $*"
+  case $dryrun in
+    t)
+      echo >&2 "               *** $*"
+      ;;
+    nil)
+      now=$(date +"%Y-%m-%d %H:%M:%S %z")
+      echo >&9 "$now $*"
+      ;;
+  esac
+}
+
+maybe () {
+  ## Run CMD, if this isn't a dry run.
+
+  case $dryrun in
+    t) echo >&2 "              +++ $*" ;;
+    nil) "$@" ;;
+  esac
+}
+
+copy () {
+  prefix=$1
+  ## Copy lines from stdin to stdout, adding PREFIX.
+
+  while IFS= read -r line; do
+    printf "%s %s\n" "$prefix" "$line"
+  done

 }
 
 run () {
 }
 
 run () {

+  stdinp=nil
+  while :; do
+    case $1 in
+      -stdin) stdinp=t; shift ;;
+      --) shift; break ;;
+      *) break ;;
+    esac
+  done

   tag=$1 cmd=$2; shift 2
   ## Run CMD, logging its output in a pleasing manner.
 
   tag=$1 cmd=$2; shift 2
   ## Run CMD, logging its output in a pleasing manner.
 

-  log "BEGIN $tag"
-  rc=$(
-    { { { ( set +e
-           "$cmd" "$@" 3>&- 4>&- 5>&- 9>&-
-           echo $? >&5; ) |
-         while IFS= read line; do echo "| $line"; done >&4; } 2>&1 |
-       while IFS= read line; do echo "* $line"; done >&4; } 4>&1 |
-      cat >&9; } 5>&1 </dev/null
-  )
-  case $rc in
-    0) log "END $tag" ;;
-    *) log "FAIL $tag (rc = $rc)" ;;
+  case $dryrun in
+    t)
+      echo >&2 "               *** RUN $tag"
+      echo >&2 "               +++ $cmd $*"
+      rc=0
+      ;;
+    nil)
+      log "BEGIN $tag"
+      rc=$(
+       case $stdinp in nil) exec </dev/null ;; esac
+       { { { ( set +e
+               "$cmd" "$@" 3>&- 4>&- 5>&- 9>&-
+               echo $? >&5; ) |
+             copy "|" >&4; } 2>&1 |
+           copy "*" >&4; } 4>&1 |
+         cat >&9; } 5>&1
+      )
+      case $rc in
+       0) log "END $tag" ;;
+       *) log "FAIL $tag (rc = $rc)" ;;
+      esac
+      ;;

   esac
   return $rc
 }
 
   esac
   return $rc
 }
 

+run_diff () {
+  out=$1 old=$2 new=$3
+  ## Write a unified diff from OLD to NEW, to OUT.
+
+  set +e; diff -u "$old" "$new" >"$out"; rc=$?; set -e
+  case $rc in 1) cat "$out" ;; esac
+  return $rc
+}
+

 localp () {
   h=$1
   ## Answer whether H is a local host.
 localp () {
   h=$1
   ## Answer whether H is a local host.


@@ -98,13 +146,13 @@ hostrun () {
   ## way it will be processed by a shell.
 
   if localp $host; then run "@$host: $tag" sh -c "$cmd"
   ## way it will be processed by a shell.
 
   if localp $host; then run "@$host: $tag" sh -c "$cmd"

-  else run "@$host: $tag" ssh $host "$cmd"
+  else run "@$host: $tag" ssh $userat$host "$cmd"

   fi
 }
 
 _hostrun () {
   h=$1 cmd=$2
   fi
 }
 
 _hostrun () {
   h=$1 cmd=$2

-  ## Like hostrun, but without the complicated logging, but targetted at a
+  ## Like hostrun, but without the complicated logging, and targetted at a

   ## specific host.
 
   if localp $h; then sh -c "$cmd"
   ## specific host.
 
   if localp $h; then sh -c "$cmd"


@@ -118,7 +166,81 @@ hostpath () {
   ## current host is local.
 
   if localp $host; then echo $path
   ## current host is local.
 
   if localp $host; then echo $path

-  else echo $host:$path
+  else echo $userat$host:$path
+  fi
+}
+
+defhook () {
+  hook=$1
+  ## Define a hook called HOOK.
+
+  eval hk_$hook=
+}
+
+addhook () {
+  hook=$1 cmd=$2
+  ## Add command CMD to the hook HOOK.
+
+  eval old=\$hk_$hook; new="$old $cmd"
+  eval hk_$hook=\$new
+}
+
+runhook () {
+  hook=$1; shift 1
+  ## Invoke HOOK, passing it the remaining arguments.
+
+  eval cmds=\$hk_$hook
+  for cmd in $cmds; do
+    if ! $cmd "$@"; then return $?; fi
+  done
+}
+
+remove_old_logfiles () {
+  base=$1
+  ## Remove old logfiles with names of the form BASE.DATE#N, so that there
+  ## are at most $MAXLOG of them.
+
+  ## Count up the logfiles.
+  nlog=0
+  for i in "$base".*; do
+    if [ ! -f "$i" ]; then continue; fi
+    nlog=$(( nlog + 1 ))
+  done
+
+  ## If there are too many, go through and delete some early ones.
+  if [ $dryrun = nil ] && [ $nlog -gt $MAXLOG ]; then
+    n=$(( nlog - MAXLOG ))
+    for i in "$base".*; do
+      if [ ! -f "$i" ]; then continue; fi
+      rm -f "$i"
+      n=$(( n - 1 ))
+      if [ $n -eq 0 ]; then break; fi
+    done
+  fi
+}
+
+###--------------------------------------------------------------------------
+### Database operations.
+
+insert_index () {
+  host=$1 fs=$2 date=$3 vol=$4
+
+  if [ -f "$INDEXDB" ]; then
+    sqlite3 "$INDEXDB" <<EOF
+INSERT INTO idx (host, fs, date, vol)
+       VALUES ('$host', '$fs', '$date', '$vol');
+EOF
+  fi
+}
+
+delete_index () {
+  host=$1 fs=$2 date=$3
+
+  if [ -f "$INDEXDB" ]; then
+    sqlite3 "$INDEXDB" <<EOF
+DELETE FROM idx WHERE
+       host = '$host' AND fs = '$fs' AND date = '$date';
+EOF

   fi
 }
 
   fi
 }
 


@@ -168,7 +290,6 @@ unsnap_ro () {
 ## Snapshot using LVM.
 
 SNAPSIZE="-l10%ORIGIN"
 ## Snapshot using LVM.
 
 SNAPSIZE="-l10%ORIGIN"

-SNAPDIR=@mntbkpdir@/snap

 
 snap_lvm () {
   vg=$1 lv=$2
 
 snap_lvm () {
   vg=$1 lv=$2


@@ -187,9 +308,21 @@ unsnap_lvm () {
   vg=$1 lv=$2
 
   ## Remove the snapshot.  Sometimes LVM doesn't notice that the snapshot is
   vg=$1 lv=$2
 
   ## Remove the snapshot.  Sometimes LVM doesn't notice that the snapshot is

-  ## no longer in open immdiately, so try several times.
+  ## no longer in open immdiately, so try several times.  Sometimes, more
+  ## mysteriously, something is keeping the filesystem from being unmounted,
+  ## so try that several times and report on things keeping the filesystem
+  ## open.

   hostrun "unsnap-lvm $vg/$lv" "
   hostrun "unsnap-lvm $vg/$lv" "

-       umount $SNAPDIR/$lv
+       for i in 1 2 3 4; do
+         echo \";;; BEGIN fuser -mv $SNAPDIR/$lv\"
+         fuser -mv $SNAPDIR/$lv | sed 's/^/;;; /'
+         echo \";;; END fuser -mv $SNAPDIR/$lv\"
+         echo \";;; BEGIN lsof $SNAPDIR/$lv\"
+         lsof $SNAPDIR/$lv | sed 's/^/;;; /'
+         echo \";;; END lsof $SNAPDIR/$lv\"
+         if umount $SNAPDIR/$lv; then break; fi
+         sleep 2
+       done

        rc=1
        for i in 1 2 3 4; do
          if lvremove -f $vg/$lv.bkp; then rc=0; break; fi
        rc=1
        for i in 1 2 3 4; do
          if lvremove -f $vg/$lv.bkp; then rc=0; break; fi


@@ -248,7 +381,7 @@ do_rfreezefs () {
 
     ## Get the volume host to create the snapshot.
     set +e
 
     ## Get the volume host to create the snapshot.
     set +e

-    _hostrun >&2 3>&- $lvhost \
+    _hostrun >&2 3>&- $userat$lvhost \

       "lvcreate --snapshot -n$lv.bkp $SNAPSIZE $vg/$lv"
     snaprc=$?
     set -e
       "lvcreate --snapshot -n$lv.bkp $SNAPSIZE $vg/$lv"
     snaprc=$?
     set -e


@@ -259,7 +392,7 @@ do_rfreezefs () {
     case $tok in
       "$tok_THAWED") ;;
       *)
     case $tok in
       "$tok_THAWED") ;;
       *)

-       _hostrun >&2 3>&- $lvhost "lvremove -f $vg/$lv.bkp" || :
+       _hostrun >&2 3>&- $userat$lvhost "lvremove -f $vg/$lv.bkp" || :

        echo >&2 "$quis: unexpected token $tok (rfreezefs $fsdir on $fshost)"
        exit 1
        ;;
        echo >&2 "$quis: unexpected token $tok (rfreezefs $fsdir on $fshost)"
        exit 1
        ;;


@@ -286,7 +419,7 @@ do_rfreezefs () {
   esac
 
   ## Mount the snapshot on the volume host.
   esac
 
   ## Mount the snapshot on the volume host.

-  _hostrun >&2 $lvhost "
+  _hostrun >&2 $userat$lvhost "

        mkdir -p $SNAPDIR/$lv
        mount -oro /dev/$vg/$lv.bkp $SNAPDIR/$lv"
 }
        mkdir -p $SNAPDIR/$lv
        mount -oro /dev/$vg/$lv.bkp $SNAPDIR/$lv"
 }


@@ -310,53 +443,6 @@ unsnap_rfreezefs () {
 ###--------------------------------------------------------------------------
 ### Expiry computations.
 
 ###--------------------------------------------------------------------------
 ### Expiry computations.
 

-parsedate () {
-  date=$1
-  ## Parse an ISO8601 DATE, and set YEAR, MONTH, DAY appropriately (and
-  ## without leading zeros).
-
-  ## Extract the components of the date and trim leading zeros (which will
-  ## cause things to be interpreted as octal and fail).
-  year=${date%%-*} rest=${date#*-}; month=${rest%%-*} day=${rest#*-}
-  year=${year#0} month=${month#0} day=${day#0}
-}
-
-julian () {
-  date=$1
-  ## Convert an ISO8601 DATE to a Julian Day Number.
-
-  parsedate $date
-
-  ## The actual calculation: convert a (proleptic) Gregorian calendar date
-  ## into a Julian day number.  This is taken from Wikipedia's page
-  ## http://en.wikipedia.org/wiki/Julian_day#Calculation but the commentary
-  ## is mine.  The epoch is 4713BC-01-01 (proleptic) Julian, or 4714BC-11-24
-  ## proleptic Gregorian.
-
-  ## If the MONTH is January or February then set a = 1, otherwise set a = 0.
-  a=$(( (14 - $month)/12 ))
-
-  ## Compute a year offset relative to 4799BC-03-01.  This puts the leap day
-  ## as the very last day in a year, which is very convenient.  The offset
-  ## here is sufficient to make all y values positive (within the range of
-  ## the JDN calendar), and is a multiple of 400, which is the Gregorian
-  ## cycle length.
-  y=$(( $year + 4800 - $a ))
-
-  ## Compute the offset month number in that year.  These months count from
-  ## zero, not one.
-  m=$(( $month + 12*$a - 3 ))
-
-  ## Now for the main event.  The (153 m + 2)/5 term is a surprising but
-  ## correct trick for obtaining the number of days in the first m months of
-  ## the (shifted) year).  The magic offset 32045 is what you get when you
-  ## plug the proper JDN epoch (year = -4713, month = 11, day = 24) into the
-  ## above machinery.
-  jdn=$(( $day + (153*$m + 2)/5 + 365*$y + $y/4 - $y/100 + $y/400 - 32045 ))
-
-  echo $jdn
-}
-

 expire () {
   ## Read dates on stdin; write to stdout `EXPIRE date' for dates which
   ## should be expired and `RETAIN date' for dates which should be retained.
 expire () {
   ## Read dates on stdin; write to stdout `EXPIRE date' for dates which
   ## should be expired and `RETAIN date' for dates which should be retained.


@@ -454,14 +540,29 @@ EOF
 ###--------------------------------------------------------------------------
 ### Actually taking backups of filesystems.
 
 ###--------------------------------------------------------------------------
 ### Actually taking backups of filesystems.
 

-STOREDIR=@mntbkpdir@/store

 MAXLOG=14
 HASH=sha256
 MAXLOG=14
 HASH=sha256

+unset VOLUME

 
 bkprc=0
 
 
 bkprc=0
 

+hash_file () {
+  file=$1
+
+  case $HASH in
+    md5 | sha1 | sha224 | sha256 | sha384 | sha512)
+      set -- $(${HASH}sum <"$file")
+      echo "$1"
+      ;;
+    *)
+      set -- $(openssl dgst -$HASH <"$file")
+      echo "$2"
+      ;;
+  esac
+}
+

 remote_fshash () {
 remote_fshash () {

-  _hostrun $host "
+  _hostrun $userat$host "

        umask 077
        mkdir -p $fshashdir
        cd ${snapmnt#*:}
        umask 077
        mkdir -p $fshashdir
        cd ${snapmnt#*:}


@@ -488,116 +589,281 @@ expire_backups () {
     done; } |
   expire |
   while read op date; do
     done; } |
   expire |
   while read op date; do

-    case $op in
-      RETAIN)
+    case $op,$dryrun in
+      RETAIN,t)
+       echo >&2 "              --- keep   $date"
+       ;;
+      EXPIRE,t)
+       echo >&2 "              --- delete $date"
+       ;;
+      RETAIN,nil)

        echo "keep   $date"
        ;;
        echo "keep   $date"
        ;;

-      EXPIRE)
+      EXPIRE,nil)

        echo "delete $date"
        $verbose -n "   expire $date..."
        rm -rf $date $date.*
        echo "delete $date"
        $verbose -n "   expire $date..."
        rm -rf $date $date.*

+       delete_index $host $fs $date

        $verbose " done"
        ;;
     esac
   done
 }
 
        $verbose " done"
        ;;
     esac
   done
 }
 

+## Backup hooks.
+defhook setup
+defhook precommit
+defhook postcommit
+

 backup_precommit_hook () {
   host=$1 fs=$2 date=$3
 backup_precommit_hook () {
   host=$1 fs=$2 date=$3

-  ## Override this hook in the configuration file for special effects.
+  ## Compatibility: You can override this hook in the configuration file for
+  ## special effects; but it's better to use `addhook precommit'.

 
   :
 }
 
   :
 }

+addhook precommit backup_precommit_hook

 
 backup_commit_hook () {
   host=$1 fs=$2 date=$3
 
 backup_commit_hook () {
   host=$1 fs=$2 date=$3

-  ## Override this hook in the configuration file for special effects.
+  ## Compatibility: You can override this hook in the configuration file for
+  ## special effects; but it's better to use `addhook commit'.

 
   :
 }
 
   :
 }

+addhook commit backup_commit_hook

 
 do_backup () {
   date=$1 fs=$2 fsarg=$3
   ## Back up FS on the current host.
 
   set -e
 
 do_backup () {
   date=$1 fs=$2 fsarg=$3
   ## Back up FS on the current host.
 
   set -e

+  attempt=0
+  fshash_diff=nil
+
+  ## Run a hook beforehand.
+  set +e; runhook setup $host $fs $date; rc=$?; set -e
+  case $? in
+    0) ;;
+    99) log "BACKUP of $host:$fs SKIPPED by hook"; return 0 ;;
+    *) log "BACKUP of $host:$fs FAILED (hook returns $?)"; return $? ;;
+  esac

 
   ## Report the start of this attempt.
   log "START BACKUP of $host:$fs"
 
 
   ## Report the start of this attempt.
   log "START BACKUP of $host:$fs"
 

-  ## Create and mount the remote snapshot.
-  snapmnt=$(snap_$snap $snapargs $fs $fsarg) || return $?
-  $verbose "   create snapshot"
+  ## Maybe we need to retry the backup.
+  while :; do

 
 

-  ## Build the list of hardlink sources.
-  linkdests=""
-  for i in $host $like; do
-    d=$STOREDIR/$i/$fs/last/
-    if [ -d $d ]; then linkdests="$linkdests --link-dest=$d"; fi
-  done
+    ## Rig checksum variables to mismatch unless they're set later.
+    hrfs=REMOTE hlfs=LOCAL

 
 

-  ## Copy files from the remote snapshot.
-  mkdir -p new/
-  $verbose -n "        running rsync..."
-  set +e
-  run "RSYNC of $host:$fs (snapshot on $snapmnt)" do_rsync \
-    $linkdests \
-    $rsyncargs \
-    $snapmnt/ new/
-  rc_rsync=$?
-  set -e
-  $verbose " done"
+    ## Create and mount the remote snapshot.
+    case $dryrun in
+      t)
+       maybe snap_$snap $fs $fsarg
+       snapmnt="<snapshot>"
+       ;;
+      nil)
+       snapmnt=$(snap_$snap $snapargs $fs $fsarg) || return $?
+       ;;
+    esac
+    $verbose " create snapshot"

 
 

-  ## Collect a map of the snapshot for verification purposes.
-  set +e
-  $verbose -n "        remote fshash..."
-  run "@$host: fshash $fs" remote_fshash
-  rc_fshash=$?
-  set -e
-  $verbose " done"
+    ## If we had a fshash-mismatch, then clear out the potentially stale
+    ## entries, both locally and remotely.
+    case $fshash_diff in
+      nil) ;;
+      *)
+       $verbose "      prune cache"
+       run -stdin "local prune fshash" \
+         fshash -u -c$STOREDIR/fshash.cache -H$HASH new/ <$fshash_diff
+       run -stdin "@$host: prune fshash" \
+         _hostrun $userat$host <$fshash_diff \
+         "fshash -u -c$fshashdir/$fs.bkp -H$HASH ${snapmnt#*:}"
+       ;;
+    esac

 
 

-  ## Remove the snapshot.
-  unsnap_$snap $snapargs $fs $fsarg
-  $verbose "   remove snapshot"
+    ## Build the list of hardlink sources.
+    linkdests=""
+    for i in $host $like; do
+      d=$STOREDIR/$i/$fs/last/
+      if [ -d $d ]; then linkdests="$linkdests --link-dest=$d"; fi
+    done

 
 

-  ## If we failed to copy, then give up.
-  case $rc_rsync:$rc_fshash in
-    0:0) ;;
-    0:*) return $rc_fshash ;;
-    *) return $rc_rsync ;;
-  esac
+    ## Copy files from the remote snapshot.
+    maybe mkdir -p new/
+    case $dryrun in
+      t) $verbose "    running rsync" ;;
+      nil) $verbose -n "       running rsync..." ;;
+    esac
+    set +e
+    run "RSYNC of $host:$fs (snapshot on $snapmnt)" do_rsync \
+      $linkdests \
+      $rsyncargs \
+      $snapmnt/ new/
+    rc_rsync=$?
+    set -e
+    case $dryrun in nil) $verbose " done" ;; esac
+
+    ## Collect a map of the snapshot for verification purposes.
+    set +e
+    case $dryrun in
+      t) $verbose "    remote fshash" ;;
+      nil) $verbose -n "       remote fshash..." ;;
+    esac
+    run "@$host: fshash $fs" remote_fshash
+    rc_fshash=$?
+    set -e
+    case $dryrun in
+      nil)
+       hrfs=$(hash_file "new.fshash")
+       log "remote fshash $HASH checksum: $hrfs"
+       $verbose " done"
+       ;;
+      t)
+       hrfs=UNSET
+       ;;
+    esac
+
+    ## Remove the snapshot.
+    maybe unsnap_$snap $snapargs $fs $fsarg
+    $verbose " remove snapshot"
+
+    ## If we failed to copy, then give up.
+    case $rc_rsync:$rc_fshash in
+      0:0) ;;
+      0:*) return $rc_fshash ;;
+      *) return $rc_rsync ;;
+    esac
+
+    ## Get a matching map of the files received.
+    maybe mkdir -m750 -p $STOREDIR/tmp/
+    localmap=$STOREDIR/tmp/fshash.$host.$fs.$date
+    case $dryrun in
+      t) $verbose "    local fshash" ;;
+      nil) $verbose -n "       local fshash..." ;;
+    esac
+    run "local fshash $host:$fs" local_fshash || return $?
+    case $dryrun in
+      nil)
+       hlfs=$(hash_file "$localmap")
+       log "local fshash $HASH checksum: $hlfs"
+       $verbose " done"
+       ;;
+      t)
+       hlfs=UNSET
+       ;;
+    esac
+
+    ## Compare the two maps.
+    set +e
+    fshash_diff=$STOREDIR/tmp/fshash-diff.$host.$fs.$date
+    run "compare fshash maps for $host:$fs" \
+      run_diff $fshash_diff new.fshash $localmap
+    rc_diff=$?
+    set -e
+    case $rc_diff in
+      0)
+       break
+       ;;
+      1)
+       if [ $attempt -ge $retry ]; then return $rc; fi
+       $verbose "      fshash mismatch; retrying"
+       attempt=$(( $attempt + 1 ))
+       ;;
+      *)
+       return $rc_diff
+       ;;
+    esac
+  done
+
+  ## Double-check the checksums.
+  if [ $hrfs != $hlfs ]; then
+    cat >&2 <<EOF
+$0: INTERNAL ERROR: fshash $HASH checksum mismatch -- aborting
+       remote fshash checksum = $hrfs
+       local fshash checksum = $hlfs
+EOF
+    exit 127
+  fi

 
 

-  ## Get a matching map of the files received.
-  mkdir -m750 -p $STOREDIR/tmp
-  localmap=$STOREDIR/tmp/fshash.$host.$fs.$date
-  $verbose -n "        local fshash..."
-  run "local fshash $host:$fs" local_fshash || return $?
-  $verbose " done"
-
-  ## Compare the two maps.
-  run "compare fshash maps for $host:$fs" \
-    diff -u new.fshash $localmap || return $?
-  rm -f $localmap
+  ## Glorious success.
+  maybe rm -f $localmap
+  case $fshash_diff in nil) ;; *) maybe rm -f $fshash_diff ;; esac

   $verbose "   fshash match"
 
   ## Commit this backup.
   $verbose "   fshash match"
 
   ## Commit this backup.

-  backup_precommit_hook $host $fs $date
-  mv new $date
-  mv new.fshash $date.fshash
-  backup_commit_hook $host $fs $date
-  mkdir hack
-  ln -s $date hack/last
-  mv hack/last .
-  rmdir hack
+  case $dryrun in
+    nil)
+      runhook precommit $host $fs $date
+      mv new $date
+      mv new.fshash $date.fshash
+      insert_index $host $fs $date $VOLUME
+      runhook commit $host $fs $date
+      mkdir hack
+      ln -s $date hack/last
+      mv hack/last .
+      rmdir hack
+      ;;
+  esac

   $verbose "   commit"
 
   ## Expire old backups.
   $verbose "   commit"
 
   ## Expire old backups.

-  case "${expire_policy+t}" in
-    t) run "expiry for $host:$fs" expire_backups ;;
+  case "${expire_policy+t},${default_policy+t}" in
+    ,t) expire_policy=$default_policy ;;
+  esac
+  case "${expire_policy+t},$dryrun" in
+    t,nil) run "expiry for $host:$fs" expire_backups ;;
+    t,t) expire_backups ;;

   esac
   esac

+  clear_policy=t

 
   ## Report success.
 
   ## Report success.

-  log "SUCCESSFUL BACKUP of $host:$fs"
+  case $dryrun in
+    t) log "END BACKUP of $host:$fs" ;;
+    nil) log "SUCCESSFUL BACKUP of $host:$fs" ;;
+  esac
+}
+
+run_backup_cmd () {
+  fs=$1 date=$2 cmd=$3; shift 3
+  ## try_backup FS DATE COMMAND ARGS ...
+  ##
+  ## Run COMMAND ARGS to back up filesystem FS on the current host,
+  ## maintaining a log, and checking whether it worked.  The caller has
+  ## usually worked out the DATE in order to set up the filesystem, and we
+  ## need it to name the log file properly.
+
+  ## Find a name for the log file.  In unusual circumstances, we may have
+  ## deleted old logs from today, so just checking for an unused sequence
+  ## number is insufficient.  Instead, check all of the logfiles for today,
+  ## and use a sequence number that's larger than any of them.
+  case $dryrun in
+    t)
+      log=/dev/null
+      ;;
+    nil)
+      seq=1
+      for i in "$logdir/$host/$fs.$date#"*; do
+       tail=${i##*#}
+       case "$tail" in [!1-9]* | *[!0-9]*) continue ;; esac
+       if [ -f "$i" -a $tail -ge $seq ]; then seq=$(( tail + 1 )); fi
+      done
+      log="$logdir/$host/$fs.$date#$seq"
+      ;;
+  esac
+
+  ## Run the backup command.
+  case $dryrun in nil) mkdir -p $logdir/$host ;; esac
+  if ! "$cmd" "$@" 9>$log 1>&9; then
+    echo >&2
+    echo >&2 "$quis: backup of $host:$fs FAILED!"
+    bkprc=1
+  fi
+
+  ## Clear away any old logfiles.
+  remove_old_logfiles "$logdir/$host/$fs"

 }
 
 backup () {
 }
 
 backup () {


@@ -606,6 +872,21 @@ backup () {
   ## Back up the filesystems on the currently selected host using the
   ## currently selected snapshot type.
 
   ## Back up the filesystems on the currently selected host using the
   ## currently selected snapshot type.
 

+  ## Make sure that there's a store volume.  We must do this here rather than
+  ## in the main body of the script, since the configuration file needs a
+  ## chance to override STOREDIR.
+  if ! [ -r $STOREDIR/.rsync-backup-store ]; then
+    echo >&2 "$quis: no backup volume mounted"
+    exit 15
+  fi
+
+  ## Read the volume name if we don't have one already.  Again, this allows
+  ## the configuration file to provide a volume name.
+  case "${VOLUME+t}${VOLUME-nil}" in
+    nil) VOLUME=$(cat $METADIR/volume) ;;
+  esac
+
+  ## Back up each requested file system in turn.

   for fs in "$@"; do
 
     ## Parse the argument.
   for fs in "$@"; do
 
     ## Parse the argument.


@@ -617,72 +898,61 @@ backup () {
 
     ## Move to the store directory and set up somewhere to put this backup.
     cd $STOREDIR
 
     ## Move to the store directory and set up somewhere to put this backup.
     cd $STOREDIR

-    if [ ! -d $host ]; then
-      mkdir -m755 $host
-      chown root:root $host
-    fi
-    if [ ! -d $host/$fs ]; then
-      mkdir -m750 $host/$fs
-      chown root:backup $host/$fs
-    fi
+    case $dryrun in
+      nil)
+       if [ ! -d $host ]; then
+         mkdir -m755 $host
+         chown root:root $host
+       fi
+       if [ ! -d $host/$fs ]; then
+         mkdir -m750 $host/$fs
+         chown root:backup $host/$fs
+       fi
+       ;;
+    esac

     cd $host/$fs
 
     ## Find out if we've already copied this filesystem today.
     date=$(date +%Y-%m-%d)
     cd $host/$fs
 
     ## Find out if we've already copied this filesystem today.
     date=$(date +%Y-%m-%d)

-    if [ -d $date ]; then
+    if [ $dryrun = nil ] && [ -d $date ]; then

       $verbose "       already dumped"
       continue
     fi
 
       $verbose "       already dumped"
       continue
     fi
 

-    ## Find a name for the log file.  In unusual circumstances, we may have
-    ## deleted old logs from today, so just checking for an unused sequence
-    ## number is insufficient.  Instead, check all of the logfiles for today,
-    ## and use a sequence number that's larger than any of them.
-    seq=1
-    for i in "$logdir/$host/$fs.$date#"*; do
-      tail=${i##*#}
-      case "$tail" in [!1-9]* | *[!0-9]*) continue ;; esac
-      if [ -f "$i" -a $tail -ge $seq ]; then seq=$(( tail + 1 )); fi
-    done
-    log="$logdir/$host/$fs.$date#$seq"
-

     ## Do the backup of this filesystem.
     ## Do the backup of this filesystem.

-    mkdir -p $logdir/$host
-    if ! do_backup $date $fs $fsarg 9>$log 1>&9; then
-      echo >&2
-      echo >&2 "$quis: backup of $host:$fs FAILED!"
-      bkprc=1
-    fi
-
-    ## Count up the logfiles.
-    nlog=0
-    for i in "$logdir/$host/$fs".*; do
-      if [ ! -f "$i" ]; then continue; fi
-      nlog=$(( nlog + 1 ))
-    done
-
-    ## If there are too many, go through and delete some early ones.
-    if [ $nlog -gt $MAXLOG ]; then
-      n=$(( nlog - MAXLOG ))
-      for i in "$logdir/$host/$fs".*; do
-       if [ ! -f "$i" ]; then continue; fi
-       rm -f "$i"
-       n=$(( n - 1 ))
-       if [ $n -eq 0 ]; then break; fi
-      done
-    fi
+    run_backup_cmd $fs $date do_backup $date $fs $fsarg

   done
 }
 
 ###--------------------------------------------------------------------------
 ### Configuration functions.
 
   done
 }
 
 ###--------------------------------------------------------------------------
 ### Configuration functions.
 

-host () { host=$1; like=; $verbose "host $host"; }
-snaptype () { snap=$1; shift; snapargs="$*"; }
+defhook start
+defhook end
+
+done_first_host_p=nil
+
+host () {
+  host=$1
+  like= userat=
+  case $done_first_host_p in
+    nil) runhook start; done_first_host_p=t ;;
+  esac
+  case "${expire_policy+t},${default_policy+t}" in
+    t,) default_policy=$expire_policy ;;
+  esac
+  unset expire_policy
+  $verbose "host $host"
+}
+
+snaptype () { snap=$1; shift; snapargs="$*"; retry=1; }

 rsyncargs () { rsyncargs="$*"; }
 like () { like="$*"; }
 rsyncargs () { rsyncargs="$*"; }
 like () { like="$*"; }

+retry () { retry="$*"; }
+user () { userat="$*@"; }

 
 retain () {
 
 retain () {

+  case $clear_policy in t) unset expire_policy; clear_policy=nil ;; esac

   expire_policy="${expire_policy+$expire_policy
 }$*"
 }
   expire_policy="${expire_policy+$expire_policy
 }$*"
 }


@@ -691,31 +961,22 @@ retain () {
 ### Read the configuration and we're done.
 
 usage () {
 ### Read the configuration and we're done.
 
 usage () {

-  echo "usage: $quis [-v] [-c CONF]"
+  echo "usage: $quis [-nv] [-c CONF]"

 }
 
 version () {
   echo "$quis version $VERSION"
 }
 
 }
 
 version () {
   echo "$quis version $VERSION"
 }
 

-config () {
-  echo
-  cat <<EOF
-conf = $conf
-mntbkpdir = $mntbkpdir
-fshashdir = $fshashdir
-logdir = $logdir
-EOF
-}
-

 whine () { echo >&8 "$@"; }
 
 whine () { echo >&8 "$@"; }
 

-while getopts "hVvc:" opt; do
+while getopts "hVvc:n" opt; do

   case "$opt" in
     h) usage; exit 0 ;;
     V) version; config; exit 0 ;;
     v) verbose=whine ;;
     c) conf=$OPTARG ;;
   case "$opt" in
     h) usage; exit 0 ;;
     V) version; config; exit 0 ;;
     v) verbose=whine ;;
     c) conf=$OPTARG ;;

+    n) dryrun=t ;;

     *) exit 1 ;;
   esac
 done
     *) exit 1 ;;
   esac
 done


@@ -725,6 +986,12 @@ exec 8>&1
 
 . "$conf"
 
 
 . "$conf"
 

+runhook end $bkprc
+case "$bkprc" in
+  0) $verbose "All backups successful" ;;
+  *) $verbose "Backups FAILED" ;;
+esac
+

 ###----- That's all, folks --------------------------------------------------
 
 exit $bkprc
 ###----- That's all, folks --------------------------------------------------
 
 exit $bkprc