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

    63

    64

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

    65

            --hosts-charset=$CHARSET \

    66

            --forward-zone="$domain" \

    68

    else

    70

    fi

    71

}

    72

    73

function update_hosts_dhcp {

    74

    local out=$1; shift

    75

    local src=$1; shift

    76

    77

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

    78

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

    79

    80

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

    81

            --hosts-charset=$CHARSET \

    82

            $src "$@"

    83

    else

    84

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

    85

    fi

    86

}

    87

    88

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

    89

#

    90

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

    91

function update_hosts_reverse {

    92

    local out="$1"; shift

    93

    local reverse="$1"; shift

    94

    97

    98

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

    99

            --hosts-charset=$CHARSET \

   100

            --reverse-zone="$reverse" \

   102

    else

   104

    fi

   105

}

   106

   107

## Update .serial number:

   108

#

   109

#   do_update_serial $serial

   110

#

   111

# Shows old/new serial on debug.

   112

function do_update_serial {

   113

    local serial="$1"

   114

   115

    # read

   116

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

   117

   118

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

   119

   120

    # read

   121

    local new=$(cat "$serial")

   122

   123

    debug "  $old -> $new"

   124

}

   125

   126

   127

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

   128

#

   129

#   update_serial   $zone   $deps...

   130

#

   131

# Supports SERIAL_FORCE/NOOP.

   132

# Updates $SERIALS/$zone.serial.

   133

function update_serial {

   134

    local serial="$1"; shift

   135

   136

    # test

   137

    if [ $SERIAL_FORCE ]; then

   138

        log_force "Updating $serial: forced"

   139

   140

        do_update_serial "$serial"

   141

   142

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

   143

        log_skip "Updating $serial: not changed"

   144

   145

    elif [ $SERIAL_NOOP ]; then

   146

        log_noop "Updating $serial: skipped"

   147

   148

    else

   149

        log_update "Updating $serial..."

   150

   151

        do_update_serial "$serial"

   152

    fi

   153

}

   154

   155

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

   156

#

   157

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

   158

function update_zone {

   159

    local out="$1"

   160

    local src="$2"

   161

    local serial="$3"

   162

    local serial_opt=

   163

   164

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

   165

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

   166

   167

    elif [ $SERIAL_NOOP ]; then

   168

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

   169

    else

   170

        fail "$out: missing serial: $serial"

   171

    fi

   172

   173

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

   174

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

   175

   176

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

   177

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

   178

                $serial_opt

   179

    else

   180

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

   181

    fi

   182

}

   183

   184

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

   185

function update_dhcp_conf {

   186

    local out="$1"

   187

    local src="$2"

   188

   189

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

   190

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

   191

   192

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

   193

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

   194

    else

   195

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

   196

    fi

   197

}

   198

   199

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

   200

#

   201

#   check_hosts     .../hosts

   202

function check_hosts {

   203

    local hosts=$1; shift 1

   204

   205

    # TODO

   206

    check $hosts \

   207

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

   208

}

   209

   210

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

   211

#

   212

#   check_zone      ..../$zone $origin

   213

function check_zone {

   214

    local zone=$1

   215

    local origin=$2

   216

   217

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

   218

   219

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

   220

    check $zone $NAMED_CHECKZONE $origin $zone

   221

}

   222

   223

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

   224

#

   225

#   check_dhcp      [$conf]

   226

#

   227

# Defaults to the global $DHCPD_CONF.

   228

# Fails if the check fails.

   229

function check_dhcp {

   230

    local conf=${1:-$DHCPD_CONF}

   231

   232

    log_check "Checking DHCP $conf..." 

   233

   234

    if [ ! -e $DHCPD ]; then

   235

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

   236

        return 0

   237

    fi

   238

   239

    check $conf \

   240

        $DHCPD -cf $conf -t

   241

}

   242

   243

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

   244

#

   245

#   check_dhcp_conf     $conf

   246

#

   247

function check_dhcp_conf {

   248

    local conf=$1;

   249

   250

    check_dhcp $DHCP_DATA/$conf.conf

   251

}

   252

   253

### Deploy

   254

## Run rndc reload

   255

function do_reload_zones {

   256

    # run

   257

    indent "        rndc: " \

   258

        $RNDC reload

   259

   260

    # set flag

   261

    RELOAD_ZONES=y

   262

}

   263

   264

## Load update zonefiles into bind:

   265

#

   266

#   reload_zones    

   267

#

   268

# Invokes `rndc reload`, showing its output.

   269

function reload_zones {

   270

    local msg="Reload zones"

   271

   272

    if [ $RELOAD_FORCE ]; then

   273

        log_force  "$msg..."

   274

   275

        do_reload_zones

   276

   277

    elif [ $RELOAD_NOOP ]; then

   278

        log_noop    "$msg: skipped"

   279

   280

    elif [ ! -e $RNDC ]; then

   281

        log_warn "reload_zones: rndc not installed, skipping"

   282

   283

    elif [ ! -e $RNDC_KEY ]; then

   284

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

   285

   286

    elif [ ! -r $RNDC_KEY ]; then

   287

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

   288

   289

        return 1

   290

   291

    else

   292

        log_update  "$msg..."

   293

   294

        # run

   295

        do_reload_zones

   296

    fi

   297

}

   298

   299

## Reload DHCP by restarting it, if running:

   300

#

   301

#   do_reload_dhcp

   302

#

   303

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

   304

function do_reload_dhcp {

   305

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

   306

        cmd $DHCPD_INIT restart

   307

    else

   308

        log_warn "dhcpd not running; did not restart"

   309

    fi

   310

}

   311

   312

## Reload dhcp hosts

   313

#

   314

#   reload_dhcp

   315

#

   316

# noop's if we haven't reloaded zones

   317

function reload_dhcp {

   318

    local msg="Reload DHCP hosts"

   319

   320

    if [ $RELOAD_FORCE ]; then

   321

        log_force  "$msg..."

   322

   323

        do_reload_dhcp

   324

   325

    elif [ $RELOAD_NOOP ]; then

   326

        log_noop    "$msg: skipped"

   327

   328

    elif [ ! -e $DHCPD ]; then

   329

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

   330

   331

    else

   332

        log_update  "$msg..."

   333

   334

        # run

   335

        do_reload_dhcp

   336

    fi

   337

}

   338

   339

### Commit

   340

## Perform `hg commit`

   341

function do_commit {

   342

    local repo=$1

   343

    local msg=$1

   344

   345

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

   346

   347

    hg_commit $repo "$msg"

   348

}

   349

   350

   351

## Commit changes to version control:

   352

#

   353

#   commit_data

   354

#

   355

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

   356

function commit {

   357

    local repo=$1

   358

    local commit_msg="$COMMIT_MSG"

   359

   360

    local msg="Commit changes"

   361

   362

    # operate?

   363

    if [ $COMMIT_FORCE ]; then

   364

        log_force   "$msg..."

   365

   366

        do_commit "$commit_msg"

   367

   368

    elif ! hg_modified $repo; then

   369

        log_warn    "$msg: no changes"

   370

   371

    elif [ $COMMIT_SKIP ]; then

   372

        log_noop    "$msg: skipped"

   373

   374

        # still show diff, though

   375

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

   376

    else

   377

        log_update  "$msg..."

   378

   379

        do_commit $repo "$commit_msg"

   380

    fi

   381

}