autocluster

   1 #!/bin/bash
   2 # main autocluster script
   3 #
   4 # Copyright (C) Andrew Tridgell  2008
   5 # Copyright (C) Martin Schwenke  2008
   6 #
   7 # This program is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program; if not, see <http://www.gnu.org/licenses/>.
  19
  20 ##BEGIN-INSTALLDIR-MAGIC##
  21 # There are better ways of doing this but not if you still want to be
  22 # able to run straight out of a git tree.  :-)
  23 if [ -f "$0" ]; then
  24     autocluster="$0"
  25 else
  26     autocluster=$(which "$0")
  27 fi
  28 if [ -L "$autocluster" ] ; then
  29     autocluster=$(readlink "$autocluster")
  30 fi
  31 installdir=$(dirname "$autocluster")
  32 ##END-INSTALLDIR-MAGIC##
  33
  34 ####################
  35 # show program usage
  36 usage ()
  37 {
  38     cat <<EOF
  39 Usage: autocluster [OPTION] ... <COMMAND>
  40   options:
  41      -c <file>                   specify config file (default is "config")
  42      -e <expr>                   execute <expr> and exit
  43      -E <expr>                   execute <expr> and continue
  44      -x                          enable script debugging
  45      --dump                      dump config settings and exit
  46
  47   configuration options:
  48 EOF
  49
  50     usage_config_options
  51
  52     cat <<EOF
  53
  54   commands:
  55      base [ create | boot ] ...
  56
  57      cluster [ build |
  58                destroy | undefine |
  59                create | update_hosts | boot | setup ] ...
  60
  61      create base
  62            create a base image
  63
  64      create cluster [ CLUSTERNAME ]
  65            create a full cluster
  66
  67      create node CLUSTERNAME IP_OFFSET
  68            (re)create a single cluster node
  69
  70      mount DISK
  71            mount a qemu disk on mnt/
  72
  73      unmount | umount
  74            unmount a qemu disk from mnt/
  75
  76      bootbase
  77            boot the base image
  78 EOF
  79     exit 1
  80 }
  81
  82 ###############################
  83
  84 die () {
  85     if [ "$no_sanity" = 1 ] ; then
  86         fill_text 0 "WARNING: $*" >&2
  87     else
  88         fill_text 0 "ERROR: $*" >&2
  89         exit 1
  90     fi
  91 }
  92
  93 announce ()
  94 {
  95     echo "######################################################################"
  96     printf "# %-66s #\n" "$*"
  97     echo "######################################################################"
  98     echo ""
  99 }
 100
 101 waitfor ()
 102 {
 103     local file="$1"
 104     local msg="$2"
 105     local timeout="$3"
 106
 107     local tmpfile=$(mktemp)
 108
 109     cat <<EOF >"$tmpfile"
 110 spawn tail -n 10000 -f $file
 111 expect -timeout $timeout -re "$msg"
 112 EOF
 113
 114     export LANG=C
 115     expect "$tmpfile"
 116     rm -f "$tmpfile"
 117
 118     if ! grep -E "$msg" "$file" > /dev/null; then
 119         echo "Failed to find \"$msg\" in \"$file\""
 120         return 1
 121     fi
 122
 123     return 0
 124 }
 125
 126 ###############################
 127
 128 # Indirectly call a function named by ${1}_${2}
 129 call_func () {
 130     local func="$1" ; shift
 131     local type="$1" ; shift
 132
 133     local f="${func}_${type}"
 134     if type -t "$f" >/dev/null && ! type -P "$f" >/dev/null ; then
 135         "$f" "$@"
 136     else
 137         f="${func}_DEFAULT"
 138         if type -t "$f" >/dev/null && ! type -P "$f" >/dev/null  ; then
 139             "$f" "$type" "$@"
 140         else
 141             die "No function defined for \"${func}\" \"${type}\""
 142         fi
 143     fi
 144 }
 145
 146 # Note that this will work if you pass "call_func f" because the first
 147 # element of the node tuple is the node type.  Nice...  :-)
 148 for_each_node ()
 149 {
 150     local n
 151     for n in $NODES ; do
 152         "$@" $(IFS=: ; echo $n)
 153     done
 154 }
 155
 156 node_is_ctdb_node_DEFAULT ()
 157 {
 158     echo 0
 159 }
 160
 161 hack_one_node_with ()
 162 {
 163     local filter="$1" ; shift
 164
 165     local node_type="$1"
 166     local ip_offset="$2"
 167     local name="$3"
 168     local ctdb_node="$4"
 169
 170     $filter
 171
 172     local item="${node_type}:${ip_offset}${name:+:}${name}${ctdb_node:+:}${ctdb_node}"
 173     nodes="${nodes}${nodes:+ }${item}"
 174 }
 175
 176 # This also gets used for non-filtering iteration.
 177 hack_all_nodes_with ()
 178 {
 179     local filter="$1"
 180
 181     local nodes=""
 182     for_each_node hack_one_node_with "$filter"
 183     NODES="$nodes"
 184 }
 185
 186 register_hook ()
 187 {
 188     local hook_var="$1"
 189     local new_hook="$2"
 190
 191     eval "$hook_var=\"${!hook_var}${!hook_var:+ }${new_hook}\""
 192 }
 193
 194 run_hooks ()
 195 {
 196     local hook_var="$1"
 197     shift
 198
 199     local i
 200     for i in ${!hook_var} ; do
 201         $i "$@"
 202     done
 203 }
 204
 205 # Use with care, since this may clear some autocluster defaults.!
 206 clear_hooks ()
 207 {
 208     local hook_var="$1"
 209
 210     eval "$hook_var=\"\""
 211 }
 212
 213 ##############################
 214
 215 # These hooks are intended to customise the value of $DISK.  They have
 216 # access to 1 argument ("base", "system", "shared") and the variables
 217 # $VIRTBASE, $CLUSTER, $BASENAME (for "base"), $NAME (for "system"),
 218 # $SHARED_DISK_NUM (for "shared").  A hook must be deterministic and
 219 # should not be stateful, since they can be called multiple times for
 220 # the same disk.
 221 hack_disk_hooks=""
 222
 223 create_node_DEFAULT ()
 224 {
 225     local type="$1"
 226     local ip_offset="$2"
 227     local name="$3"
 228     local ctdb_node="$4"
 229
 230     echo "Creating node \"$name\" (of type \"${type}\")"
 231
 232     create_node_COMMON "$name" "$ip_offset" "$type"
 233 }
 234
 235 # common node creation stuff
 236 create_node_COMMON ()
 237 {
 238     local NAME="$1"
 239     local ip_offset="$2"
 240     local type="$3"
 241     local template_file="${4:-$NODE_TEMPLATE}"
 242
 243     if [ "$SYSTEM_DISK_FORMAT" != "qcow2" -a "$BASE_FORMAT" = "qcow2" ] ; then
 244         die "Error: if BASE_FORMAT is \"qcow2\" then SYSTEM_DISK_FORMAT must also be \"qcow2\"."
 245     fi
 246
 247     local IPNUM=$(($FIRSTIP + $ip_offset))
 248     make_network_map
 249
 250     # Determine base image name.  We use $DISK temporarily to allow
 251     # the path to be hacked.
 252     local DISK="${VIRTBASE}/${BASENAME}.${BASE_FORMAT}"
 253     if [ "$BASE_PER_NODE_TYPE" = "yes" ] ; then
 254         DISK="${VIRTBASE}/${BASENAME}-${type}.${BASE_FORMAT}"
 255     fi
 256     run_hooks hack_disk_hooks "base"
 257     local base_disk="$DISK"
 258
 259     # Determine the system disk image name.
 260     DISK="${VIRTBASE}/${CLUSTER}/${NAME}.${SYSTEM_DISK_FORMAT}"
 261     run_hooks hack_disk_hooks "system"
 262
 263     local di="$DISK"
 264     if [ "$DISK_FOLLOW_SYMLINKS" = "yes" -a -L "$DISK" ] ; then
 265         di=$(readlink "$DISK")
 266     fi
 267     rm -f "$di"
 268     local di_dirname="${di%/*}"
 269     mkdir -p "$di_dirname"
 270
 271     case "$SYSTEM_DISK_FORMAT" in
 272         qcow2)
 273             echo "Creating the disk..."
 274             qemu-img create -b "$base_disk" -f qcow2 "$di"
 275             create_node_configure_image "$DISK" "$type"
 276             ;;
 277         raw)
 278             echo "Creating the disk..."
 279             cp -v --sparse=always "$base_disk" "$di"
 280             create_node_configure_image "$DISK" "$type"
 281             ;;
 282         reflink)
 283             echo "Creating the disk..."
 284             cp -v --reflink=always "$base_disk" "$di"
 285             create_node_configure_image "$DISK" "$type"
 286             ;;
 287         mmclone)
 288             echo "Creating the disk (using mmclone)..."
 289             local base_snap="${base_disk}.snap"
 290             [ -f "$base_snap" ] || mmclone snap "$base_disk" "$base_snap"
 291             mmclone copy "$base_snap" "$di"
 292             create_node_configure_image "$DISK" "$type"
 293             ;;
 294         none)
 295             echo "Skipping disk image creation as requested"
 296             ;;
 297         *)
 298             die "Error: unknown SYSTEM_DISK_FORMAT=\"${SYSTEM_DISK_FORMAT}\"."
 299     esac
 300
 301     # Pull the UUID for this node out of the map.
 302     UUID=$(awk "\$1 == $ip_offset {print \$2}" $uuid_map)
 303
 304     mkdir -p tmp
 305
 306     echo "Creating $NAME.xml"
 307     substitute_vars $template_file tmp/$NAME.xml
 308
 309     # install the XML file
 310     $VIRSH undefine $NAME > /dev/null 2>&1 || true
 311     $VIRSH define tmp/$NAME.xml
 312 }
 313
 314 create_node_configure_image ()
 315 {
 316     local disk="$1"
 317     local type="$2"
 318
 319     diskimage mount "$disk"
 320     setup_base "$type"
 321     diskimage unmount
 322 }
 323
 324 hack_network_map_hooks=""
 325
 326 # Uses: CLUSTER, NAME, NETWORKS, FIRSTIP, ip_offset
 327 make_network_map ()
 328 {
 329     network_map="tmp/network_map.$NAME"
 330
 331     if [ -n "$CLUSTER" ] ; then
 332         local md5=$(echo "$CLUSTER" | md5sum)
 333         local nh=$(printf "%02x" $ip_offset)
 334         local mac_prefix="02:${md5:0:2}:${md5:2:2}:00:${nh}:"
 335     else
 336         local mac_prefix="02:42:42:00:00:"
 337     fi
 338
 339     local n
 340     local count=1
 341     for n in $NETWORKS ; do
 342         local ch=$(printf "%02x" $count)
 343         local mac="${mac_prefix}${ch}"
 344
 345         set -- ${n//,/ }
 346         local ip_bits="$1" ; shift
 347         local dev="$1" ; shift
 348         local opts="$*"
 349
 350         local net="${ip_bits%/*}"
 351         local netname="acnet_${net//./_}"
 352
 353         local ip="${net%.*}.${IPNUM}"
 354         local mask="255.255.255.0"
 355
 356         # This can be used to override the variables in the echo
 357         # statement below.  The hook can use any other variables
 358         # available in this function.
 359         run_hooks hack_network_map_hooks
 360
 361         echo "${netname} ${dev} ${ip} ${mask} ${mac} ${opts}"
 362         count=$(($count + 1))
 363     done >"$network_map"
 364 }
 365
 366 ##############################
 367
 368 expand_nodes ()
 369 {
 370     # Expand out any abbreviations in NODES.
 371     local ns=""
 372     local n
 373     for n in $NODES ; do
 374         local t="${n%:*}"
 375         local ips="${n#*:}"
 376         case "$ips" in
 377             *,*)
 378                 local i
 379                 for i in ${ips//,/ } ; do
 380                     ns="${ns}${ns:+ }${t}:${i}"
 381                 done
 382                 ;;
 383             *-*)
 384                 local i
 385                 for i in $(seq ${ips/-/ }) ; do
 386                     ns="${ns}${ns:+ }${t}:${i}"
 387                 done
 388                 ;;
 389             *)
 390                 ns="${ns}${ns:+ }${n}"
 391         esac
 392     done
 393     NODES="$ns"
 394
 395     # Check IP addresses for duplicates.
 396     local ip_offsets=":"
 397     # This function doesn't modify anything...
 398     get_ip_offset ()
 399     {
 400         [ "${ip_offsets/${ip_offset}}" != "$ip_offsets" ] && \
 401             die "Duplicate IP offset in NODES - ${node_type}:${ip_offset}"
 402         ip_offsets="${ip_offsets}${ip_offset}:"
 403     }
 404     hack_all_nodes_with get_ip_offset
 405
 406     # Determine node names and whether they're in the CTDB cluster
 407     declare -A node_count
 408     _get_name_ctdb_node ()
 409     {
 410         local count=$((${node_count[$node_type]:-0} + 1))
 411         node_count[$node_type]=$count
 412         name=$(call_func node_name_format "$node_type" "$CLUSTER" $count) || {
 413             echo "ERROR: Node type \"${node_type}\" not defined!"
 414             echo "Valid node types are:"
 415             set | sed -n 's@^node_name_format_\(.*\) ().*@  \1@p'
 416             exit 1
 417         }
 418         ctdb_node=$(call_func node_is_ctdb_node "$node_type")
 419     }
 420     hack_all_nodes_with _get_name_ctdb_node
 421 }
 422
 423 ##############################
 424
 425 sanity_check_cluster_name ()
 426 {
 427     [ -z "${CLUSTER//[A-Za-z0-9]}" ] || \
 428         die "Cluster names should be restricted to the characters A-Za-z0-9.  \
 429 Some cluster filesystems have problems with other characters."
 430 }
 431
 432 hosts_file=
 433
 434 cluster_nodelist_hacking ()
 435 {
 436     # Rework the NODES list
 437     expand_nodes
 438
 439     # Build /etc/hosts and hack the names of the ctdb nodes
 440     hosts_line_hack_name ()
 441     {
 442         local sname=""
 443         local hosts_line
 444         local ip_addr="${NETWORK_PRIVATE_PREFIX}.$(($FIRSTIP + $ip_offset))"
 445
 446         # Primary name for CTDB nodes is <CLUSTER>n<num>
 447         if [ "$ctdb_node" = 1 ] ; then
 448             num_ctdb_nodes=$(($num_ctdb_nodes + 1))
 449             sname="${CLUSTER}n${num_ctdb_nodes}"
 450             hosts_line="$ip_addr ${sname}.${ld} ${name}.${ld} $name $sname"
 451             name="$sname"
 452         else
 453             hosts_line="$ip_addr ${name}.${ld} $name"
 454         fi
 455
 456         # This allows you to add a function to your configuration file
 457         # to modify hostnames (and other aspects of nodes).  This
 458         # function can access/modify $name (the existing name),
 459         # $node_type and $ctdb_node (1, if the node is a member of the
 460         # CTDB cluster, 0 otherwise).
 461         if [ -n "$HOSTNAME_HACKING_FUNCTION" ] ; then
 462             local old_name="$name"
 463             $HOSTNAME_HACKING_FUNCTION
 464             if [ "$name" != "$old_name" ] ; then
 465                 hosts_line="$ip_addr ${name}.${ld} $name"
 466             fi
 467         fi
 468
 469         echo "$hosts_line"
 470     }
 471     hosts_file="tmp/hosts.$CLUSTER"
 472     {
 473         local num_ctdb_nodes=0
 474         local ld=$(echo $DOMAIN | tr A-Z a-z)
 475         echo "# autocluster $CLUSTER"
 476         hack_all_nodes_with hosts_line_hack_name
 477         echo
 478     } >$hosts_file
 479
 480     # Build /etc/ctdb/nodes
 481     ctdb_nodes_line ()
 482     {
 483         [ "$ctdb_node" = 1 ] || return 0
 484         echo "${NETWORK_PRIVATE_PREFIX}.$(($FIRSTIP + $ip_offset))"
 485         num_nodes=$(($num_nodes + 1))
 486     }
 487     nodes_file="tmp/nodes.$CLUSTER"
 488     local num_nodes=0
 489     hack_all_nodes_with ctdb_nodes_line >$nodes_file
 490
 491     # Build UUID map
 492     uuid_map="tmp/uuid_map.$CLUSTER"
 493     uuid_map_line ()
 494     {
 495         echo "${ip_offset} $(uuidgen) ${node_type}"
 496     }
 497     hack_all_nodes_with uuid_map_line >$uuid_map
 498 }
 499
 500 create_cluster_hooks=
 501 cluster_created_hooks=
 502
 503 cluster_create ()
 504 {
 505     # Use $1.  If not set then use value from configuration file.
 506     CLUSTER="${1:-${CLUSTER}}"
 507     announce "cluster create \"${CLUSTER}\""
 508     [ -n "$CLUSTER" ] || die "\$CLUSTER not set"
 509
 510     sanity_check_cluster_name
 511
 512     mkdir -p $VIRTBASE/$CLUSTER $KVMLOG tmp
 513
 514     # Run hooks before doing anything else.
 515     run_hooks create_cluster_hooks
 516
 517     for_each_node call_func create_node
 518
 519     echo "Cluster $CLUSTER created"
 520     echo ""
 521
 522     run_hooks cluster_created_hooks
 523 }
 524
 525 cluster_created_hosts_message ()
 526 {
 527     echo "You may want to add this to your /etc/hosts file:"
 528     cat $hosts_file
 529 }
 530
 531 register_hook cluster_created_hooks cluster_created_hosts_message
 532
 533 cluster_destroy ()
 534 {
 535     announce "cluster destroy \"${CLUSTER}\""
 536     [ -n "$CLUSTER" ] || die "\$CLUSTER not set"
 537
 538     vircmd destroy "$CLUSTER" || true
 539 }
 540
 541 cluster_undefine ()
 542 {
 543     announce "cluster undefine \"${CLUSTER}\""
 544     [ -n "$CLUSTER" ] || die "\$CLUSTER not set"
 545
 546     vircmd undefine "$CLUSTER" || true
 547 }
 548
 549 cluster_update_hosts ()
 550 {
 551     announce "cluster update_hosts \"${CLUSTER}\""
 552     [ -n "$CLUSTER" ] || die "\$CLUSTER not set"
 553
 554     [ -n "$hosts_file" ] || hosts_file="tmp/hosts.${CLUSTER}"
 555     [ -r "$hosts_file" ] || die "Missing hosts file \"${hosts_file}\""
 556
 557     # Building a general node name regexp is a bit cumbersome.  :-)
 558     local name_regexp="("
 559     for i in $(set | sed -n -e "s@^\(node_name_format_.*\) ().*@\1@p") ; do
 560         # Format node name with placeholders (remembering that "_" is
 561         # not valid in a real cluster name)
 562         local t=$("$i" "_" "0")
 563         # now replace the placeholders with regexps - order is
 564         # important here, since the cluster name can contain digits
 565         t=$(sed -r -e "s@[[:digit:]]+@[[:digit:]]+@" -e "s@_@${CLUSTER}@" <<<"$t")
 566         # add to the regexp
 567         name_regexp="${name_regexp}${t}|"
 568     done
 569     name_regexp="${name_regexp}${CLUSTER}n[[:digit:]]+)"
 570
 571     local pat="# autocluster ${CLUSTER}\$|[[:space:]]${name_regexp}"
 572
 573     local t="/etc/hosts.${CLUSTER}"
 574     grep -E "$pat" /etc/hosts >"$t" || true
 575     if diff -B "$t" "$hosts_file" >/dev/null ; then
 576         rm "$t"
 577         return
 578     fi
 579
 580     local old=/etc/hosts.old.autocluster
 581     cp /etc/hosts "$old"
 582     local new=/etc/hosts.new
 583     grep -Ev "$pat" "$old" |
 584     cat -s - "$hosts_file" >"$new"
 585
 586     mv "$new" /etc/hosts
 587
 588     echo "Made these changes to /etc/hosts:"
 589     diff -u "$old" /etc/hosts || true
 590 }
 591
 592 cluster_boot ()
 593 {
 594     [ -n "$CLUSTER_PATTERN" ] || CLUSTER_PATTERN="$CLUSTER"
 595     announce "cluster boot \"${CLUSTER_PATTERN}\""
 596     [ -n "$CLUSTER_PATTERN" ] || die "\$CLUSTER_PATTERN not set"
 597
 598     vircmd start "$CLUSTER_PATTERN"
 599
 600     local nodes=$(vircmd dominfo "$CLUSTER_PATTERN" 2>/dev/null | \
 601         sed -n -e 's/Name: *//p')
 602
 603     # Wait for each node
 604     local i
 605     for i in $nodes ; do
 606         waitfor "${KVMLOG}/serial.$i" "login:" 300 || {
 607             vircmd destroy "$CLUSTER_PATTERN"
 608             die "Failed to create cluster"
 609         }
 610     done
 611
 612     # Move past the last line of log output
 613     echo ""
 614 }
 615
 616 cluster_setup_tasks_DEFAULT ()
 617 {
 618     local stage="$1"
 619
 620     # By default nodes have no tasks
 621     case "$stage" in
 622         install_packages) echo "" ;;
 623         setup_clusterfs)  echo "" ;;
 624         setup_node)       echo "" ;;
 625         setup_cluster)    echo "" ;;
 626     esac
 627 }
 628
 629 cluster_setup ()
 630 {
 631     announce "cluster setup \"${CLUSTER}\""
 632     [ -n "$CLUSTER" ] || die "\$CLUSTER not set"
 633
 634     local ssh="ssh -o StrictHostKeyChecking=no"
 635     local setup_clusterfs_done=false
 636     local setup_cluster_done=false
 637
 638     _cluster_setup_do_stage ()
 639     {
 640         local stage="$1"
 641         local type="$2"
 642         local ip_offset="$3"
 643         local name="$4"
 644         local ctdb_node="$5"
 645
 646         local tasks=$(call_func cluster_setup_tasks "$type" "$stage")
 647
 648         if [ -n "$tasks" ] ; then
 649             # These tasks are only done on 1 node
 650             case "$stage" in
 651                 setup_clusterfs)
 652                     if $setup_clusterfs_done ; then
 653                         return
 654                     else
 655                         setup_clusterfs_done=true
 656                     fi
 657                     ;;
 658                 setup_cluster)
 659                     if $setup_cluster_done ; then
 660                         return
 661                     else
 662                         setup_cluster_done=true
 663                     fi
 664                     ;;
 665             esac
 666
 667             $ssh "$name" ./scripts/cluster_setup.sh "$stage" $tasks
 668         fi
 669
 670     }
 671
 672     local stages="install_packages setup_clusterfs setup_node setup_cluster"
 673     local stage
 674     for stage in $stages ; do
 675         for_each_node _cluster_setup_do_stage "$stage"
 676     done
 677 }
 678
 679 create_one_node ()
 680 {
 681     CLUSTER="$1"
 682     local single_node_ip_offset="$2"
 683
 684     sanity_check_cluster_name
 685
 686     mkdir -p $VIRTBASE/$CLUSTER $KVMLOG tmp
 687
 688     for n in $NODES ; do
 689         set -- $(IFS=: ; echo $n)
 690         [ $single_node_ip_offset -eq $2 ] || continue
 691         call_func create_node "$@"
 692
 693         echo "Requested node created"
 694         echo ""
 695         echo "You may want to update your /etc/hosts file:"
 696         cat $hosts_file
 697
 698         break
 699     done
 700 }
 701
 702 ###############################
 703 # test the proxy setup
 704 test_proxy() {
 705     export http_proxy=$WEBPROXY
 706     wget -O /dev/null $INSTALL_SERVER || \
 707         die "Your WEBPROXY setting \"$WEBPROXY\" is not working"
 708     echo "Proxy OK"
 709 }
 710
 711 ###################
 712
 713 kickstart_floppy_create_hooks=
 714
 715 guess_install_network ()
 716 {
 717     # Figure out IP address to use during base install.  Default to
 718     # the IP address of the 1st (private) network. If a gateway is
 719     # specified then use the IP address associated with it.
 720     INSTALL_IP=""
 721     INSTALL_GW=""
 722     local netname dev ip mask mac opts
 723     while read netname dev ip mask mac opts; do
 724         local o
 725         for o in $opts ; do
 726             case "$o" in
 727                 gw\=*)
 728                     INSTALL_GW="${o#gw=}"
 729                     INSTALL_IP="$ip"
 730             esac
 731         done
 732         [ -n "$INSTALL_IP" ] || INSTALL_IP="$ip"
 733     done <"$network_map"
 734 }
 735
 736 # create base image
 737 base_create()
 738 {
 739     local NAME="$BASENAME"
 740     local DISK="${VIRTBASE}/${NAME}.${BASE_FORMAT}"
 741     run_hooks hack_disk_hooks "base"
 742
 743     mkdir -p $KVMLOG
 744
 745     echo "Testing WEBPROXY $WEBPROXY"
 746     test_proxy
 747
 748     local di="$DISK"
 749     if [ "$DISK_FOLLOW_SYMLINKS" = "yes" -a -L "$DISK" ] ; then
 750         di=$(readlink "$DISK")
 751     fi
 752     rm -f "$di"
 753     local di_dirname="${di%/*}"
 754     mkdir -p "$di_dirname"
 755
 756     echo "Creating the disk"
 757     qemu-img create -f $BASE_FORMAT "$di" $DISKSIZE
 758
 759     rm -rf tmp
 760     mkdir -p mnt tmp tmp/ISO
 761
 762     setup_timezone
 763
 764     IPNUM=$FIRSTIP
 765     make_network_map
 766
 767     guess_install_network
 768
 769     echo "Creating kickstart file from template"
 770     substitute_vars "$KICKSTART" "tmp/ks.cfg"
 771
 772     # $ISO gets $ISO_DIR prepended if it doesn't start with a leading '/'.
 773     case "$ISO" in
 774         (/*) : ;;
 775         (*) ISO="${ISO_DIR}/${ISO}"
 776     esac
 777
 778     echo "Creating kickstart floppy"
 779     dd if=/dev/zero of=tmp/floppy.img bs=1024 count=1440
 780     mkdosfs -n KICKSTART tmp/floppy.img
 781     mount -o loop -t msdos tmp/floppy.img mnt
 782     cp tmp/ks.cfg mnt
 783     mount -o loop,ro $ISO tmp/ISO
 784
 785     echo "Setting up bootloader"
 786     cp tmp/ISO/isolinux/isolinux.bin tmp
 787     cp tmp/ISO/isolinux/vmlinuz tmp
 788     cp tmp/ISO/isolinux/initrd.img tmp
 789
 790     run_hooks kickstart_floppy_create_hooks
 791
 792     umount tmp/ISO
 793     umount mnt
 794
 795     UUID=`uuidgen`
 796
 797     substitute_vars $INSTALL_TEMPLATE tmp/$NAME.xml
 798
 799     rm -f $KVMLOG/serial.$NAME
 800
 801     # boot the install CD
 802     $VIRSH create tmp/$NAME.xml
 803
 804     echo "Waiting for install to start"
 805     sleep 2
 806
 807     # wait for the install to finish
 808     if ! waitfor $KVMLOG/serial.$NAME "$KS_DONE_MESSAGE" $CREATE_BASE_TIMEOUT ; then
 809         $VIRSH destroy $NAME
 810         die "Failed to create base image ${DISK} after waiting for ${CREATE_BASE_TIMEOUT} seconds.
 811 You may need to increase the value of CREATE_BASE_TIMEOUT.
 812 Alternatively, the install might have completed but KS_DONE_MESSAGE
 813 (currently \"${KS_DONE_MESSAGE}\")
 814 may not have matched anything at the end of the kickstart output."
 815     fi
 816
 817     $VIRSH destroy $NAME
 818
 819     ls -l $DISK
 820     cat <<EOF
 821
 822 Install finished, base image $DISK created
 823
 824 You may wish to run
 825    chcon -t virt_content_t $DISK
 826    chattr +i $DISK
 827 To ensure that this image does not change
 828
 829 Note that the root password has been set to $ROOTPASSWORD
 830
 831 EOF
 832 }
 833
 834 ###############################
 835 # boot the base disk
 836 base_boot() {
 837     rm -rf tmp
 838     mkdir -p tmp
 839
 840     NAME="$BASENAME"
 841     DISK="${VIRTBASE}/${NAME}.${BASE_FORMAT}"
 842
 843     IPNUM=$FIRSTIP
 844
 845     make_network_map
 846
 847     CLUSTER="base"
 848
 849     diskimage mount $DISK
 850     setup_base
 851     diskimage unmount
 852
 853     UUID=`uuidgen`
 854
 855     echo "Creating $NAME.xml"
 856     substitute_vars $BOOT_TEMPLATE tmp/$NAME.xml
 857
 858     # boot the base system
 859     $VIRSH create tmp/$NAME.xml
 860 }
 861
 862 ######################################################################
 863
 864 # Updating a disk image...
 865
 866 diskimage ()
 867 {
 868     local func="$1"
 869     shift
 870     call_func diskimage_"$func" "$SYSTEM_DISK_ACCESS_METHOD" "$@"
 871 }
 872
 873 # setup the files from $BASE_TEMPLATES/, substituting any variables
 874 # based on the config
 875 copy_base_dir_substitute_templates ()
 876 {
 877     local dir="$1"
 878
 879     local d="$BASE_TEMPLATES/$dir"
 880     [ -d "$d" ] || return 0
 881
 882     local f
 883     for f in $(cd "$d" && find . \! -name '*~' \( -type d -name .svn -prune -o -print \) ) ; do
 884         f="${f#./}" # remove leading "./" for clarity
 885         if [ -d "$d/$f" ]; then
 886             # Don't chmod existing directory
 887             if diskimage is_directory "/$f" ; then
 888                 continue
 889             fi
 890             diskimage mkdir_p "/$f"
 891         else
 892             echo " Install: $f"
 893             diskimage substitute_vars "$d/$f" "/$f"
 894         fi
 895         diskimage chmod_reference "$d/$f" "/$f"
 896     done
 897 }
 898
 899 setup_base_hooks=
 900
 901 setup_base_ssh_keys ()
 902 {
 903     # this is needed as git doesn't store file permissions other
 904     # than execute
 905     # Note that we protect the wildcards from the local shell.
 906     diskimage chmod 600 "/etc/ssh/*key" "/root/.ssh/*"
 907     diskimage chmod 700 "/etc/ssh" "/root/.ssh" "/root"
 908     if [ -r "$HOME/.ssh/id_rsa.pub" ]; then
 909        echo "Adding $HOME/.ssh/id_rsa.pub to ssh authorized_keys"
 910        diskimage append_text_file "$HOME/.ssh/id_rsa.pub" "/root/.ssh/authorized_keys"
 911     fi
 912     if [ -r "$HOME/.ssh/id_dsa.pub" ]; then
 913        echo "Adding $HOME/.ssh/id_dsa.pub to ssh authorized_keys"
 914        diskimage append_text_file "$HOME/.ssh/id_dsa.pub" "/root/.ssh/authorized_keys"
 915     fi
 916 }
 917
 918 register_hook setup_base_hooks setup_base_ssh_keys
 919
 920 setup_base_grub_conf ()
 921 {
 922     echo "Adjusting grub.conf"
 923     local o="$EXTRA_KERNEL_OPTIONS" # For readability.
 924     local grub_configs="/boot/grub/grub.conf"
 925     if ! diskimage is_file "$grub_configs" ; then
 926         grub_configs="/etc/default/grub /boot/grub2/grub.cfg"
 927     fi
 928     local c
 929     for c in $grub_configs ; do
 930         diskimage sed "$c" \
 931             -e "s/console=ttyS0,19200/console=ttyS0,115200/"  \
 932             -e "s/ console=tty1//" -e "s/ rhgb/ norhgb/"  \
 933             -e "s/ nodmraid//" -e "s/ nompath//"  \
 934             -e "s/quiet/noapic divider=10${o:+ }${o}/g"
 935     done
 936 }
 937
 938 register_hook setup_base_hooks setup_base_grub_conf
 939
 940 setup_base()
 941 {
 942     local type="$1"
 943
 944     umask 022
 945     echo "Copy base files"
 946     copy_base_dir_substitute_templates "all"
 947     if [ -n "$type" ] ; then
 948         copy_base_dir_substitute_templates "$type"
 949     fi
 950
 951     run_hooks setup_base_hooks
 952 }
 953
 954 ipv4_prefix_to_netmask ()
 955 {
 956     local prefix="$1"
 957
 958     local div=$(($prefix / 8))
 959     local mod=$(($prefix % 8))
 960
 961     local octet
 962     for octet in 1 2 3 4 ; do
 963         if [ $octet -le $div ] ; then
 964             echo -n "255"
 965         elif [ $mod -ne 0 -a $octet -eq $(($div + 1)) ] ; then
 966             local shift=$((8 - $mod))
 967             echo -n $(( (255 >> $shift << $shift) ))
 968         else
 969             echo -n 0
 970         fi
 971         if [ $octet -lt 4 ] ; then
 972             echo -n '.'
 973         fi
 974     done
 975
 976     echo
 977 }
 978
 979 # setup various networking components
 980 setup_network()
 981 {
 982     # This avoids doing anything when we're called from boot_base().
 983     if [ -z "$hosts_file" ] ; then
 984         echo "Skipping network-related setup"
 985         return
 986     fi
 987
 988     echo "Setting up networks"
 989     diskimage append_text_file "$hosts_file" "/etc/hosts"
 990
 991     echo "Setting up /etc/ctdb/nodes"
 992     diskimage mkdir_p "/etc/ctdb"
 993     diskimage put "$nodes_file" "/etc/ctdb/nodes"
 994
 995     [ "$WEBPROXY" = "" ] || {
 996         diskimage append_text "export http_proxy=$WEBPROXY" "/etc/bashrc"
 997     }
 998
 999     if [ -n "$NFSSHARE" -a -n "$NFS_MOUNTPOINT" ] ; then
1000         echo "Enabling nfs mount of $NFSSHARE"
1001         diskimage mkdir_p "$NFS_MOUNTPOINT"
1002         diskimage append_text "$NFSSHARE $NFS_MOUNTPOINT nfs nfsvers=3,intr 0 0" "/etc/fstab"
1003     fi
1004
1005     diskimage mkdir_p "/etc/yum.repos.d"
1006     echo '@@@YUM_TEMPLATE@@@' | diskimage substitute_vars - "/etc/yum.repos.d/autocluster.repo"
1007
1008     diskimage rm_rf "/etc/udev/rules.d/70-persistent-net.rules"
1009
1010     echo "Setting up network interfaces: "
1011     local netname dev ip mask mac opts
1012     while read netname dev ip mask mac opts; do
1013         echo "  $dev"
1014
1015         local o gw
1016         gw=""
1017         for o in $opts ; do
1018             case "$o" in
1019                 gw\=*)
1020                     gw="${o#gw=}"
1021             esac
1022         done
1023
1024         cat <<EOF | \
1025             diskimage put - "/etc/sysconfig/network-scripts/ifcfg-${dev}"
1026 DEVICE=$dev
1027 ONBOOT=yes
1028 TYPE=Ethernet
1029 IPADDR=$ip
1030 NETMASK=$mask
1031 HWADDR=$mac
1032 ${gw:+GATEWAY=}${gw}
1033 EOF
1034
1035         # This goes to 70-persistent-net.rules
1036         cat <<EOF
1037 # Generated by autocluster
1038 SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="${mac}", ATTR{type}=="1", KERNEL=="eth*", NAME="${dev}"
1039
1040 EOF
1041     done <"$network_map" |
1042     diskimage put - "/etc/udev/rules.d/70-persistent-net.rules"
1043 }
1044
1045 register_hook setup_base_hooks setup_network
1046
1047 setup_base_cluster_setup_config ()
1048 {
1049     local f
1050     {
1051         echo "# Generated by autocluster"
1052         echo
1053         # This is a bit of a hack.  Perhaps these script belong
1054         # elsewhere, since they no longer have templates?
1055         for f in $(find "${BASE_TEMPLATES}/all/root/scripts" -type f |
1056             xargs grep -l '^#config:') ; do
1057
1058             b=$(basename "$f")
1059             echo "# $b"
1060             local vs v
1061             vs=$(sed -n 's@^#config: *@@p' "$f")
1062             for v in $vs ; do
1063                 # This could substitute the values in directly using
1064                 # ${!v} but then no sanity checking is done to make
1065                 # sure variables are set.
1066                 echo "${v}=\"@@${v}@@\""
1067             done
1068             echo
1069         done
1070     } | diskimage substitute_vars - "/root/scripts/cluster_setup.config"
1071 }
1072
1073 register_hook setup_base_hooks setup_base_cluster_setup_config
1074
1075 setup_timezone() {
1076     [ -z "$TIMEZONE" ] && {
1077         [ -r /etc/timezone ] && {
1078             TIMEZONE=`cat /etc/timezone`
1079         }
1080         [ -r /etc/sysconfig/clock ] && {
1081             . /etc/sysconfig/clock
1082             TIMEZONE="$ZONE"
1083         }
1084         TIMEZONE="${TIMEZONE// /_}"
1085     }
1086     [ -n "$TIMEZONE" ] || \
1087         die "Unable to determine TIMEZONE - please set in config"
1088 }
1089
1090 # substite a set of variables of the form @@XX@@ for the shell
1091 # variables $XX in a file.
1092 #
1093 # Indirect variables @@@XX@@@ (3 ats) specify that the variable should
1094 # contain a filename whose contents are substituted, with variable
1095 # substitution applied to those contents.  If filename starts with '|'
1096 # it is a command instead - however, quoting is extremely fragile.
1097 substitute_vars() {(
1098         infile="${1:-/dev/null}" # if empty then default to /dev/null
1099         outfile="$2" # optional
1100
1101         tmp_out=$(mktemp)
1102         cat "$infile" >"$tmp_out"
1103
1104         # Handle any indirects by looping until nothing changes.
1105         # However, only handle 10 levels of recursion.
1106         count=0
1107         while : ; do
1108             if ! _substitute_vars "$tmp_out" "@@@" ; then
1109                 rm -f "$tmp_out"
1110                 die "Failed to expand template $infile"
1111             fi
1112
1113             # No old version of file means no changes made.
1114             if [ ! -f "${tmp_out}.old" ] ; then
1115                 break
1116             fi
1117
1118             rm -f "${tmp_out}.old"
1119
1120             count=$(($count + 1))
1121             if [ $count -ge 10 ] ; then
1122                 rm -f "$tmp_out"
1123                 die "Recursion too deep in $infile - only 10 levels allowed!"
1124             fi
1125         done
1126
1127         # Now regular variables.
1128         if ! _substitute_vars "$tmp_out" "@@" ; then
1129             rm -f "$tmp_out"
1130             die "Failed to expand template $infile"
1131         fi
1132         rm -f "${tmp_out}.old"
1133
1134         if [ -n "$outfile" ] ; then
1135             mv "$tmp_out" "$outfile"
1136         else
1137             cat "$tmp_out"
1138             rm -f "$tmp_out"
1139         fi
1140 )}
1141
1142
1143 # Delimiter @@ means to substitute contents of variable.
1144 # Delimiter @@@ means to substitute contents of file named by variable.
1145 # @@@ supports leading '|' in variable value, which means to excute a
1146 # command.
1147 _substitute_vars() {(
1148         tmp_out="$1"
1149         delimiter="${2:-@@}"
1150
1151         # Get the list of variables used in the template.  The grep
1152         # gets rid of any blank lines and lines with extraneous '@'s
1153         # next to template substitutions.
1154         VARS=$(sed -n -e "s#[^@]*${delimiter}\([A-Z0-9_][A-Z0-9_]*\)${delimiter}[^@]*#\1\n#gp" "$tmp_out" |
1155             grep '^[A-Z0-9_][A-Z0-9_]*$' |
1156             sort -u)
1157
1158         tmp=$(mktemp)
1159         for v in $VARS; do
1160             # variable variables are fun .....
1161             [ "${!v+x}" ] || {
1162                 rm -f $tmp
1163                 die "No substitution given for ${delimiter}$v${delimiter} in $infile"
1164             }
1165             s=${!v}
1166
1167             if [ "$delimiter" = "@@@" ] ; then
1168                 f=${s:-/dev/null}
1169                 c="${f#|}" # Is is a command, signified by a leading '|'?
1170                 if [ "$c" = "$f" ] ; then
1171                     # No leading '|', cat file.
1172                     s=$(cat -- "$f")
1173                     [ $? -eq 0 ] || {
1174                         rm -f $tmp
1175                         die "Could not substitute contents of file $f"
1176                     }
1177                 else
1178                     # Leading '|', execute command.
1179                     # Quoting problems here - using eval "$c" doesn't help.
1180                     s=$($c)
1181                     [ $? -eq 0 ] || {
1182                         rm -f $tmp
1183                         die "Could not execute command $c"
1184                     }
1185                 fi
1186             fi
1187
1188             # escape some pesky chars
1189             # This first one can be too slow if done using a bash
1190             # variable pattern subsitution.
1191             s=$(echo -n "$s" | tr '\n' '\001' | sed -e 's/\o001/\\n/g')
1192             s=${s//#/\\#}
1193             s=${s//&/\\&}
1194             echo "s#${delimiter}${v}${delimiter}#${s}#g"
1195         done > $tmp
1196
1197         # Get the in-place sed to make a backup of the old file.
1198         # Remove the backup if it is the same as the resulting file -
1199         # this acts as a flag to the caller that no changes were made.
1200         sed -i.old -f $tmp "$tmp_out"
1201         if cmp -s "${tmp_out}.old" "$tmp_out" ; then
1202             rm -f "${tmp_out}.old"
1203         fi
1204
1205         rm -f $tmp
1206 )}
1207
1208 check_command() {
1209     which $1 > /dev/null || die "Please install $1 to continue"
1210 }
1211
1212 # Set a variable if it isn't already set.  This allows environment
1213 # variables to override default config settings.
1214 defconf() {
1215     local v="$1"
1216     local e="$2"
1217
1218     [ "${!v+x}" ] || eval "$v=\"$e\""
1219 }
1220
1221 load_config () {
1222     local i
1223
1224     for i in "${installdir}/config.d/"*.defconf ; do
1225         . "$i"
1226     done
1227 }
1228
1229 # Print the list of config variables defined in config.d/.
1230 get_config_options () {( # sub-shell for local declaration of defconf()
1231         local options=
1232         defconf() { options="$options $1" ; }
1233         load_config
1234         echo $options
1235 )}
1236
1237 # Produce a list of long options, suitable for use with getopt, that
1238 # represent the config variables defined in config.d/.
1239 getopt_config_options () {
1240     local x=$(get_config_options | tr 'A-Z_' 'a-z-')
1241     echo "${x// /:,}:"
1242 }
1243
1244 # Unconditionally set the config variable associated with the given
1245 # long option.
1246 setconf_longopt () {
1247     local longopt="$1"
1248     local e="$2"
1249
1250     local v=$(echo "${longopt#--}" | tr 'a-z-' 'A-Z_')
1251     # unset so defconf will set it
1252     eval "unset $v"
1253     defconf "$v" "$e"
1254 }
1255
1256 # Dump all of the current config variables.
1257 dump_config() {
1258     local o
1259     for o in $(get_config_options) ; do
1260         echo "${o}=\"${!o}\""
1261     done
1262     exit 0
1263 }
1264
1265 # $COLUMNS is set in interactive bash shells.  It probably isn't set
1266 # in this shell, so let's set it if it isn't.
1267 : ${COLUMNS:=$(stty size 2>/dev/null | sed -e 's@.* @@')}
1268 : ${COLUMNS:=80}
1269 export COLUMNS
1270
1271 # Print text assuming it starts after other text in $startcol and
1272 # needs to wrap before $COLUMNS - 2.  Subsequent lines start at $startcol.
1273 # Long "words" will extend past $COLUMNS - 2.
1274 fill_text() {
1275     local startcol="$1"
1276     local text="$2"
1277
1278     local width=$(($COLUMNS - 2 - $startcol))
1279     [ $width -lt 0 ] && width=$((78 - $startcol))
1280
1281     local out=""
1282
1283     local padding
1284     if [ $startcol -gt 0 ] ; then
1285         padding=$(printf "\n%${startcol}s" " ")
1286     else
1287         padding="
1288 "
1289     fi
1290
1291     while [ -n "$text" ] ; do
1292         local orig="$text"
1293
1294         # If we already have output then arrange padding on the next line.
1295         [ -n "$out" ] && out="${out}${padding}"
1296
1297         # Break the text at $width.
1298         out="${out}${text:0:${width}}"
1299         text="${text:${width}}"
1300
1301         # If we have left over text then the line break may be ugly,
1302         # so let's check and try to break it on a space.
1303         if [ -n "$text" ] ; then
1304             # The 'x's stop us producing a special character like '(',
1305             # ')' or '!'.  Yuck - there must be a better way.
1306             if [ "x${text:0:1}" != "x " -a "x${text: -1:1}" != "x " ] ; then
1307                 # We didn't break on a space.  Arrange for the
1308                 # beginning of the broken "word" to appear on the next
1309                 # line but not if it will make us loop infinitely.
1310                 if [ "${orig}" != "${out##* }${text}" ] ; then
1311                     text="${out##* }${text}"
1312                     out="${out% *}"
1313                 else
1314                     # Hmmm, doing that would make us loop, so add the
1315                     # rest of the word from the remainder of the text
1316                     # to this line and let it extend past $COLUMNS - 2.
1317                     out="${out}${text%% *}"
1318                     if [ "${text# *}" != "$text" ] ; then
1319                         # Remember the text after the next space for next time.
1320                         text="${text# *}"
1321                     else
1322                         # No text after next space.
1323                         text=""
1324                     fi
1325                 fi
1326             else
1327                 # We broke on a space.  If it will be at the beginning
1328                 # of the next line then remove it.
1329                 text="${text# }"
1330             fi
1331         fi
1332     done
1333
1334     echo "$out"
1335 }
1336
1337 # Display usage text, trying these approaches in order.
1338 # 1. See if it all fits on one line before $COLUMNS - 2.
1339 # 2. See if splitting before the default value and indenting it
1340 #    to $startcol means that nothing passes $COLUMNS - 2.
1341 # 3. Treat the message and default value as a string and just us fill_text()
1342 #    to format it.
1343 usage_display_text () {
1344     local startcol="$1"
1345     local desc="$2"
1346     local default="$3"
1347
1348     local width=$(($COLUMNS - 2 - $startcol))
1349     [ $width -lt 0 ] && width=$((78 - $startcol))
1350
1351     default="(default \"$default\")"
1352
1353     if [ $((${#desc} + 1 + ${#default})) -le $width ] ; then
1354         echo "${desc} ${default}"
1355     else
1356         local padding=$(printf "%${startcol}s" " ")
1357
1358         if [ ${#desc} -lt $width -a ${#default} -lt $width ] ; then
1359             echo "$desc"
1360             echo "${padding}${default}"
1361         else
1362             fill_text $startcol "${desc} ${default}"
1363         fi
1364     fi
1365 }
1366
1367 # Display usage information for long config options.
1368 usage_smart_display () {( # sub-shell for local declaration of defconf()
1369         local startcol=33
1370
1371         defconf() {
1372             local local longopt=$(echo "$1" | tr 'A-Z_' 'a-z-')
1373
1374             printf "     --%-25s " "${longopt}=${3}"
1375
1376             usage_display_text $startcol "$4" "$2"
1377         }
1378
1379         "$@"
1380 )}
1381
1382
1383 # Display usage information for long config options.
1384 usage_config_options (){
1385     usage_smart_display load_config
1386 }
1387
1388 actions_init ()
1389 {
1390     actions=""
1391 }
1392
1393 actions_add ()
1394 {
1395     actions="${actions}${actions:+ }$*"
1396 }
1397
1398 actions_run ()
1399 {
1400     [ -n "$actions" ] || usage
1401
1402     local a
1403     for a in $actions ; do
1404         $a
1405     done
1406 }
1407
1408 ######################################################################
1409
1410 post_config_hooks=
1411
1412 ######################################################################
1413
1414 load_config
1415
1416 ############################
1417 # parse command line options
1418 long_opts=$(getopt_config_options)
1419 getopt_output=$(getopt -n autocluster -o "c:e:E:xh" -l help,dump -l "$long_opts" -- "$@")
1420 [ $? != 0 ] && usage
1421
1422 use_default_config=true
1423
1424 # We do 2 passes of the options.  The first time we just handle usage
1425 # and check whether -c is being used.
1426 eval set -- "$getopt_output"
1427 while true ; do
1428     case "$1" in
1429         -c) shift 2 ; use_default_config=false ;;
1430         -e) shift 2 ;;
1431         -E) shift 2 ;;
1432         --) shift ; break ;;
1433         --dump|-x) shift ;;
1434         -h|--help) usage ;; # Usage should be shown here for real defaults.
1435         --*) shift 2 ;; # Assume other long opts are valid and take an arg.
1436         *) usage ;; # shouldn't happen, so this is reasonable.
1437     esac
1438 done
1439
1440 config="./config"
1441 $use_default_config && [ -r "$config" ] && . "$config"
1442
1443 eval set -- "$getopt_output"
1444
1445 while true ; do
1446     case "$1" in
1447         -c)
1448             b=$(basename $2)
1449             # force at least ./local_file to avoid accidental file
1450             # from $PATH
1451             . "$(dirname $2)/${b}"
1452             # If $CLUSTER is unset then try to base it on the filename
1453             if [ ! -n "$CLUSTER" ] ; then
1454                 case "$b" in
1455                     *.autocluster)
1456                         CLUSTER="${b%.autocluster}"
1457                 esac
1458             fi
1459             shift 2
1460             ;;
1461         -e) no_sanity=1 ; run_hooks post_config_hooks ; eval "$2" ; exit ;;
1462         -E) eval "$2" ; shift 2 ;;
1463         -x) set -x; shift ;;
1464         --dump) no_sanity=1 ; run_hooks post_config_hooks ; dump_config ;;
1465         --) shift ; break ;;
1466         -h|--help) usage ;; # Redundant.
1467         --*)
1468             # Putting --opt1|opt2|... into a variable and having case
1469             # match against it as a pattern doesn't work.  The | is
1470             # part of shell syntax, so we need to do this.  Look away
1471             # now to stop your eyes from bleeding! :-)
1472             x=",${long_opts}" # Now each option is surrounded by , and :
1473             if [ "$x" != "${x#*,${1#--}:}" ] ; then
1474                 # Our option, $1, surrounded by , and : was in $x, so is legal.
1475                 setconf_longopt "$1" "$2"; shift 2
1476             else
1477                 usage
1478             fi
1479             ;;
1480         *) usage ;; # shouldn't happen, so this is reasonable.
1481     esac
1482 done
1483
1484 run_hooks post_config_hooks
1485
1486 # catch errors
1487 set -e
1488 set -E
1489 trap 'es=$?;
1490       echo ERROR: failed in function \"${FUNCNAME}\" at line ${LINENO} of ${BASH_SOURCE[0]} with code $es;
1491       exit $es' ERR
1492
1493 # check for needed programs
1494 check_command expect
1495
1496 [ $# -lt 1 ] && usage
1497
1498 t="$1"
1499 shift
1500
1501 case "$t" in
1502     base)
1503         actions_init
1504         for t in "$@" ; do
1505             case "$t" in
1506                 create|boot) actions_add "base_${t}" ;;
1507                 *) usage ;;
1508             esac
1509         done
1510         actions_run
1511         ;;
1512
1513     cluster)
1514         actions_init
1515         for t in "$@" ; do
1516             case "$t" in
1517                 destroy|undefine|create|update_hosts|boot|setup)
1518                     actions_add "cluster_${t}" ;;
1519                 build)
1520                     for t in destroy undefine create update_hosts boot setup ; do
1521                         actions_add "cluster_${t}"
1522                     done
1523                     ;;
1524                 *) usage ;;
1525             esac
1526         done
1527         cluster_nodelist_hacking
1528         actions_run
1529         ;;
1530
1531     create)
1532         t="$1"
1533         shift
1534         case "$t" in
1535             base)
1536                 [ $# != 0 ] && usage
1537                 base_create
1538                 ;;
1539             cluster)
1540                 [ $# != 1 ] && usage
1541                 cluster_create "$1"
1542                 ;;
1543             node)
1544                 [ $# != 2 ] && usage
1545                 create_one_node "$1" "$2"
1546                 ;;
1547             *)
1548                 usage;
1549                 ;;
1550         esac
1551         ;;
1552     mount)
1553         [ $# != 1 ] && usage
1554         diskimage mount "$1"
1555         ;;
1556     unmount|umount)
1557         [ $# != 0 ] && usage
1558         diskimage unmount
1559         ;;
1560     bootbase)
1561         base_boot;
1562         ;;
1563     *)
1564         usage;
1565         ;;
1566 esac