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

    38

    39

### Command-line argument handling

    40

    41

IS_TTY=

    42

    43

## Options

    44

LOG_ERROR=y

    45

LOG_WARN=y

    46

LOG=y

    47

LOG_FORCE=y

    48

LOG_UPDATE=y

    49

LOG_NOOP=y

    50

LOG_SKIP=

    51

LOG_DEBUG=

    52

LOG_CMD=

    53

    54

UPDATE_FORCE=

    55

UPDATE_NOOP=

    56

UPDATE_DIFF=

    57

    58

SERIAL_NOOP=

    59

SERIAL_FORCE=

    60

    61

COMMIT_SKIP=

    62

COMMIT_FORCE=

    63

COMMIT_MSG=' '

    64

    65

DEPLOY_SKIP=

    66

    67

## Output command-line argument help.

    68

function help_args {

    69

    local prog=$1

    70

    71

    cat <<END

    72

Usage: $prog [options]

    73

    74

General:

    75

    -h      display this help text

    76

    -d DIR  datadir

    77

    78

Logging:    

    79

    -q      quiet

    80

    -v      verbose

    81

    -D      debug

    82

    -V      debug commands

    83

    84

Updates:

    85

    -p      show changes

    86

    -F      force-updates without checking src mtime

    87

    -S      do not update serial

    88

    -s      update serials

    89

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

    90

    91

Commit    

    92

    -C      do not commit changes

    93

    -c      commit changes

    94

    -m MSG  commit message

    95

END

    96

}

    97

    98

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

    99

function parse_args {

   100

    OPTIND=1

   101

   102

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

   103

        case $opt in

   104

            h)  

   105

                help_args $0

   106

                exit 0

   107

            ;;

   108

   109

            d)  ROOT="$OPTARG" ;;

   110

   111

            q)  

   112

                LOG= 

   113

                LOG_WARN=

   114

                LOG_UPDATE=

   115

                LOG_FORCE=

   116

                LOG_NOOP=

   117

                ;;

   118

   119

            v)  LOG_SKIP=y ;;

   120

            D)  

   121

                LOG_DEBUG=y

   122

                LOG_INFO=y

   123

                ;;

   124

            V)  LOG_CMD=y ;;

   125

   126

            p)  UPDATE_DIFF=y   ;;

   127

            F)  UPDATE_FORCE=y  ;;

   128

            S)  SERIAL_NOOP=y   ;;

   129

            s)  SERIAL_FORCE=y  ;;

   130

   131

            n)  

   132

                UPDATE_NOOP=y 

   133

                # implies -Sp

   134

                UPDATE_DIFF=y

   135

                SERIAL_NOUPDATE=y

   136

                COMMIT_SKIP=y

   137

                DEPLOY_SKIP=y

   138

                ;;

   139

   140

            C)  COMMIT_SKIP=y ;;

   141

            c)  COMMIT_FORCE=y ;;

   142

            m)  COMMIT_MSG="$OPTARG" ;;

   143

   144

            ?)  

   145

                die 

   146

            ;;

   147

        esac

   148

   149

    done

   150

}

   151

   152

### Logging

   153

# Output message to stderr.

   154

function log_msg {

   155

    echo "$*" >&2

   156

}

   157

   158

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

   159

function log_color {

   160

    local code=$1; shift

   161

   162

    if [ $IS_TTY ]; then

   163

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

   164

    else

   165

        echo "$*" >&2

   166

    fi

   167

}

   168

   169

## Log at various log-levels

   170

   171

function log_error {

   172

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

   173

}

   174

   175

function log_warn {

   176

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

   177

}

   178

   179

# plain

   180

function log {

   181

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

   182

}

   183

   184

function log_force {

   185

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

   186

}

   187

   188

function log_update {

   189

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

   190

}

   191

   192

function log_noop {

   193

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

   194

}

   195

   196

function log_skip {

   197

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

   198

}

   199

   200

function log_debug {

   201

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

   202

}

   203

   204

function log_cmd {

   205

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

   206

}

   207

   208

# Output stacktrace, broken.

   209

function log_stack {

   210

    local level=1

   211

   212

    while info=$(caller $level); do

   213

        echo $info | read line sub file

   214

   215

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

   216

   217

        level=$(($level + 1))

   218

    done

   219

}

   220

   221

# Output calling function's name.

   222

function func_caller {

   223

    caller 1 | cut -d ' ' -f 2

   224

}

   225

   226

### High-level logging output

   227

# Log with func_caller at log_debug

   228

function debug {

   229

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

   230

   231

    log_debug "$prefix: $*"

   232

}

   233

   234

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

   235

function fail {

   236

    log_error "$(func_caller): $*"

   237

   238

    exit 2

   239

}

   240

   241

# Log at log_error and exit

   242

function die {

   243

    log_error "$*"

   244

    exit 1

   245

}

   246

   247

### Command execution

   248

## Execute command, possibly logging its execution.

   249

#

   250

#   cmd     $cmd...

   251

#

   252

