1

#!/bin/bash

     2

# vim: set ft=sh :

     3

     4

set -ue

     5

     6

     7

### Paths

     8

ROOT=$(pwd)

     9

    10

# resolve $0

    11

self=$0

    12

while [ -L $self ]; do

    13

    tgt=$(readlink $self)

    14

    15

    if [ "${tgt:0:1}" == "/" ]; then

    16

        self=$tgt

    17

    else

    18

        self=$(dirname $self)/$tgt

    19

    fi

    20

done

    21

    22

# Our bin dir, with scripts

    23

BIN=$(dirname $self)

    24

    25

# Data files

    26

DATA=settings

    27

ZONES=zones

    28

SERIALS=$DATA

    29

REPO=

    30

    31

# Script/data args

    32

PROCESS_ARGS='--input-charset latin-1'

    33

    34

# external progs

    35

NAMED_CHECKZONE=/usr/sbin/named-checkzone

    36

HG=/usr/bin/hg

    37

RNDC=/usr/sbin/rndc

    39

    40

### Command-line argument handling

    41

    42

IS_TTY=

    43

    44

## Options

    45

LOG_ERROR=y

    46

LOG_WARN=y

    47

LOG=y

    48

LOG_FORCE=y

    49

LOG_UPDATE=y

    50

LOG_NOOP=y

    51

LOG_SKIP=

    52

LOG_DEBUG=

    53

LOG_CMD=

    54

    55

UPDATE_FORCE=

    56

UPDATE_NOOP=

    57

UPDATE_DIFF=

    58

    59

SERIAL_NOOP=

    60

SERIAL_FORCE=

    61

    62

COMMIT_SKIP=

    63

COMMIT_FORCE=

    64

COMMIT_MSG=' '

    65

    66

DEPLOY_SKIP=

    67

    68

## Output command-line argument help.

    69

function help_args {

    70

    local prog=$1

    71

    72

    cat <<END

    73

Usage: $prog [options]

    74

    75

General:

    76

    -h      display this help text

    77

    -d DIR  datadir

    78

    79

Logging:    

    80

    -q      quiet

    81

    -v      verbose

    82

    -D      debug

    83

    -V      debug commands

    84

    85

Updates:

    86

    -p      show changes

    87

    -F      force-updates without checking src mtime

    88

    -S      do not update serial

    89

    -s      update serials

    90

    -n      no-op/mock-update; don't actually change anything; implies -SpC

    91

    92

Commit    

    93

    -C      do not commit changes

    94

    -c      commit changes

    95

    -m MSG  commit message

    96

END

    97

}

    98

    99

## Parse any command-line arguments, setting the global options vars.

   100

function parse_args {

   101

    OPTIND=1

   102

   103

    while getopts 'hd:qvDVpFSsnCcm:' opt "$@"; do

   104

        case $opt in

   105

            h)  

   106

                help_args $0

   107

                exit 0

   108

            ;;

   109

   110

            d)  ROOT="$OPTARG" ;;

   111

   112

            q)  

   113

                LOG= 

   114

                LOG_WARN=

   115

                LOG_UPDATE=

   116

                LOG_FORCE=

   117

                LOG_NOOP=

   118

                ;;

   119

   120

            v)  LOG_SKIP=y ;;

   121

            D)  

   122

                LOG_DEBUG=y

   123

                LOG_INFO=y

   124

                ;;

   125

            V)  LOG_CMD=y ;;

   126

   127

            p)  UPDATE_DIFF=y   ;;

   128

            F)  UPDATE_FORCE=y  ;;

   129

            S)  SERIAL_NOOP=y   ;;

   130

            s)  SERIAL_FORCE=y  ;;

   131

   132

            n)  

   133

                UPDATE_NOOP=y 

   134

                # implies -Sp

   135

                UPDATE_DIFF=y

   136

                SERIAL_NOUPDATE=y

   137

                COMMIT_SKIP=y

   138

                DEPLOY_SKIP=y

   139

                ;;

   140

   141

            C)  COMMIT_SKIP=y ;;

   142

            c)  COMMIT_FORCE=y ;;

   143

            m)  COMMIT_MSG="$OPTARG" ;;

   144

   145

            ?)  

   146

                die 

   147

            ;;

   148

        esac

   149

   150

    done

   151

}

   152

   153

### Logging

   154

# Output message to stderr.

   155

function log_msg {

   156

    echo "$*" >&2

   157

}

   158

   159

# Output message to stderr, optionally with given color, if TTY.

   160

