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

    61

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

    62

        log_update "Generating forward hosts zone $out @ $domain <- $@..."

    63

    64

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

    65

            --hosts-charset=$CHARSET \

    66

            --forward-zone="$domain" \

    67

             "$@"

    68

    else

    69

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

    70

    fi

    71

}

    72

    73

function update_hosts_dhcp {

    74

    local out=$1; shift

    76

    79

    80

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

    81

            --hosts-charset=$CHARSET \

    84

    else

    86

    fi

    87

}

    88

    89

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

    90

#

    91

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

    92

function update_hosts_reverse {

    93

    local out="$1"; shift

    94

    local reverse="$1"; shift

    95

    96

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

    97

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

    98

    99

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

   100

            --hosts-charset=$CHARSET \

   101

            --reverse-zone="$reverse" \

   102

            "$@"

   103

    else

   104

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

   105

    fi

   106

}

   107

   108

## Update .serial number:

   109

#

   110

#   do_update_serial .../serials/$zone  $serial

   111

#

   112

function do_update_serial {

   113

    local dst="$1"

   114

    local serial="$2"

   115

   116

    echo $serial > $dst

   117

}

   118

   119

   120

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

   121

#

   122

#   update_serial   .../serials/$zone   $serial     $deps...

   123

#

   124

# Supports SERIAL_FORCE/NOOP.

   125

# Updates $SERIALS/$zone.serial.

   126

function update_serial {

   127

    local dst="$1"; shift

   128

    local serial="$1"; shift

   129

   130

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

   131

   132

    # test

   133

    if [ $SERIAL_FORCE ]; then

   134

        log_force "Updating $dst: $old <- $serial: forced"

   135

   136

        do_update_serial "$dst" "$serial"

   137

   138

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

   139

        log_skip "Updating $dst: $old <- $serial: not changed"

   140

   141

    elif [ $SERIAL_NOOP ]; then

   142

        log_noop "Updating $dst: $old <- $serial: skipped"

   143

   144

    else

   145

        log_update "Updating $dst: $old <- $serial"

   146

   147

        do_update_serial "$dst" "$serial"

   148

    fi

   149

}

   150

   151

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

   152

#

   153

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

   154

function update_zone {

   155

    local out="$1"; shift

   156

    local src="$1"; shift

   157

    local serial="$1"; shift

   158

    local serial_opt=

   159

   160

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

   161

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

   162

    elif [ $SERIAL_NOOP ]; then

   163

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

   164

    else

   165

        fail "$out: missing serial: $serial"

   166

    fi

   167

   168

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

   169

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

   170

   171

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

   172

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

   173

                $serial_opt

   174

    else

   175

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

   176

    fi

   177

}

   178

   179

## Generate dhcp confs from source using pvl.dhcp-conf:

   180

function update_dhcp_conf {

   181

    local out="$1"

   182

    local src="$2"

   183

   184

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

   185

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

   186

   187

        do_update "$out" $OPT/bin/pvl.dhcp-conf "$src" \

   188

            --include-path=$SRV/var/dhcp

   189

    else

   190

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

   191

    fi

   192

}

   193

   194

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

   195

#

   196

#   check_hosts     .../hosts

   197

function check_hosts {

   198

    local hosts=$1; shift 1

   199

   200

    # TODO

   201

    check $hosts \

   202

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

   203

}

   204

   205

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

   206

#

   207

#   check_zone      ..../$zone $origin

   208

function check_zone {

   209

    local zone=$1

   210

    local origin=$2

   211

   212

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

   213

   214

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

   215

    check $zone $NAMED_CHECKZONE $origin $zone

   216

}

   217

   218

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

   219

#

   220

#   check_dhcp      [$conf]

   221

#

   222

# Defaults to the global $DHCPD_CONF.

   223

# Fails if the check fails.

   224

