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

    20

function copy_generic {

    21

    local out=$1

    22

    local src=$2

    23

    24

    if check_update $out $src; then

    25

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

    26

    27

        do_update $out \

    28

            cat $ROOT/$src

    29

    else

    30

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

    31

    fi

    32

}

    33

    54

## Hosts

    55

## Update hosts from verbatim from input zone data:

    56

#

    57

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

    58

#

    59

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

    60

function copy_hosts {

    61

    local zone=$1

    62

    local base=$2

    63

    64

    # XXX: filenames given directly

    65

    local out=$zone

    66

    local src=$base

    67

    68

    copy_generic $out $src

    69

}

    70

    71

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

    72

#

    73

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

    74

#

    75

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

    76

function update_hosts {

    77

    local zone=$1; shift

    78

    local base=$1; shift

    79

    80

    if check_update $zone $base; then

    81

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

    82

    83

        do_update $zone \

    84

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

    85

    else

    86

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

    87

    fi

    88

}

    89

    90

## Update .serial number:

    91

#

    92

#   do_update_serial $serial

    93

#

    94

# Shows old/new serial on debug.

    95

function do_update_serial {

    96

    local serial=$1

    97

    98

    # read

    99

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

   100

   101

   102

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

   103

   104

    # read

   105

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

   106

   107

    debug "  $old -> $new"

   108

}

   109

   110

   111

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

   112

#

   113

#   update_serial   $zone   $deps...

   114

#

   115

# Supports SERIAL_FORCE/NOOP.

   116

# Updates $SERIALS/$zone.serial.

   117

function update_serial {

   118

    local zone=$1; shift

   119

   120

    local serial=$SERIALS/$zone.serial

   121

   122

    # test

   123

    if [ $SERIAL_FORCE ]; then

   124

        log_force "Updating $serial: forced"

   125

   126

        do_update_serial $serial

   127

   128

    elif ! check_update $serial "$@"; then

   129

        log_skip "Updating $serial: not changed"

   130

   131

    elif [ $SERIAL_NOOP ]; then

   132

        log_noop "Updating $serial: skipped"

   133

   134

    else

   135

        log_update "Updating $serial..."

   136

   137

        do_update_serial $serial

   138

    fi

   139

}

   140

   141

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

   142

#

   143

#   link_serial $zone $base

   144

function link_serial {

   145

    local zone=$1

   146

    local base=$2

   147

   148

    local out=$SERIALS/$zone.serial

   149

    local tgt=$SERIALS/$base.serial

   150

   151

    link_generic $out $tgt

   152

}

   153

   154

## Update zone file verbatim from source:

   155

#

   156

#   copy_zone   $view   $zone   [$base]

   157

#

   158

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

   159

function copy_zone {

   160

    local view=$1

   161

    local zone=$2

   162

    local base=${3:-$zone}

   163

   164

    local out=$ZONES/$view/$zone

   165

    local src=$DATA/$base

   166

   167

    copy_generic $out $src

   168

}

   169

   170

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

   171

#

   172

#   update_zone $view   $zone   [$base]

   173

#

   174

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

   175

function update_zone {

   176

    local view=$1

   177

    local zone=$2

   178

    local base=${3:-$zone}

   179

   180

    local out=$ZONES/$view/$zone

   181

    local src=$DATA/$base.zone

   182

    local lnk=$ZONES/$base

   183

   184

    local serial=$SERIALS/$base.serial

   185

   186

    if check_update $out $src $serial; then

   187

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

   188

   189

        do_update $out \

   190

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

   191

                --serial $ROOT/$serial              \

   192

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

   193

                --expand view=$view

   194

    else

   195

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

   196

    fi

   197

}

   198

   199

## Link zone file to ues given shared zone.

   200

#

   201

#   link_zone   $view   $zone   [$base]

   202

#

   203

# Looks for shared zone at:

   204

#   $ZONES/$view/$base

   205

#   $ZONES/common/$base

   206

function link_zone {

   207

    local view=$1

   208

    local zone=$2

   209

    local base=${3:-$zone}

   210

   211

    local out=$ZONES/$view/$zone

   212

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

   213

   214

    link_generic $out $tgt

   215

}

   216

   217

