1

#!/bin/bash

     2

## vim: set ft=sh :

     3

#

     4

# Operations on zonefiles/hosts/whatever

     5

     6

function link_generic {

     7

    local out=$1

     8

    local tgt=$2

     9

    10

    if check_link $out $tgt; then

    11

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

    12

    13

        do_link $out $tgt

    14

    15

    else

    16

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

    17

    fi

    18

}

    19

    33

    34

## Hosts

    35

## Update hosts from verbatim from input zone data:

    36

#

    37

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

    38

#

    39

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

    40

function copy_hosts {

    41

    local zone=$1

    42

    local base=$2

    43

    47

    49

}

    50

    51

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

    52

#

    53

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

    54

#

    55

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

    56

function update_hosts {

    57

    local zone=$1; shift

    58

    local base=$1; shift

    59

    60

    if check_update $zone $base; then

    61

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

    62

    63

        do_update $zone \

    64

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

    65

    else

    66

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

    67

    fi

    68

}

    69

    70

## Update .serial number:

    71

#

    72

#   do_update_serial $serial

    73

#

    74

# Shows old/new serial on debug.

    75

function do_update_serial {

    76

    local serial=$1

    77

    78

    # read

    79

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

    80

    81

    82

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

    83

    84

    # read

    85

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

    86

    87

    debug "  $old -> $new"

    88

}

    89

    90

    91

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

    92

#

    93

#   update_serial   $zone   $deps...

    94

#

    95

# Supports SERIAL_FORCE/NOOP.

    96

# Updates $SERIALS/$zone.serial.

    97

function update_serial {

    98

    local zone=$1; shift

    99

   100

    local serial=$SERIALS/$zone.serial

   101

   102

    # test

   103

    if [ $SERIAL_FORCE ]; then

   104

        log_force "Updating $serial: forced"

   105

   106

        do_update_serial $serial

   107

   108

    elif ! check_update $serial "$@"; then

   109

        log_skip "Updating $serial: not changed"

   110

   111

    elif [ $SERIAL_NOOP ]; then

   112

        log_noop "Updating $serial: skipped"

   113

   114

    else

   115

        log_update "Updating $serial..."

   116

   117

        do_update_serial $serial

   118

    fi

   119

}

   120

   121

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

   122

#

   123

#   link_serial $zone $base

   124

function link_serial {

   125

    local zone=$1

   126

    local base=$2

   127

   128

    local out=$SERIALS/$zone.serial

   129

    local tgt=$SERIALS/$base.serial

   130

   131

    link_generic $out $tgt

   132

}

   133

   134

## Update zone file verbatim from source:

   135

#

   136

#   copy_zone   $view   $zone   [$base]

   137

#

   138

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

   139

function copy_zone {

   140

    local view=$1

   141

    local zone=$2

   142

    local base=${3:-$zone}

   143

   144

    local out=$ZONES/$view/$zone

   145

    local src=$DATA/$base

   146

   148

}

   149

   150

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

   151

#

   152

#   update_zone $view   $zone   [$base]

   153

#

   154

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

   155

function update_zone {

   156

    local view=$1

   157

    local zone=$2

   158

    local base=${3:-$zone}

   159

   160

    local out=$ZONES/$view/$zone

   161

    local src=$DATA/$base.zone

   162

    local lnk=$ZONES/$base

   163

   164

    local serial=$SERIALS/$base.serial

   165

   166

    if check_update $out $src $serial; then

   167

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

   168

   169

        do_update $out \

   170

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

   171

                --serial $ROOT/$serial              \

   172

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

   173

                --expand view=$view

   174

    else

   175

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

   176

    fi

   177

}

   178

   179

## Link zone file to ues given shared zone.

   180

#

   181

#   link_zone   $view   $zone   [$base]

   182

#

   183

# Looks for shared zone at:

   184

#   $ZONES/$view/$base

   185

#   $ZONES/common/$base

   186

function link_zone {

   187

    local view=$1

   188

    local zone=$2

   189

    local base=${3:-$zone}

   190

   191

    local out=$ZONES/$view/$zone

   192

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

   193

   194

    link_generic $out $tgt

   195

}

   196

   197

## Link dhcp file directly from data to $DHCP

   198

