1

#!/bin/bash

     2

## vim: set ft=sh :

     3

#

     4

# Operations on zonefiles/hosts/whatever

     5

     6

function link {

     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 {

    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 "$src"

    29

    else

    30

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

    31

    fi

    32

}

    33

    34

## Run check-command on given file, outputting results:

    35

#

    36

#   check    $src    $cmd $args...

    37

#

    38

function check {

    39

    local src="$1"; shift

    40

    local cmd="$1"; shift

    41

    42

    if cmd_test "$cmd" -q "$@"; then

    43

        log_skip    "Check $src: OK"

    44

    45

    else

    46

        log_error   "  Check $src: Failed"

    47

    48

        indent "    " "$cmd" "$@"

    49

    50

        exit 1

    51

    fi

    52

}

    53

    54

## Generate forward zone from hosts hosts using pvl.hosts-dns:

    55

#

    56

#   update_hosts_forward out/hosts/$hosts $hosts in/hosts/$hosts

    57

function update_hosts_forward {

    58

    local out="$1"; shift

    59

    local domain="$1"; shift

    60

    local src="$1"; shift

    61

    62

    if check_update "$out" "$src" "$@"; then

    63

        log_update "Generating forward hosts zone $out <- $src..."

    64

    65

        do_update "$out" $OPT/bin/pvl.hosts-dns \

    66

            --hosts-charset=$CHARSET \

    67

            --forward-zone="$domain" \

    68

             "$src" "$@"

    69

    70

    else

    71

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

    72

    fi

    73

}

    74

    75

function update_hosts_dhcp {

    76

    local out=$1; shift

    77

    local src=$1; shift

    78

    79

    if check_update $out $src "$@"; then

    80

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

    81

    82

        do_update $out $OPT/bin/pvl.hosts-dhcp \

    83

            --hosts-charset=$CHARSET \

    84

            $src "$@"

    85

    else

    86

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

    87

    fi

    88

}

    89

    90

## Generate reverse zone from hosts hosts using pvl.hosts-dns:

    91

#

    92

#   update_hosts_reverse out/hosts/$reverse $reverse in/hosts/$hosts

    93

function update_hosts_reverse {

    94

    local out="$1"; shift

    95

    local reverse="$1"; shift

    96

    local src="$1"; shift

    97

    98

    if check_update "$out" "$src" "$@"; then

    99

        log_update "Generating reverse hosts zone $out <- $src..."

   100

   101

        do_update "$out" $OPT/bin/pvl.hosts-dns \

   102

            --hosts-charset=$CHARSET \

   103

            --reverse-zone="$reverse" \

   104

            "$src" "$@"

   105

   106

    else

   107

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

   108

    fi

   109

}

   110

   111

## Update .serial number:

   112

#

   113

#   do_update_serial $serial

   114

#

   115

# Shows old/new serial on debug.

   116

function do_update_serial {

   117

    local serial="$1"

   118

   119

    # read

   120

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

   121

   122

    cmd $OPT/bin/pvl.dns-serial "$serial"

   123

   124

    # read

   125

    local new=$(cat "$serial")

   126

   127

    debug "  $old -> $new"

   128

}

   129

   130

   131

## Generate new serial for zone using pvl.dns-serial, if the zone data has changed:

   132

#

   133

#   update_serial   $zone   $deps...

   134

#

   135

# Supports SERIAL_FORCE/NOOP.

   136

# Updates $SERIALS/$zone.serial.

   137

function update_serial {

   138

    local serial="$1"; shift

   139

   140

    # test

   141

    if [ $SERIAL_FORCE ]; then

   142

        log_force "Updating $serial: forced"

   143

   144

        do_update_serial "$serial"

   145

   146

    elif ! check_update "$serial" "$@"; then

   147

        log_skip "Updating $serial: not changed"

   148

   149

    elif [ $SERIAL_NOOP ]; then

   150

        log_noop "Updating $serial: skipped"

   151

   152

    else

   153

        log_update "Updating $serial..."

   154

   155

        do_update_serial "$serial"

   156

    fi

   157

}

   158

   159

## Generate zone file from source using pvl.dns-zone:

   160

#

   161

#   update_zone out/zones/$zone in/zones/$zone var/serials/$zone

   162

function update_zone {

   163

    local out="$1"

   164

    local src="$2"

   165

    local serial="$3"

   166

    local serial_opt=

   167

   168

    if [ -n "$serial" -a -f "$serial" ]; then

   169

        serial_opt="--serial=$(cat "$serial")"

   170

   171

    elif [ $SERIAL_NOOP ]; then

   172

        warn "$out: noop'd serial, omitting"

   173

    else

   174

        fail "$out: missing serial: $serial"

   175

    fi

   176

   177

    if check_update "$out" "$src" "$serial"; then

   178

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

   179

   180

        do_update "$out" $OPT/bin/pvl.dns-zone "$src" \

   181

                --include-path=$SRV/var/zones   \

   182

                $serial_opt

   183

    else

   184

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

   185

    fi

   186

}

   187

   203

## Test hosts zone for validity using pvl.hosts-check:

   204

#

   205

#   check_hosts     .../hosts

   206

function check_hosts {

   207

    local hosts=$1; shift 1

   208

   209

    # TODO

   210

    check $hosts \

   211

        $OPT/bin/pvl.hosts-check $hosts

   212

}

   213

   214

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

   215

#

   216

#   check_zone      ..../$zone $origin

   217

function check_zone {

   218

    local zone=$1

   219

    local origin=$2

   220

   221

    log_check "Checking $zone @ $origin..." 

   222

   223

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

   224

    check $zone $NAMED_CHECKZONE $origin $zone

   225

}

   226

   227

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

   228

#

   229

#   check_dhcp      [$conf]

   230

#

   231

# Defaults to the global $DHCPD_CONF.

   232

# Fails if the check fails.

   233

function check_dhcp {

   234

    local conf=${1:-$DHCPD_CONF}

   235

   236

    log_check "Checking DHCP $conf..." 

   237

   238

    if [ ! -e $DHCPD ]; then

   239

        log_warn "check_dhcp: dhcpd not installed, skipping: $conf"

   240

        return 0

   241

    fi

   242

   243

    check $conf \

   244

        $DHCPD -cf $conf -t

   245

}

   246

   247

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

   248

#

   249

#   check_dhcp_conf     $conf

   250

#

   251

function check_dhcp_conf {

   252

    local conf=$1;

   253

   254

    check_dhcp $DHCP_DATA/$conf.conf

   255

}

   256

   257

### Deploy

   258

## Run rndc reload

   259

function do_reload_zones {

   260

    # run

   261

    indent "        rndc: " \

   262

        $RNDC reload

   263

   264

    # set flag

   265

    RELOAD_ZONES=y

   266

}

   267

   268

## Load update zonefiles into bind:

   269

#

   270

#   reload_zones    

   271

#

   272

# Invokes `rndc reload`, showing its output.

   273

function reload_zones {

   274

    local msg="Reload zones"

   275

   276

    if [ $RELOAD_FORCE ]; then

   277

        log_force  "$msg..."

   278

   279

        do_reload_zones

   280

   281

    elif [ $RELOAD_NOOP ]; then

   282

        log_noop    "$msg: skipped"

   283

   284

    elif [ ! -e $RNDC ]; then

   285

        log_warn "reload_zones: rndc not installed, skipping"

   286

   287

    elif [ ! -e $RNDC_KEY ]; then

   288

        log_warn   "  $msg: rndc: key not found: $RNDC_KEY"

   289

   290

    elif [ ! -r $RNDC_KEY ]; then

   291

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

   292

   293

        return 1

   294

   295

    else

   296

        log_update  "$msg..."

   297

   298

        # run

   299

        do_reload_zones

   300

    fi

   301

}

   302

   303

## Reload DHCP by restarting it, if running:

   304

#

   305

#   do_reload_dhcp

   306

#

   307

# Does NOT restart dhcp if it is not running (status).

   308

function do_reload_dhcp {

   309

    if cmd_test $DHCPD_INIT status >/dev/null; then

   310

        cmd $DHCPD_INIT restart

   311

    else

   312

        log_warn "dhcpd not running; did not restart"

   313

    fi

   314

}

   315

   316

## Reload dhcp hosts

   317

#

   318

#   reload_dhcp

   319

#

   320

# noop's if we haven't reloaded zones

   321

function reload_dhcp {

   322

    local msg="Reload DHCP hosts"

   323

   324

    if [ $RELOAD_FORCE ]; then

   325

        log_force  "$msg..."

   326

   327

        do_reload_dhcp

   328

   329

    elif [ $RELOAD_NOOP ]; then

   330

        log_noop    "$msg: skipped"

   331

   332

    elif [ ! -e $DHCPD ]; then

   333

        log_warn "reload_dhcp: dhcpd not installed, skipping: $conf"

   334

   335

    else

   336

        log_update  "$msg..."

   337

   338

        # run

   339

        do_reload_dhcp

   340

    fi

   341

}

   342

   343

### Commit

   344

## Perform `hg commit`

   345

function do_commit {

   346

    local repo=$1

   347

    local msg=$1

   348

   349

    [ $LOG_DIFF ] && indent "    " hg_diff $repo

   350

   351

    hg_commit $repo "$msg"

   352

}

   353

   354

   355

## Commit changes to version control:

   356

#

   357

#   commit_data

   358

#

   359

# Invokes `hg commit`, first showing the diff.

   360

function commit {

   361

    local repo=$1

   362

    local commit_msg="$COMMIT_MSG"

   363

   364

    local msg="Commit changes"

   365

   366

    # operate?

   367

    if [ $COMMIT_FORCE ]; then

   368

        log_force   "$msg..."

   369

   370

        do_commit "$commit_msg"

   371

   372

    elif ! hg_modified $repo; then

   373

        log_warn    "$msg: no changes"

   374

   375

    elif [ $COMMIT_SKIP ]; then

   376

        log_noop    "$msg: skipped"

   377

   378

        # still show diff, though

   379

        [ $LOG_DIFF ] && indent "    " hg_diff $repo

   380

    else

   381

        log_update  "$msg..."

   382

   383

        do_commit $repo "$commit_msg"

   384

    fi

   385

}