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

## 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 $out $src

    69

}

    70

    71

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

    72

#

    74

function update_hosts_forward {

    78

    81

    86

    87

    else

    89

    fi

    90

}

    91

    92

function update_hosts_dhcp {

    95

    97

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

    98

   102

    else

   103

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

   104

    fi

   105

}

   106

   128

## Update .serial number:

   129

#

   130

#   do_update_serial $serial

   131

#

   132

# Shows old/new serial on debug.

   133

function do_update_serial {

   134

    local serial=$1

   135

   136

    # read

   137

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

   138

   139

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

   140

   141

    # read

   142

    local new=$(cat $serial)

   143

   144

    debug "  $old -> $new"

   145

}

   146

   147

   148

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

   149

#

   150

#   update_serial   $zone   $deps...

   151

#

   152

# Supports SERIAL_FORCE/NOOP.

   153

# Updates $SERIALS/$zone.serial.

   154

function update_serial {

   155

    local serial=$1; shift

   156

   157

    # test

   158

    if [ $SERIAL_FORCE ]; then

   159

        log_force "Updating $serial: forced"

   160

   161

        do_update_serial $serial

   162

   163

    elif ! check_update $serial "$@"; then

   164

        log_skip "Updating $serial: not changed"

   165

   166

    elif [ $SERIAL_NOOP ]; then

   167

        log_noop "Updating $serial: skipped"

   168

   169

    else

   170

        log_update "Updating $serial..."

   171

   172

        do_update_serial $serial

   173

    fi

   174

}

   175

   176

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

   177

#

   178

#   link_serial $zone $base

   179

function link_serial {

   180

    local zone=$1

   181

    local base=$2

   182

   183

    local out=$SERIALS/$zone.serial

   184

    local tgt=$SERIALS/$base.serial

   185

   186

    link $out $tgt

   187

}

   188

   189

## Update zone file verbatim from source:

   190

#

   191

#   copy_zone   $view   $zone   [$base]

   192

#

   193

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

   194

function copy_zone {

   195

    local view=$1

   196

    local zone=$2

   197

    local base=${3:-$zone}

   198

   199

    local out=$ZONES/$view/$zone

   200

    local src=$DATA/$base

   201

   202

    copy $out $src

   203

}

   204

   205

## Return the first zone that exists under $DATA/$name.zone

   206

#

   207

#   base=$(choose_zone $name...)

   208

function choose_zone {

   209

    # look

   210

    for name in "$@"; do

   211

        if [ $name ] && [ -e $DATA/$name.zone ]; then

   212

            echo $name

   213

            return 0

   214

        fi

   215

    done

   216

   217

    # failed to find

   218

    die "Unable to find zone in $DATA/*.zone: $@"

   219

}

   220

   221

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

   222

#

   223

#   update_zone $view   $zone   [$base]

   224

function update_zone {

   225

    local out=$1

   226

    local src=$2

   227

    local serial=$3

   228

   229

    if check_update $out $src $serial; then

   230

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

   231

   232

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

   233

                --serial $(cat $serial)

   234

    else

   235

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

   236

    fi

   237

}

   238

   239

## Link zone file to ues given shared zone.

   240

#

   241

#   link_zone   $view   $zone   [$base]

   242

#

   243

# Looks for shared zone at:

   244

#   $ZONES/$view/$base

   245

#   $ZONES/common/$base

   246

function link_zone {

   247

    local view=$1

   248

    local zone=$2

   249

    local base=${3:-$zone}

   250

   251

    local out=$ZONES/$view/$zone

   252

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

   253

   254

    link $out $tgt

   255

}

   256

   257

## Link dhcp file directly from data to $DHCP

   258

function link_dhcp_conf {

   259

    local conf=$1

   260

    local base=${2:-$conf}

   261

   262

    local out=$DHCP/$conf.conf

   263

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

   264

   265

    link $out $tgt

   266

}

   267

   268

## Copy dhcp conf from data to $DHCP

   269

function copy_dhcp_conf {

   270

    local conf=$1

   271

    local base=${2:-$conf}

   272

   273

    local out=$DHCP/$conf.conf

   274

    local src=$DHCP_DATA/$base.conf

   275

   276

    copy $out $src

   277

}

   278

   279

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

   280

#

   281