function link_dhcp_conf {

   199

    local conf=$1

   200

    local base=${2:-$conf}

   201

   202

    local out=$DHCP/$conf.conf

   203

    local tgt=$(choose_link $out $DHCP/$base.conf $DHCP_DATA/$base.conf)

   204

   205

    link_generic $out $tgt

   206

}

   207

   219

## Test hosts zone for validity:

   220

#

   221

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

   222

#

   223

# Fails if the check fails.

   224

function check_hosts {

   225

    local hosts=$1; shift 1

   226

   227

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

   228

   229

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

   230

        log_skip "Check $hosts: OK"

   231

    else

   232

        log_error "  Check $hosts: Failed"

   233

   234

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

   235

   236

        exit 1

   237

    fi

   238

}

   239

   240

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

   241

#

   242

#   check_zone      $view       $zone       $origin

   243

#

   244

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

   245

# Fails if the check fails.

   246

function check_zone {

   247

    local view=$1

   248

    local zone=$2

   249

    local origin=$3

   250

   251

    local src=$ZONES/$view/$zone

   252

   253

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

   254

   255

    # test

   256

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

   257

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

   258

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

   259

    else

   260

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

   261

   262

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

   263

   264

        exit 1

   265

    fi

   266

}

   267

   268

## Test DHCP configuration for validity using dhcpd -t:

   269

#

   270

#   check_dhcp      [$conf]

   271

#

   272

# Defaults to the global $DHCPD_CONF.

   273

# Fails if the check fails.

   274

function check_dhcp {

   275

    local conf=${1:-$DHCPD_CONF}

   276

   277

    local cmd=($DHCPD -cf $conf -t)

   278

   279

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

   280

        log_skip    "Check $conf: OK"

   281

   282

    else

   283

        log_error   "  Check $conf: Failed"

   284

   285

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

   286

   287

        exit 1

   288

    fi

   289

}

   290

   291

## Test DHCP configuration of given settings/dhcp using check_dhcp $DHCP_DATA/$host.conf:

   292

#

   293

#   check_dhcp_conf     $conf

   294

#

   295

function check_dhcp_conf {

   296

    local conf=$1

   297

   298

    check_dhcp $DHCP_DATA/$conf.conf

   299

}

   300

   301

# Run rndc reload

   302

function do_reload {

   303

    # run

   304

    indent "        rndc: " \

   305

        $RNDC reload

   306

}

   307

   308

## Load update zonefiles into bind:

   309

#

   310

#   reload_zones    

   311

#

   312

# Invokes `rndc reload`, showing its output.

   313

function reload_zones {

   314

    local msg="Reload zones"

   315

   316

    if [ $RELOAD_FORCE ]; then

   317

        log_force  "$msg..."

   318

   319

        do_reload

   320

   321

    elif [ $RELOAD_NOOP ]; then

   322

        log_noop    "$msg: skipped"

   323

   324

    elif [ ! -r $RNDC_KEY ]; then

   325

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

   326

   327

        return 1

   328

   329

    else

   330

        log_update  "$msg..."

   331

   332

        # run

   333

        do_reload

   334

    fi

   335

}

   336

   337

## Perform `hg commit` for $DATA

   338

function do_commit {

   339

    local msg=$1

   340

   341

    [ $LOG_DIFF ] && indent "    " hg_diff

   342

   343

    hg_commit "$msg"

   344

}

   345

   346

   347

## Commit changes in $DATA to version control:

   348

#

   349

#   commit_data

   350

#

   351

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

   352

function commit_data {

   353

    local repo=$REPO

   354

    local commit_msg="$COMMIT_MSG"

   355

   356

    local msg="Commit changes in $repo"

   357

   358

    # operate?

   359

    if [ $COMMIT_FORCE ]; then

   360

        log_force   "$msg..."

   361

   362

        do_commit "$commit_msg"

   363

   364

    elif ! hg_modified; then

   365

        log_skip    "$msg: no changes"

   366

   367

    elif [ $COMMIT_SKIP ]; then

   368

        log_noop    "$msg: skipped"

   369

   370

        # still show diff, though

   371

        [ $LOG_DIFF ] && indent "    " hg_diff

   372

    else

   373

        log_update  "$msg..."

   374

   375

        do_commit "$commit_msg"

   376

    fi

   377

}

   378