## Link dhcp file directly from data to $DHCP

   218

function link_dhcp_conf {

   219

    local conf=$1

   220

    local base=${2:-$conf}

   221

   222

    local out=$DHCP/$conf.conf

   223

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

   224

   225

    link_generic $out $tgt

   226

}

   227

   228

## Copy dhcp conf from data to $DHCP

   229

function copy_dhcp_conf {

   230

    local conf=$1

   231

    local base=${2:-$conf}

   232

   233

    local out=$DHCP/$conf.conf

   234

    local src=$DHCP_DATA/$base.conf

   235

   236

    copy_generic $out $src

   237

}

   238

   239

## Test hosts zone for validity:

   240

#

   241

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

   242

#

   243

# Fails if the check fails.

   244

function check_hosts {

   245

    local hosts=$1; shift 1

   246

   247

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

   248

   249

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

   250

        log_skip "Check $hosts: OK"

   251

    else

   252

        log_error "  Check $hosts: Failed"

   253

   254

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

   255

   256

        exit 1

   257

    fi

   258

}

   259

   260

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

   261

#

   262

#   check_zone      $view       $zone       $origin

   263

#

   264

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

   265

# Fails if the check fails.

   266

function check_zone {

   267

    local view=$1

   268

    local zone=$2

   269

    local origin=$3

   270

   271

    local src=$ZONES/$view/$zone

   272

   273

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

   274

   275

    # test

   276

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

   277

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

   278

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

   279

    else

   280

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

   281

   282

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

   283

   284

        exit 1

   285

    fi

   286

}

   287

   288

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

   289

#

   290

#   check_dhcp      [$conf]

   291

#

   292

# Defaults to the global $DHCPD_CONF.

   293

# Fails if the check fails.

   294

function check_dhcp {

   295

    local conf=${1:-$DHCPD_CONF}

   296

   299

}

   300

   301

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

   302

#

   303

#   check_dhcp_conf     $conf

   304

#

   305

function check_dhcp_conf {

   307

   308

    check_dhcp $DHCP_DATA/$conf.conf

   309

}

   310

   330

# Run rndc reload

   332

    # run

   333

    indent "        rndc: " \

   334

        $RNDC reload

   338

}

   339

   340

## Load update zonefiles into bind:

   341

#

   342

#   reload_zones    

   343

#

   344

# Invokes `rndc reload`, showing its output.

   345

function reload_zones {

   346

    local msg="Reload zones"

   347

   348

    if [ $RELOAD_FORCE ]; then

   349

        log_force  "$msg..."

   350

   352

   353

    elif [ $RELOAD_NOOP ]; then

   354

        log_noop    "$msg: skipped"

   355

   356

    elif [ ! -r $RNDC_KEY ]; then

   357

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

   358

   359

        return 1

   360

   361

    else

   362

        log_update  "$msg..."

   363

   364

        # run

   403

    fi

   404

}

   405

   406

## Perform `hg commit` for $DATA

   407

function do_commit {

   408

    local msg=$1

   409

   410

    [ $LOG_DIFF ] && indent "    " hg_diff

   411

   412

    hg_commit "$msg"

   413

}

   414

   415

   416

## Commit changes in $DATA to version control:

   417

#

   418

#   commit_data

   419

#

   420

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

   421

function commit_data {

   422

    local repo=$REPO

   423

    local commit_msg="$COMMIT_MSG"

   424

   425

    local msg="Commit changes in $repo"

   426

   427

    # operate?

   428

    if [ $COMMIT_FORCE ]; then

   429

        log_force   "$msg..."

   430

   431

        do_commit "$commit_msg"

   432

   433

    elif ! hg_modified; then

   434

        log_skip    "$msg: no changes"

   435

   436

    elif [ $COMMIT_SKIP ]; then

   437

        log_noop    "$msg: skipped"

   438

   439

        # still show diff, though

   440

        [ $LOG_DIFF ] && indent "    " hg_diff

   441

    else

   442

        log_update  "$msg..."

   443

   444

        do_commit "$commit_msg"

   445

    fi

   446

}

   447