# Fails if the command returns an error exit code.

   253

function cmd {

   254

    log_cmd "$@"

   255

   256

    "$@" || die "Failed"

   257

}

   258

   259

function indent () {

   260

    local indent=$1; shift

   261

   262

    log_cmd "$@"

   263

   264

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

   265

   266

    return ${PIPESTATUS[0]}

   267

}

   268

   269

   270

### FS utils

   271

# Create dir in $ROOT if not exists.

   272

function ensure_dir {

   273

    local dir=$1

   274

   275

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

   276

        log_warn "Creating output dir: $dir"

   277

        cmd mkdir $ROOT/$dir

   278

    fi

   279

}

   280

   281

## Output absolute path from $ROOT:

   282

#

   283

#   abspath $path

   284

#

   285

function abspath () {

   286

    local path=$1

   287

   288

    echo "$ROOT/$path"

   289

}

   290

   291

### HG wrappers

   292

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

   293

function hg {

   294

    local repo=$REPO; shift

   295

   296

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

   297

}

   298

   299

# Does the repo have local modifications?

   300

function hg_modified {

   301

    hg id | grep -q '+'

   302

}

   303

   304

# Output possible -u flag for commit.

   305

function hg_user {

   306

    if [ ${SUDO_USER:-} ]; then

   307

        echo '-u' "$SUDO_USER"

   308

   309

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

   310

        debug "using .hgrc user"

   311

        echo ''

   312

   313

    else

   314

        echo '-u' "$USER"

   315

    fi

   316

}

   317

   318

# Show changes in repo

   319

function hg_diff {

   320

    hg diff

   321

}

   322

   323

## Commit changes in repo, with given message:

   324

#

   325

#   hg_commit   $msg

   326

#

   327

function hg_commit {

   328

    local msg=$1

   329

    local user_opt=$(hg_user)

   330

   331

    debug "$user_opt: $msg"

   332

    hg commit $user_opt -m "$msg"

   333

}

   334

   335

   336

### Dependency-based updates

   337

   338

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

   339

#

   340

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

   341

#

   342

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

   343

function check_update {

   344

    # target

   345

    local out=$1; shift

   346

   347

    debug "$out"

   348

   349

    # need update?

   350

    local update=

   351

   352

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

   353

        debug "  update: unknown deps"

   354

        update=y

   355

   356

    elif [ ! -e $out ]; then

   357

        debug "  update: dest missing"

   358

        update=y

   359

   360

    elif [ $UPDATE_FORCE ]; then

   361

        debug "  update: forced"

   362

        update=y

   363

    fi

   364

   365

    # check deps

   366

    for dep in "$@"; do

   367

        # don't bother checking if already figured out

   368

        [ $update ] && continue

   369

   370

        # check

   371

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

   372

            fail "$dst: Missing source: $dep"

   373

   374

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

   375

            debug "  update: $dep"

   376

            update=y

   377

        else

   378

            debug "  check: $dep"

   379

        fi

   380

    done

   381

   382

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

   383

   384

    # return

   385

    [ $update ]

   386

}

   387

   388

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

   389

#

   390

#   do_update $out $BIN/cmd --args

   391

#

   392

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

   393

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

   394

function do_update {

   395

    local out=$1; shift

   396

    local tmp=$out.new

   397

   398

    debug "$out"

   399

    cmd "$@" > $ROOT/$tmp

   400

   401

    # compare

   402

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

   403

        debug "  changes:"

   404

   405

        # terse

   406

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

   407

    fi

   408

   409

    # deploy

   410

    if [ $UPDATE_NOOP ]; then

   411

        # cleanup

   412

        debug "  no-op"

   413

   414

        cmd rm $ROOT/$tmp

   415

    else

   416

        # commit

   417

        debug "  deploy"

   418

   419

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

   420

    fi

   421

}

   422

   423

## Look for a link target:

   424

#

   425

#   find_link   $lnk    $tgt...

   426

#

   427

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

   428

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

   429

function choose_link {

   430

    local lnk=$1; shift

   431

    local tgt=-

   432

   433

    for tgt in "$@"; do

   434

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

   435

    done

   436

   437

    echo $tgt

   438

}

   439

   440

   441

## Compare symlink to target:

   442

#

   443

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

   444

#

   445

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

   446

# Fails if the target does not exist.

   447

function check_link {

   448

    local lnk=$1

   449

    local tgt=$2

   450

   451

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

   452

   453

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

   454

}

   455

   456

## Update symlink to point to target:

   457

#

   458

#   do_link $lnk $tgt

   459

#

   460

function do_link {

   461

    local lnk=$1

   462

    local tgt=$2

   463

   464

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

   465

}

   466

   467

## Update .serial number:

   468

#

   469

#   do_update_serial $serial

   470

#

   471

# Shows old/new serial on debug.

   472

function do_update_serial {

   473

    local serial=$1

   474

   475

    # read

   476

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

   477

   478

   479

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

   480

   481

    # read

   482

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

   483

   484

    debug "  $old -> $new"