#   check_hosts     .../hosts

   282

function check_hosts {

   283

    local hosts=$1; shift 1

   284

   285

    # TODO

   286

    check $hosts \

   287

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

   288

}

   289

   290

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

   291

#

   292

#   check_zone      ..../$zone $origin

   293

function check_zone {

   294

    local zone=$1

   295

    local origin=$2

   296

   297

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

   298

    check $zone $NAMED_CHECKZONE $origin $zone

   299

}

   300

   301

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

   302

#

   303

#   check_dhcp      [$conf]

   304

#

   305

# Defaults to the global $DHCPD_CONF.

   306

# Fails if the check fails.

   307

function check_dhcp {

   308

    local conf=${1:-$DHCPD_CONF}

   309

   310

    if [ ! -e $DHCPD ]; then

   311

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

   312

        return 0

   313

    fi

   314

   315

    check $conf \

   316

        $DHCPD -cf $conf -t

   317

}

   318

   319

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

   320

#

   321

#   check_dhcp_conf     $conf

   322

#

   323

function check_dhcp_conf {

   324

    local conf=$1;

   325

   326

    check_dhcp $DHCP_DATA/$conf.conf

   327

}

   328

   329

### Deploy

   330

## Run rndc reload

   331

function do_reload_zones {

   332

    # run

   333

    indent "        rndc: " \

   334

        $RNDC reload

   335

   336

    # set flag

   337

    RELOAD_ZONES=y

   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

   351

        do_reload_zones

   352

   353

    elif [ $RELOAD_NOOP ]; then

   354

        log_noop    "$msg: skipped"

   355

   356

    elif [ ! -e $RNDC ]; then

   357

        log_warn "reload_zones: rndc not installed, skipping"

   358

   359

    elif [ ! -e $RNDC_KEY ]; then

   360

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

   361

   362

    elif [ ! -r $RNDC_KEY ]; then

   363

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

   364

   365

        return 1

   366

   367

    else

   368

        log_update  "$msg..."

   369

   370

        # run

   371

        do_reload_zones

   372

    fi

   373

}

   374

   375

## Reload DHCP by restarting it, if running:

   376

#

   377

#   do_reload_dhcp

   378

#

   379

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

   380

function do_reload_dhcp {

   381

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

   382

        cmd $DHCPD_INIT restart

   383

    else

   384

        log_warn "dhcpd not running; did not restart"

   385

    fi

   386

}

   387

   388

## Reload dhcp hosts

   389

#

   390

#   reload_dhcp

   391

#

   392

# noop's if we haven't reloaded zones

   393

function reload_dhcp {

   394

    local msg="Reload DHCP hosts"

   395

   396

    if [ $RELOAD_FORCE ]; then

   397

        log_force  "$msg..."

   398

   399

        do_reload_dhcp

   400

   401

    elif [ $RELOAD_NOOP ]; then

   402

        log_noop    "$msg: skipped"

   403

   404

    elif [ ! -e $DHCPD ]; then

   405

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

   406

   407

    else

   408

        log_update  "$msg..."

   409

   410

        # run

   411

        do_reload_dhcp

   412

    fi

   413

}

   414

   415

### Commit

   416

## Perform `hg commit`

   417

function do_commit {

   418

    local msg=$1

   419

   420

    [ $LOG_DIFF ] && indent "    " hg_diff

   421

   422

    hg_commit "$msg"

   423

}

   424

   425

   426

## Commit changes to version control:

   427

#

   428

#   commit_data

   429

#

   430

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

   431

function commit_data {

   432

    local commit_msg="$COMMIT_MSG"

   433

   434

    local msg="Commit changes"

   435

   436

    # operate?

   437

    if [ $COMMIT_FORCE ]; then

   438

        log_force   "$msg..."

   439

   440

        do_commit "$commit_msg"

   441

   442

    elif ! hg_modified; then

   443

        log_skip    "$msg: no changes"

   444

   445

    elif [ $COMMIT_SKIP ]; then

   446

        log_noop    "$msg: skipped"

   447

   448

        # still show diff, though

   449

        [ $LOG_DIFF ] && indent "    " hg_diff

   450

    else

   451

        log_update  "$msg..."

   452

   453

        do_commit "$commit_msg"

   454

    fi

   455

}