function log_color {

   161

    local code=$1; shift

   162

   163

    if [ $IS_TTY ]; then

   164

        echo $'\e['${code}'m'"$*"$'\e[00m' >&2

   165

    else

   166

        echo "$*" >&2

   167

    fi

   168

}

   169

   170

## Log at various log-levels

   171

   172

function log_error {

   173

    [ $LOG_ERROR ] && log_color '31' "$*"

   174

}

   175

   176

function log_warn {

   177

    [ $LOG_WARN ] && log_color '33' "$*" || true

   178

}

   179

   180

# plain

   181

function log {

   182

    [ $LOG ] && log_msg "$*" || true

   183

}

   184

   185

function log_force {

   186

    [ $LOG_FORCE ] && log_color '2;33' "  $*" || true

   187

}

   188

   189

function log_update {

   190

    [ $LOG_UPDATE ] && log_color '36' "  $*" || true

   191

}

   192

   193

function log_noop {

   194

    [ $LOG_NOOP ] && log_color '2;34' "  $*" || true

   195

}

   196

   197

function log_skip {

   198

    [ $LOG_SKIP ] && log_color '1;34' "  $*" || true

   199

}

   200

   201

function log_debug {

   202

    [ $LOG_DEBUG ] && log_color 32 "    $*" || true

   203

}

   204

   205

function log_cmd {

   206

    [ $LOG_CMD ] && log_color 35 "        \$ $*" || true

   207

}

   208

   209

# Output stacktrace, broken.

   210

function log_stack {

   211

    local level=1

   212

   213

    while info=$(caller $level); do

   214

        echo $info | read line sub file

   215

   216

        log_msg "$file:$lineno $sub()"

   217

   218

        level=$(($level + 1))

   219

    done

   220

}

   221

   222

# Output calling function's name.

   223

function func_caller {

   224

    caller 1 | cut -d ' ' -f 2

   225

}

   226

   227

### High-level logging output

   228

# Log with func_caller at log_debug

   229

function debug {

   230

    printf -v prefix "%s" $(func_caller)

   231

   232

    log_debug "$prefix: $*"

   233

}

   234

   235

# Log with func_caller at log_error and exit, intended for internal errors...

   236

function fail {

   237

    log_error "$(func_caller): $*"

   238

   239

    exit 2

   240

}

   241

   242

# Log at log_error and exit

   243

function die {

   244

    log_error "$*"

   245

    exit 1

   246

}

   247

   248

### Command execution

   249

## Execute command, possibly logging its execution.

   250

#

   251

#   cmd     $cmd...

   252

#

   253

# Fails if the command returns an error exit code.

   254

function cmd {

   255

    log_cmd "$@"

   256

   257

    "$@" || die "Failed"

   258

}

   259

   260

function indent () {

   261

    local indent=$1; shift

   262

   263

    log_cmd "$@"

   264

   265

    "$@" | sed "s/^/$indent/"

   266

   267

    return ${PIPESTATUS[0]}

   268

}

   269

   270

   271

### FS utils

   272

# Create dir in $ROOT if not exists.

   273

function ensure_dir {

   274

    local dir=$1

   275

   276

    if [ ! -d $ROOT/$dir ]; then

   277

        log_warn "Creating output dir: $dir"

   278

        cmd mkdir $ROOT/$dir

   279

    fi

   280

}

   281

   282

## Output absolute path from $ROOT:

   283

#

   284

#   abspath $path

   285

#

   286

function abspath () {

   287

    local path=$1

   288

   289

    echo "$ROOT/$path"

   290

}

   291

   292

### HG wrappers

   293

# Run `hg ...` within $REPO.

   294

function hg {

   295

    local repo=$REPO; shift

   296

   297

    cmd $HG -R $ROOT/$repo "$@"

   298

}

   299

   300

# Does the repo have local modifications?

   301

function hg_modified {

   302

    hg id | grep -q '+'

   303

}

   304

   305

# Output possible -u flag for commit.

   306

function hg_user {

   307

    if [ ${SUDO_USER:-} ]; then

   308

        echo '-u' "$SUDO_USER"

   309

   310

    elif [ $HOME ] && [ -e $HOME/.hgrc ]; then

   311

        debug "using .hgrc user"

   312

        echo ''

   313

   314

    else

   315

        echo '-u' "$USER"

   316

    fi

   317

}

   318

   319

# Show changes in repo

   320

function hg_diff {

   321

    hg diff

   322

}

   323

   324

## Commit changes in repo, with given message:

   325

#

   326

#   hg_commit   $msg

   327

#

   328

