1

#!/bin/bash

     2

## vim: set ft=sh :

     3

#

     4

# Operations on zonefiles/hosts/whatever

     5

     6

## Hosts

     7

## Update hosts from verbatim from input zone data:

     8

#

     9

#   copy_hosts      $ZONES/$zone    $DATA/$base

    10

#

    11

# Writes updated zone to $zone, deps on $base.

    12

function copy_hosts {

    13

    local zone=$1

    14

    local base=$2

    15

    16

    if check_update $zone $base; then

    17

        log_update "Copying hosts $zone <- $base..."

    18

    19

        do_update $zone \

    20

            cat $ROOT/$base

    21

    else

    22

        log_skip "Copying hosts $zone <- $base: not changed"

    23

    fi

    24

}

    25

    26

## Generate hosts from input zone data using $BIN/process-zone:

    27

#

    28

#   update_hosts    $ZONES/$zone    $DATA/$base

    29

#

    30

# Writes process-zone'd data to $zone, deps on $base.

    31

function update_hosts {

    32

    local zone=$1; shift

    33

    local base=$1; shift

    34

    35

    if check_update $zone $base; then

    36

        log_update "Generating hosts $zone <- $base..."

    37

    38

        do_update $zone \

    39

            $BIN/process-zone $PROCESS_ARGS $ROOT/$base "$@"

    40

    else

    41

        log_skip "Generating hosts $zone <- $base: not changed"

    42

    fi

    43

}

    44

    66

## Generate new serial for zone using $BIN/update-serial, if the zone data has changed:

    67

#

    68

#   update_serial   $zone   $deps...

    69

#

    70

# Supports SERIAL_FORCE/NOOP.

    71

# Updates $SERIALS/$zone.serial.

    72

function update_serial {

    73

    local zone=$1; shift

    74

    75

    local serial=$SERIALS/$zone.serial

    76

    77

    # test

    78

    if [ $SERIAL_FORCE ]; then

    79

        log_force "Updating $serial: forced"

    80

    81

        do_update_serial $serial

    82

    83

    elif ! check_update $serial "$@"; then

    84

        log_skip "Updating $serial: not changed"

    85

    86

    elif [ $SERIAL_NOOP ]; then

    87

        log_noop "Updating $serial: skipped"

    88

    89

    else

    90

        log_update "Updating $serial..."

    91

    92

        do_update_serial $serial

    93

    fi

    94

}

    95

    96

## Link serial for zone from given base-zone:

    97

#

    98

#   link_serial $zone $base

    99

function link_serial {

   100

    local zone=$1

   101

    local base=$2

   102

   103

    local lnk=$SERIALS/$zone.serial

   104

    local tgt=$SERIALS/$base.serial

   105

   106

    if check_link $lnk $tgt; then

   107

        log_update "Linking $lnk -> $tgt..."

   108

   109

        do_link $lnk $tgt

   110

   111

    else

   112

        log_skip "Linking $lnk -> $tgt: not changed"

   113

    fi

   114

}

   115

   116

## Update zone file verbatim from source:

   117

#

   118

#   copy_zone   $view   $zone   [$base]

   119

#

   120

# Copies changed $DATA/$base zone data to $ZONES/$view/$zone.

   121

function copy_zone {

   122

    local view=$1

   123

    local zone=$2

   124

    local base=${3:-$zone}

   125

   126

    local out=$ZONES/$view/$zone

   127

    local src=$DATA/$base

   128

   129

    if check_update $out $src; then

   130

        log_update "Copying $out <- $src..."

   131

   132

        do_update $out \

   133

            cat $ROOT/$src

   134

    else

   135

        log_skip "Copying $out <- $src: not changed"

   136

    fi

   137

}

   138

   139

## Expand zone file from source using $BIN/expand-zone:

   140

#

   141

#   update_zone $view   $zone   [$base]

   142

#

   143

# Processed $DATA/$base zone data through $BIN/expand-zone, writing output to $ZONES/$view/$zone.

   144

function update_zone {

   145

    local view=$1

   146

    local zone=$2

   147

    local base=${3:-$zone}

   148

   149

    local out=$ZONES/$view/$zone

   150

    local src=$DATA/$base.zone

   151

    local lnk=$ZONES/$base

   152

   153

    local serial=$SERIALS/$base.serial

   154

   155

    if check_update $out $src $serial; then

   156

        log_update "Generating $out <- $src..." 

   157

   158

        do_update $out \

   159

            $BIN/expand-zone $ROOT/$src \

   160

                --serial $ROOT/$serial              \

   161

                --expand zones=$(abspath $ZONES)    \

   162

                --expand view=$view

   163

    else

   164

        log_skip "Generating $out <- $src: not changed" 

   165

    fi

   166

}

   167

   168

