update: rename deploy_zones -> reload_zones; move related do_* from lib/update.updates -> lib/update.operations where they belong
#!/bin/bash
## vim: set ft=sh :
#
# Operations on zonefiles/hosts/whatever
## Hosts
## Update hosts from verbatim from input zone data:
#
# copy_hosts $ZONES/$zone $DATA/$base
#
# Writes updated zone to $zone, deps on $base.
function copy_hosts {
local zone=$1
local base=$2
if check_update $zone $base; then
log_update "Copying hosts $zone <- $base..."
do_update $zone \
cat $ROOT/$base
else
log_skip "Copying hosts $zone <- $base: not changed"
fi
}
## Generate hosts from input zone data using $BIN/process-zone:
#
# update_hosts $ZONES/$zone $DATA/$base
#
# Writes process-zone'd data to $zone, deps on $base.
function update_hosts {
local zone=$1; shift
local base=$1; shift
if check_update $zone $base; then
log_update "Generating hosts $zone <- $base..."
do_update $zone \
$BIN/process-zone $PROCESS_ARGS $ROOT/$base "$@"
else
log_skip "Generating hosts $zone <- $base: not changed"
fi
}
## Update .serial number:
#
# do_update_serial $serial
#
# Shows old/new serial on debug.
function do_update_serial {
local serial=$1
# read
local old=$(test -e $ROOT/$serial && cat $ROOT/$serial || echo '')
cmd $BIN/update-serial $ROOT/$serial
# read
local new=$(cat $ROOT/$serial)
debug " $old -> $new"
}
## Generate new serial for zone using $BIN/update-serial, if the zone data has changed:
#
# update_serial $zone $deps...
#
# Supports SERIAL_FORCE/NOOP.
# Updates $SERIALS/$zone.serial.
function update_serial {
local zone=$1; shift
local serial=$SERIALS/$zone.serial
# test
if [ $SERIAL_FORCE ]; then
log_force "Updating $serial: forced"
do_update_serial $serial
elif ! check_update $serial "$@"; then
log_skip "Updating $serial: not changed"
elif [ $SERIAL_NOOP ]; then
log_noop "Updating $serial: skipped"
else
log_update "Updating $serial..."
do_update_serial $serial
fi
}
## Link serial for zone from given base-zone:
#
# link_serial $zone $base
function link_serial {
local zone=$1
local base=$2
local lnk=$SERIALS/$zone.serial
local tgt=$SERIALS/$base.serial
if check_link $lnk $tgt; then
log_update "Linking $lnk -> $tgt..."
do_link $lnk $tgt
else
log_skip "Linking $lnk -> $tgt: not changed"
fi
}
## Update zone file verbatim from source:
#
# copy_zone $view $zone [$base]
#
# Copies changed $DATA/$base zone data to $ZONES/$view/$zone.
function copy_zone {
local view=$1
local zone=$2
local base=${3:-$zone}
local out=$ZONES/$view/$zone
local src=$DATA/$base
if check_update $out $src; then
log_update "Copying $out <- $src..."
do_update $out \
cat $ROOT/$src
else
log_skip "Copying $out <- $src: not changed"
fi
}
## Expand zone file from source using $BIN/expand-zone:
#
# update_zone $view $zone [$base]
#
# Processed $DATA/$base zone data through $BIN/expand-zone, writing output to $ZONES/$view/$zone.
function update_zone {
local view=$1
local zone=$2
local base=${3:-$zone}
local out=$ZONES/$view/$zone
local src=$DATA/$base.zone
local lnk=$ZONES/$base
local serial=$SERIALS/$base.serial
if check_update $out $src $serial; then
log_update "Generating $out <- $src..."
do_update $out \
$BIN/expand-zone $ROOT/$src \
--serial $ROOT/$serial \
--expand zones=$(abspath $ZONES) \
--expand view=$view
else
log_skip "Generating $out <- $src: not changed"
fi
}
## Link zone file to ues given shared zone.
#
# link_zone $view $zone [$base]
#
# Looks for shared zone at:
# $ZONES/$view/$base
# $ZONES/common/$base
function link_zone {
local view=$1
local zone=$2
local base=${3:-$zone}
local out=$ZONES/$view/$zone
local tgt=$(choose_link $out $ZONES/$view/$base $ZONES/common/$base)
if check_link $out $tgt; then
log_update "Linking $out -> $tgt..."
do_link $out $tgt
else
log_skip "Linking $out -> $tgt: not changed"
fi
}
## Test hosts zone for validity:
#
# check_hosts $DATA/$hosts --check-exempt ...
#
# Fails if the check fails.
function check_hosts {
local hosts=$1; shift 1
local cmd=($BIN/process-zone $PROCESS_ARGS $ROOT/$hosts --check-hosts "$@")
if "${cmd[@]}" -q; then
log_skip "Check $hosts: OK"
else
log_error " Check $hosts: Failed"
indent " " "${cmd[@]}"
exit 1
fi
}
## Test zone file for validity using named-checkzone:
#
# check_zone $view $zone $origin
#
# Uses the zonefile at $ZONES/$view/$zone, loading it with given initial $ORIGIN.
# Fails if the check fails.
function check_zone {
local view=$1
local zone=$2
local origin=$3
local src=$ZONES/$view/$zone
local cmd=($NAMED_CHECKZONE $origin $ROOT/$src)
# test
# XXX: checkzone is very specific about the order of arguments, -q must be first
if $NAMED_CHECKZONE -q $origin $ROOT/$src; then
log_skip "Check $src ($origin): OK"
else
log_error " Check $src ($origin): Failed:"
indent " " "${cmd[@]}"
exit 1
fi
}
# Run rndc reload
function do_reload {
# run
indent " rndc: " \
$RNDC reload
}
## Load update zonefiles into bind:
#
# reload_zones
#
# Invokes `rndc reload`, showing its output.
function reload_zones {
local msg="Reload zones"
if [ $RELOAD_FORCE ]; then
log_force "$msg..."
do_reload
elif [ $RELOAD_NOOP ]; then
log_noop "$msg: skipped"
elif [ ! -r $RNDC_KEY ]; then
log_error " $msg: rndc: permission denied: $RNDC_KEY"
return 1
else
log_update "$msg..."
# run
do_reload
fi
}
## Perform `hg commit` for $DATA
function do_commit {
local msg=$1
[ $LOG_DIFF ] && indent " " hg_diff
hg_commit "$msg"
}
## Commit changes in $DATA to version control:
#
# commit_data
#
# Invokes `hg commit` in the $REPO, first showing the diff.
function commit_data {
local repo=$REPO
local commit_msg="$COMMIT_MSG"
local msg="Commit changes in $repo"
# operate?
if [ $COMMIT_FORCE ]; then
log_force "$msg..."
do_commit "$commit_msg"
elif ! hg_modified; then
log_skip "$msg: no changes"
elif [ $COMMIT_SKIP ]; then
log_noop "$msg: skipped"
# still show diff, though
[ $LOG_DIFF ] && indent " " hg_diff
else
log_update "$msg..."
do_commit "$commit_msg"
fi
}