1

#!/bin/bash

     2

## vim: set ft=sh :

     3

#

     4

# Operations on zonefiles/hosts/whatever

     5

    21

## Hosts

    22

## Update hosts from verbatim from input zone data:

    23

#

    24

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

    25

#

    26

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

    27

function copy_hosts {

    28

    local zone=$1

    29

    local base=$2

    30

    31

    if check_update $zone $base; then

    32

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

    33

    34

        do_update $zone \

    35

            cat $ROOT/$base

    36

    else

    37

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

    38

    fi

    39

}

    40

    41

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

    42

#

    43

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

    44

#

    45

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

    46

function update_hosts {

    47

    local zone=$1; shift

    48

    local base=$1; shift

    49

    50

    if check_update $zone $base; then

    51

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

    52

    53

        do_update $zone \

    54

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

    55

    else

    56

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

    57

    fi

    58

}

    59

    60

## Update .serial number:

    61

#

    62

#   do_update_serial $serial

    63

#

    64

# Shows old/new serial on debug.

    65

function do_update_serial {

    66

    local serial=$1

    67

    68

    # read

    69

    local old=$(test -e $ROOT/$serial && cat $ROOT/$serial || echo '')

    70

    71

    72

    cmd $BIN/update-serial $ROOT/$serial

    73

    74

    # read

    75

    local new=$(cat $ROOT/$serial)

    76

    77

    debug "  $old -> $new"

    78

}

    79

    80

    81

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

    82

#

    83

#   update_serial   $zone   $deps...

    84

#

    85

# Supports SERIAL_FORCE/NOOP.

    86

# Updates $SERIALS/$zone.serial.

    87

function update_serial {

    88

    local zone=$1; shift

    89

    90

    local serial=$SERIALS/$zone.serial

    91

    92

    # test

    93

    if [ $SERIAL_FORCE ]; then

    94

        log_force "Updating $serial: forced"

    95

    96

        do_update_serial $serial

    97

    98

    elif ! check_update $serial "$@"; then

    99

        log_skip "Updating $serial: not changed"

   100

   101

    elif [ $SERIAL_NOOP ]; then

   102

        log_noop "Updating $serial: skipped"

   103

   104

    else

   105

        log_update "Updating $serial..."

   106

   107

        do_update_serial $serial

   108

    fi

   109

}

   110

   111

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

   112

#

   113

#   link_serial $zone $base

   114

function link_serial {

   115

    local zone=$1

   116

    local base=$2

   117

   119

    local tgt=$SERIALS/$base.serial

   120

   121

   123

}

   124

   125

## Update zone file verbatim from source:

   126

#

   127

#   copy_zone   $view   $zone   [$base]

   128

#

   129

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

   130

function copy_zone {

   131

    local view=$1

   132

    local zone=$2

   133

    local base=${3:-$zone}

   134

   135

    local out=$ZONES/$view/$zone

   136

    local src=$DATA/$base

   137

   138

    if check_update $out $src; then

   139

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

   140

   141

        do_update $out \

   142

            cat $ROOT/$src

   143

    else

   144

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

   145

    fi

   146

}

   147

   148

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

   149

#

   150

#   update_zone $view   $zone   [$base]

   151

#

   152

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

   153

function update_zone {

   154

    local view=$1

   155

    local zone=$2

   156

    local base=${3:-$zone}

   157

   158

    local out=$ZONES/$view/$zone

   159

    local src=$DATA/$base.zone

   160

    local lnk=$ZONES/$base

   161

   162

    local serial=$SERIALS/$base.serial

   163

   164

    if check_update $out $src $serial; then

   165

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

   166

   167

        do_update $out \

   168

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

   169

                --serial $ROOT/$serial              \

   170

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

   171

                --expand view=$view

   172

    else

   173

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

   174

    fi

   175

}

   176

   177

## Link zone file to ues given shared zone.

   178

#

   179

#   link_zone   $view   $zone   [$base]

   180

#

   181

# Looks for shared zone at:

   182

#   $ZONES/$view/$base

   183

#   $ZONES/common/$base

   184

function link_zone {

   185

    local view=$1

   186

    local zone=$2

   187

    local base=${3:-$zone}

   188

   189

    local out=$ZONES/$view/$zone

   190

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

   191

   194

   199

   204

}

   205

   206

## Test hosts zone for validity:

   207

#

   208

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

   209

#

   210

# Fails if the check fails.

   211

function check_hosts {

   212

    local hosts=$1; shift 1

   213

   214

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

   215

   216

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

   217

        log_skip "Check $hosts: OK"

   218

    else

   219

        log_error "  Check $hosts: Failed"

   220

   221

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

   222

   223

        exit 1

   224

    fi

   225

}

   226

   227

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

   228

#

   229

#   check_zone      $view       $zone       $origin

   230

#

   231

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

   232

# Fails if the check fails.

   233

function check_zone {

   234

    local view=$1

   235

    local zone=$2

   236

    local origin=$3

   237

   238

    local src=$ZONES/$view/$zone

   239

   240

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

   241

   242

    # test

   243

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

   244

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

   245

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

   246

    else

   247

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

   248

   249

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

   250

   251

        exit 1

   252

    fi

   253

}

   254

   288

# Run rndc reload

   289

function do_reload {

   290

    # run

   291

    indent "        rndc: " \

   292

        $RNDC reload

   293

}

   294

   295

## Load update zonefiles into bind:

   296

#

   297

#   reload_zones    

   298

#

   299

# Invokes `rndc reload`, showing its output.

   300

function reload_zones {

   301

    local msg="Reload zones"

   302

   303

    if [ $RELOAD_FORCE ]; then

   304

        log_force  "$msg..."

   305

   306

        do_reload

   307

   308

    elif [ $RELOAD_NOOP ]; then

   309

        log_noop    "$msg: skipped"

   310

   311

    elif [ ! -r $RNDC_KEY ]; then

   312

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

   313

   314

        return 1

   315

   316

    else

   317

        log_update  "$msg..."

   318

   319

        # run

   320

        do_reload

   321

    fi

   322

}

   323

   324

## Perform `hg commit` for $DATA

   325

function do_commit {

   326

    local msg=$1

   327

   328

    [ $LOG_DIFF ] && indent "    " hg_diff

   329

   330

    hg_commit "$msg"

   331

}

   332

   333

   334

## Commit changes in $DATA to version control:

   335

#

   336

#   commit_data

   337

#

   338

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

   339

function commit_data {

   340

    local repo=$REPO

   341

    local commit_msg="$COMMIT_MSG"

   342

   343

    local msg="Commit changes in $repo"

   344

   345

    # operate?

   346

    if [ $COMMIT_FORCE ]; then

   347

        log_force   "$msg..."

   348

   349

        do_commit "$commit_msg"

   350

   351

    elif ! hg_modified; then

   352

        log_skip    "$msg: no changes"

   353

   354

    elif [ $COMMIT_SKIP ]; then

   355

        log_noop    "$msg: skipped"

   356

   357

        # still show diff, though

   358

        [ $LOG_DIFF ] && indent "    " hg_diff

   359

    else

   360

        log_update  "$msg..."

   361

   362

        do_commit "$commit_msg"

   363

    fi

   364

}

   365