## Link zone file to ues given shared zone.

   169

#

   170

#   link_zone   $view   $zone   [$base]

   171

#

   172

# Looks for shared zone at:

   173

#   $ZONES/$view/$base

   174

#   $ZONES/common/$base

   175

function link_zone {

   176

    local view=$1

   177

    local zone=$2

   178

    local base=${3:-$zone}

   179

   180

    local out=$ZONES/$view/$zone

   181

    local tgt=$(choose_link $out $ZONES/$view/$base $ZONES/common/$base)

   182

   183

    if check_link $out $tgt; then

   184

        log_update "Linking $out -> $tgt..."

   185

   186

        do_link $out $tgt

   187

   188

    else

   189

        log_skip "Linking $out -> $tgt: not changed"

   190

    fi

   191

}

   192

   193

## Test hosts zone for validity:

   194

#

   195

#   check_hosts     $DATA/$hosts    --check-exempt ...

   196

#

   197

# Fails if the check fails.

   198

function check_hosts {

   199

    local hosts=$1; shift 1

   200

   201

    local cmd=($BIN/process-zone $PROCESS_ARGS $ROOT/$hosts --check-hosts "$@")

   202

   203

    if "${cmd[@]}" -q; then

   204

        log_skip "Check $hosts: OK"

   205

    else

   206

        log_error "  Check $hosts: Failed"

   207

   208

        indent "    " "${cmd[@]}"

   209

   210

        exit 1

   211

    fi

   212

}

   213

   214

## Test zone file for validity using named-checkzone:

   215

#

   216

#   check_zone      $view       $zone       $origin

   217

#

   218

# Uses the zonefile at $ZONES/$view/$zone, loading it with given initial $ORIGIN.

   219

# Fails if the check fails.

   220

function check_zone {

   221

    local view=$1

   222

    local zone=$2

   223

    local origin=$3

   224

   225

    local src=$ZONES/$view/$zone

   226

   227

    local cmd=($NAMED_CHECKZONE $origin $ROOT/$src)

   228

   229

    # test

   230

    # XXX: checkzone is very specific about the order of arguments, -q must be first

   231

    if $NAMED_CHECKZONE -q $origin $ROOT/$src; then

   232

        log_skip "Check $src ($origin): OK"

   233

    else

   234

        log_error "  Check $src ($origin): Failed:"

   235

   236

        indent "    " "${cmd[@]}"

   237

   238

        exit 1

   239

    fi

   240

}

   241

   242

# Run rndc reload

   243

function do_reload {

   244

    # run

   245

    indent "        rndc: " \

   246

        $RNDC reload

   247

}

   248

   249

## Load update zonefiles into bind:

   250

#

   252

#

   253

# Invokes `rndc reload`, showing its output.

   255

    local msg="Reload zones"

   256

   258

        log_force  "$msg..."

   259

   260

        do_reload

   261

   263

        log_noop    "$msg: skipped"

   264

   265

    elif [ ! -r $RNDC_KEY ]; then

   266

        log_error   "  $msg: rndc: permission denied: $RNDC_KEY"

   267

   268

        return 1

   269

   270

    else

   271

        log_update  "$msg..."

   272

   273

        # run

   274

        do_reload

   275

    fi

   276

}

   288

## Commit changes in $DATA to version control:

   289

#

   290

#   commit_data

   291

#

   292

# Invokes `hg commit` in the $REPO, first showing the diff.

   293

function commit_data {

   294

    local repo=$REPO

   295

    local commit_msg="$COMMIT_MSG"

   296

   297

    local msg="Commit changes in $repo"

   298

   299

    # operate?

   300

    if [ $COMMIT_FORCE ]; then

   301

        log_force   "$msg..."

   302

   303

        do_commit "$commit_msg"

   304

   305

    elif ! hg_modified; then

   306

        log_skip    "$msg: no changes"

   307

   308

    elif [ $COMMIT_SKIP ]; then

   309

        log_noop    "$msg: skipped"

   310

   311

        # still show diff, though

   312

        [ $LOG_DIFF ] && indent "    " hg_diff

   313

    else

   314

        log_update  "$msg..."

   315

   316

        do_commit "$commit_msg"

   317

    fi

   318

}

   319