function hg_commit {

   329

    local msg=$1

   330

    local user_opt=$(hg_user)

   331

   332

    debug "$user_opt: $msg"

   333

    hg commit $user_opt -m "$msg"

   334

}

   335

   336

   337

### Dependency-based updates

   338

   339

## Compare the given output file with all given source files:

   340

#

   341

#   check_update $out ${deps[@]} && do_update $out ... || ...

   342

#

   343

# Returns true if the output file needs to be updated.

   344

function check_update {

   345

    # target

   346

    local out=$1; shift

   347

   348

    debug "$out"

   349

   350

    # need update?

   351

    local update=

   352

   353

    if [ ${#@} == 0 ]; then

   354

        debug "  update: unknown deps"

   355

        update=y

   356

   357

    elif [ ! -e $out ]; then

   358

        debug "  update: dest missing"

   359

        update=y

   360

   361

    elif [ $UPDATE_FORCE ]; then

   362

        debug "  update: forced"

   363

        update=y

   364

    fi

   365

   366

    # check deps

   367

    for dep in "$@"; do

   368

        # don't bother checking if already figured out

   369

        [ $update ] && continue

   370

   371

        # check

   372

        if [ ! -e $ROOT/$dep ]; then

   373

            fail "$dst: Missing source: $dep"

   374

   375

        elif [ $ROOT/$out -ot $ROOT/$dep ]; then

   376

            debug "  update: $dep"

   377

            update=y

   378

        else

   379

            debug "  check: $dep"

   380

        fi

   381

    done

   382

   383

    [ ! $update ] && debug "  up-to-date"

   384

   385

    # return

   386

    [ $update ]

   387

}

   388

   389

## Generate updated output file from given command's stdout:

   390

#

   391

#   do_update $out $BIN/cmd --args

   392

#

   393

# Writes output to a temporary .new file, optionally shows a diff of changes, and commits

   394

# the new version to $out (unless noop'd).

   395

function do_update {

   396

    local out=$1; shift

   397

    local tmp=$out.new

   398

   399

    debug "$out"

   400

    cmd "$@" > $ROOT/$tmp

   401

   402

    # compare

   403

    if [ -e $ROOT/$out ] && [ $UPDATE_DIFF ]; then

   404

        debug "  changes:"

   405

   406

        # terse

   407

        indent "        " diff --unified=1 $ROOT/$out $ROOT/$tmp || true

   408

    fi

   409

   410

    # deploy

   411

    if [ $UPDATE_NOOP ]; then

   412

        # cleanup

   413

        debug "  no-op"

   414

   415

        cmd rm $ROOT/$tmp

   416

    else

   417

        # commit

   418

        debug "  deploy"

   419

   420

        cmd mv $ROOT/$tmp $ROOT/$out

   421

    fi

   422

}

   423

   424

## Look for a link target:

   425

#

   426

#   find_link   $lnk    $tgt...

   427

#

   428

# Outputs the first given target to exist, skipping any that are the same as the given $lnk.

   429

# If no $tgt matches, outputs the last one, or '-'.

   430

function choose_link {

   431

    local lnk=$1; shift

   432

    local tgt=-

   433

   434

    for tgt in "$@"; do

   435

        [ $tgt != $out ] && [ -e $ROOT/$tgt ] && break

   436

    done

   437

   438

    echo $tgt

   439

}

   440

   441

   442

## Compare symlink to target:

   443

#

   444

#   check_link $lnk $tgt && do_link $lnk $tgt || ...

   445

#

   446

# Tests if the symlink exists, and the target matches.

   447

# Fails if the target does not exist.

   448

function check_link {

   449

    local lnk=$1

   450

    local tgt=$2

   451

   452

    [ ! -e $ROOT/$tgt ] && fail "$tgt: target does not exist"

   453

   454

    [ ! -e $ROOT/$lnk ] || [ $(readlink $ROOT/$lnk) != $ROOT/$tgt ]

   455

}

   456

   457

## Update symlink to point to target:

   458

#

   459

#   do_link $lnk $tgt

   460

#

   461

function do_link {

   462

    local lnk=$1

   463

    local tgt=$2

   464

   465

    cmd ln -sf $ROOT/$tgt $ROOT/$lnk

   466

}

   467

   468

## Update .serial number:

   469

#

   470

#   do_update_serial $serial

   471

#

   472

# Shows old/new serial on debug.

   473

function do_update_serial {

   474

    local serial=$1

   475

   476

    # read

   477

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

   478

   479

   480

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

   481

   482

    # read

   483

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

   484