function check_dhcp {

   225

    local conf=${1:-$DHCPD_CONF}

   226

   227

    log_check "Checking DHCP $conf..." 

   228

   229

    if [ ! -e $DHCPD ]; then

   230

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

   231

        return 0

   232

    fi

   233

   234

    check $conf \

   235

        $DHCPD -cf $conf -t

   236

}

   237

   238

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

   239

#

   240

#   check_dhcp_conf     $conf

   241

#

   242

function check_dhcp_conf {

   243

    local conf=$1;

   244

   245

    check_dhcp $DHCP_DATA/$conf.conf

   246

}

   247

   248

### Deploy

   249

# set by do_reload_zone if zone data has actually been reloaded

   250

RELOAD_ZONES=

   251

   252

## Run rndc reload

   253

function do_reload_zones {

   254

    # run

   255

    indent "        rndc: " \

   256

        $RNDC reload

   257

   258

    # set flag

   259

    RELOAD_ZONES=y

   260

}

   261

   262

## Load update zonefiles into bind:

   263

#

   264

#   reload_zones    

   265

#

   266

# Invokes `rndc reload`, showing its output.

   267

function reload_zones {

   268

    local msg="Reload zones"

   269

   270

    if [ $RELOAD_FORCE ]; then

   271

        log_force  "$msg..."

   272

   273

        do_reload_zones

   274

   275

    elif [ $RELOAD_NOOP ]; then

   276

        log_noop    "$msg: skipped"

   277

   278

    elif [ ! -e $RNDC ]; then

   279

        log_warn "reload_zones: rndc not installed, skipping"

   280

   281

    elif [ ! -e $RNDC_KEY ]; then

   282

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

   283

   284

    elif [ ! -r $RNDC_KEY ]; then

   285

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

   286

   287

        return 1

   288

   289

    else

   290

        log_update  "$msg..."

   291

   292

        # run

   293

        do_reload_zones

   294

    fi

   295

}

   296

   297

## Reload DHCP by restarting it, if running:

   298

#

   299

#   do_reload_dhcp

   300

#

   301

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

   302

function do_reload_dhcp {

   303

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

   304

        cmd $DHCPD_INIT restart

   305

    else

   306

        log_warn "dhcpd not running; did not restart"

   307

    fi

   308

}

   309

   310

## Reload dhcp hosts

   311

#

   312

#   reload_dhcp

   313

#

   314

# noop's if we haven't reloaded zones

   315

function reload_dhcp {

   316

    local msg="Reload DHCP hosts"

   317

   318

    if [ $RELOAD_FORCE ]; then

   319

        log_force  "$msg..."

   320

   321

        do_reload_dhcp

   322

   323

    elif [ $RELOAD_NOOP ]; then

   324

        log_noop    "$msg: skipped"

   325

   326

    elif [ ! -e $DHCPD ]; then

   327

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

   328

   329

    else

   330

        log_update  "$msg..."

   331

   332

        # run

   333

        do_reload_dhcp

   334

    fi

   335

}

   336

   337

### Commit

   338

## Commit changes to version control:

   339

#

   340

#   update_commit .../etc "commit message"

   341

#

   342

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

   343

function update_commit {

   344

    local repo="$1"

   345

    local commit_msg="$COMMIT_MSG"

   346

   347

    local msg="Commit changes"

   348

   349

    # operate?

   350

    if [ $COMMIT_FORCE ]; then

   351

        log_force   "$msg: $commit_msg"

   352

   353

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

   354

   355

        hg_commit "$repo" "$commit_msg"

   356

   357

    elif ! hg_modified "$repo"; then

   358

        log_warn    "$msg: no changes"

   359

   360

    elif [ $COMMIT_SKIP ]; then

   361

        log_noop    "$msg: skipped"

   362

   363

        # still show diff, though

   364

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

   365

    else

   366

        log_update  "$msg: $commit_msg"

   367

   368

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

   369

   370

        hg_commit "$repo" "$commit_msg"

   371

    fi

   372

}