jenkins-deb-common

#!/bin/bash

function jenkins_init() {
    if [ ! -z "${__JENKINS_INITIALIZED-}" ]; then
        return
    fi

    __JENKINS_INIALIZED=1

    log "Initializing"
    set -x
    set -e
    set -u

    exec 2>&1

    jenkins_set_vars

}

# see if we want to be involved in doing a thing
# if jenkins could do matrix build filters on component, that would win

function jenkins_am_interested() {
    # $1 - distrelease (ubuntu-maverick)
    # $2 - packageset (diablo-d5)

    local release=${DISTRELEASE##*-}

    case $2 in
        diablo-d5)
            [[ ${release} > "oneiric" ]] && return 1
            return 0
            ;;

        diablo-final)
            [[ ${release} > "oneiric" ]] && return 1
            return 0
            ;;

        essex-e3)
            return 0
            ;;

        *)
            return 0
    esac

    return 0
}

# set default values for all the configuration options
function jenkins_set_vars() {
    if [ ! -z "${__JENKINS_INITIALIZED-}" ]; then
        return
    fi

    unset STRATEGY

    [ -e /etc/jenkins-deb/jenkins-deb.conf ] && . /etc/jenkins-deb/jenkins-deb.conf

    # needs the base_dir so it can find virt templates
    BASE_DIR=${BASE_DIR:=~/jenkins-build}
    DEBEMAIL=${DEBEMAIL-'RCB Builder <rcb-deploy@lists.rackspace.com>'}
    GIT_BRANCH=${GIT_BRANCH-master}
    SOURCE_BUILD_DIST=${SOURCE_BUILD_DIST-ubuntu}
    SOURCE_BUILD_RELEASE=${SOURCE_BUILD_RELEASE-natty}
    PACKAGE_HOST=${PACKAGE_HOST-build.monkeypuppetlabs.com}
    IMAGE_CACHE=${IMAGE_CACHE:-build.monkeypuppetlabs.com}
    # DIST_CACHE=${DIST_CACHE:-cache.monkeypuppetlabs.com:3142}
    DIST_CACHE=${DIST_CACHE:-`grep "cache.monkeypuppetlabs.com" /etc/hosts | awk '{print $1}'`:3142}
    SQUID_CACHE=${SQUID_CACHE:-`grep "cache.monkeypuppetlabs.com" /etc/hosts | awk '{print $1}'`:3128}

    # this should get overridden by the branch config
    if [ "${COMPONENT-}" != "" ]; then
        NOVA_RELEASE=${COMPONENT%%-*}
        MILESTONE=${COMPONENT##*-}
    else
        NOVA_RELEASE=${NOVA_RELEASE-essex}
        MILESTONE=${MILESTONE-e3}
    fi

    MAJOR_VERSION=${MAJOR_VERSION-2012.1}

    ARCH=${ARCH-amd64}
    STRATEGY=${STRATEGY-lvm}
    SIGNING_KEY=${SIGNING_KEY-F87CBDE0}

    # we only see this on source builds
    if [ -e debian/changelog ]; then
        PACKAGE_VERSION=$(grep "urgency=" debian/changelog | sed -e 's/.*(\(.*\)).*/\1/' | head -n1)
    fi

    JOB_NAME=${JOB_NAME-tty}
    PACKAGE=$(echo ${JOB_NAME} | cut -d '/' -f 1 | sed -r -e "s/-(source|binaries)$//")

    # distrelease set in arch matrix on binary build
    if [ "${DISTRELEASE:-}" != "" ]; then
        BINARY_BUILD_DIST=${DISTRELEASE%%-*}
        BINARY_BUILD_RELEASE=${DISTRELEASE##*-}
    fi

    # figure out if this is a debian-ish or redhat-ish dist
    if [ "${BINARY_BUILD_DIST:-}" != "" ]; then
        declare -A variantmaps
        variantmaps=(
            [ubuntu]="debian"
            [debian]="debian"
            [fedora]="redhat"
            [centos]="redhat"
            [redhat]="redhat"
        )
        BINARY_BUILD_VARIANT=${variantmaps[${BINARY_BUILD_DIST}]}
    fi

    LVM_ROOT=${LVM_ROOT-/dev/vg0}
    INCOMING_PACKAGES=${INCOMING_PACKAGES-/srv/incoming-packages}
    PROPOSED_REPO=${PROPOSED_REPO-/srv/proposed-packages}
}

function acquire_lock() {
    # $1 - lock name
    # $2 - file handle - default 254
    name=${1-}
    fh=${2-9}

    [ "${name}" != "" ] || die "Must specify lock name"

    log "$(date +%Y%m%d): acquiring lock"

    eval "exec ${fh}>/tmp/${name}"
    flock -x ${fh}

    log "$(date +%Y%m%d): acquired lock"
}

function release_lock() {
    # $1 - file handle
    fh=${1-9}

    flock -u ${fh}

    eval "${fh}>&-"
    log "$(date +%Y%m%d): released lock"
}

function die() {
    echo $0
    exit 1
}

function log() {
    echo $*
}

function run_chef_solo() {
    # $1 - IP
    # $2 - cookbook tarball URL
    # $3 - dna.json

    ip=$1
    tarball=$2
    dna=$3

    log "Running chef solo using:"
    log " ip: ${ip}"
    log " tarball: ${tarball}"
    log " dna file: ${dna}"

    scp ${dna} root@${ip}:/root/dna.json

    # ruby ssl on maverick defaults to verify certs, and chef can't download recipies from https
    if [[ ${tarball} =~ "http" ]]; then
        tarball_file=$(mktemp)
        wget ${tarball} -O ${tarball_file}
        tarball=$(basename ${tarball})
        scp ${tarball_file} root@${ip}:~/${tarball}
        rm ${tarball_file}
    fi

    ssh root@${ip} "DEBIAN_FRONTEND=noninteractive apt-get install -y chef"
    ssh root@${ip} "LANG=C chef-solo -r ${tarball} -j /root/dna.json -l debug"
}

function maybe_make_kvm_instance() {
    # $1 - name
    # $2 - size in G (optional)

    gigs=${2-8}

    base_instance=${LVM_ROOT}/${BINARY_BUILD_RELEASE}
    new_instance=${1}

    if [ -e ${LVM_ROOT}/${new_instance} ]; then
        sudo lvremove -f ${LVM_ROOT}/${new_instance}
    fi

    if [ ! -e ${LVM_ROOT}/${new_instance} ]; then
        sudo lvcreate ${LVM_ROOT}/${BINARY_BUILD_RELEASE} --size=${gigs}G --name=${new_instance} --snapshot
    else
        echo "Logical volume ${LVM_ROOT}/${new_instance} already exists"
        return 1
    fi
}

function start_kvm_instance() {
    # $1 - name
    # $2 - IP
    # $3 - openstack url
    # $4 - openstack release
    # $5 - openstack component

    new_instance=${1}
    my_ip=${2}
    openstack_url=${3}
    openstack_release=${4}
    openstack_component=${5}

    MEMORY=${MEMORY-524288}

    # fix up the apt sources....
    sudo mkdir -p /mnt/$$
    sudo mount ${LVM_ROOT}/${new_instance} /mnt/$$

    function start_kvm_instance_cleanup() {
        sudo umount /mnt/$$
        sudo rm -rf /mnt/$$
        return 1
    }

    trap "start_kvm_instance_cleanup; return 1" SIGINT SIGTERM ERR

    # Setup apt sources
    if [ ${BINARY_BUILD_VARIANT} = "debian" ]; then
        cat <<EOF | sudo tee /mnt/$$/etc/apt/sources.list
deb http://${DIST_CACHE}/ubuntu ${BINARY_BUILD_RELEASE} main universe
deb http://${DIST_CACHE}/ubuntu ${BINARY_BUILD_RELEASE}-updates main universe
#deb ${openstack_url}/${openstack_component} ${openstack_release} main
deb ${openstack_url} ${openstack_release} ${openstack_component}
EOF
    else
        echo "current directory: `pwd`"
        cat $BASE_DIR/files/fedora.repo | sudo tee /mnt/$$/etc/yum.repos.d/fedora.repo
        cat $BASE_DIR/files/fedora-updates.repo | sudo tee /mnt/$$/etc/yum.repos.d/fedora-updates.repo
        cat $BASE_DIR/files/fedora-updates-testing.repo | sudo tee /mnt/$$/etc/yum.repos.d/fedora-updates-testing.repo

        # Fishstick01 is running a squid cache for YUM
        cat <<EOF | sudo tee /mnt/$$/etc/yum.conf
[main]
cachedir=/var/cache/yum/\$basearch/\$releasever
keepcache=0
debuglevel=2
logfile=/var/log/yum.log
exactarch=1
obsoletes=1
gpgcheck=1
plugins=1
installonly_limit=3
proxy=http://${SQUID_CACHE}
EOF
    fi

    # Configure /etc/hosts
    if [ ${BINARY_BUILD_VARIANT} = "debian" ]; then
        cat <<EOF | sudo tee /mnt/$$/etc/hosts
127.0.0.1       localhost
127.0.1.1       ${new_instance}

# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
EOF
    else
        cat <<EOF | sudo tee /mnt/$$/etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
127.0.1.1   ${new_instance}
192.168.1.1	jenkins-host.localhost.localdomain jenkins-host
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
EOF
    fi

    # Configure networking
    if [ ${BINARY_BUILD_VARIANT} = "debian" ]; then
    cat <<EOF | sudo tee /mnt/$$/etc/network/interfaces
auto eth0
iface eth0 inet static
    address ${my_ip}
    netmask 255.255.255.0
    gateway 192.168.1.1
    dns-nameservers 192.168.1.1
EOF
    else
        cat <<EOF | sudo tee /mnt/$$/etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE="eth0"
BOOTPROTO="static"
IPADDR=${my_ip}
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
ONBOOT="yes"
TYPE=Ethernet
IPV4_FAILURE_FATAL=yes
IPV6INIT=no
EOF
        sudo rm -f /mnt/$$/etc/sysconfig/network-scripts/ifcfg-p2p1
    fi

    # Setup hostame
    if [ ${BINARY_BUILD_VARIANT} = "debian" ]; then
        echo ${new_instance} | sudo tee /mnt/$$/etc/hostname
    else
        cat <<EOF | sudo tee /mnt/$$/etc/sysconfig/network
NETWORKING=yes
HOSTNAME=${new_instance}
EOF
    fi

    echo "nameserver 192.168.1.1" | sudo tee /mnt/$$/etc/resolv.conf
    sudo mkdir -p /mnt/$$/root/.ssh
    sudo cp ${HOME}/.ssh/id_rsa.pub /mnt/$$/root/.ssh/authorized_keys
    sudo chmod -R og-rwx /mnt/$$/root/.ssh

    if [ ${BINARY_BUILD_VARIANT} = "debian" ]; then
        # hackity hack hack hack
        sudo mkdir -p /mnt/$$/lib/modules
        sudo cp -a /lib/modules/`uname -r` /mnt/$$/lib/modules

        if [ ! -e /mnt/$$/usr/sbin/sshd ]; then
            sudo chroot /mnt/$$ apt-get update
            cat <<EOF | sudo tee /mnt/$$/usr/sbin/policy-rc.d
#!/bin/sh
exit 101
EOF
            sudo chmod 755 /mnt/$$/usr/sbin/policy-rc.d

            sudo chroot /mnt/$$ apt-get install -y openssh-server
            sudo rm -f /mnt/$$/usr/sbin/policy-rc.d
        fi

        sudo cp /etc/ssh/*key* /mnt/$$/etc/ssh
    fi

    sudo umount ${LVM_ROOT}/${new_instance}
    sudo rm -rf /mnt/$$

    # See if we have a virsh definition for this
    if ! $( sudo virsh list | grep -q "${new_instance}" ); then
        # make a new virsh definition
        # Varibles that get substituted in this template
        # are $MEMORY, $INSTANCE_NAME, and ${LVM_ROOT}
        INSTANCE_NAME=${new_instance}
        virt_template=${BASE_DIR}/virt-templates/default
        if [ -e ${BASE_DIR}/virt-templates/$(hostname) ]; then
            virt_template=${BASE_DIR}/virt-templates/$(hostname)
    fi
        if [ -e ${BASE_DIR}/virt-templates/$(hostname)-$BINARY_BUILD_DIST-$BINARY_BUILD_RELEASE ]; then
            virt_template=${BASE_DIR}/virt-templates/$(hostname)-$BINARY_BUILD_DIST-$BINARY_BUILD_RELEASE
        fi
        if [ -e ${BASE_DIR}/virt-templates/$INSTANCE_NAME ]; then
            virt_template=${BASE_DIR}/virt-templates/$INSTANCE_NAME
        fi
        if [ -e ${BASE_DIR}/virt-templates/$(hostname)-$INSTANCE_NAME ]; then
            virt_template=${BASE_DIR}/virt-templates/$(hostname)-$INSTANCE_NAME
        fi

        eval "echo \"$(< ${virt_template})\"" > /tmp/newxml-${new_instance}
        sudo virsh create /tmp/newxml-${new_instance}
        rm /tmp/newxml-${new_instance}
    else
        sudo virsh start ${new_instance}
    fi

    # wait for the box to come up
    count=1
    while [ $count -lt 20 ]; do
        # wait for port 22 to open
        count=$(( count + 1 ))
        sleep 5
        if ( nc ${my_ip} 22 -w 1 -q 0 < /dev/null ); then
            break
        fi
    done
    sleep 5

    [ -e ${HOME}/.ssh ] && ssh-keyscan ${my_ip} >> ${HOME}/.ssh/known_hosts

}

# reset the "proposed repo" to the current upstream
function reset_repo() {
    acquire_lock "repo"
    [ -e ${PROPOSED_REPO} ] || die "No ${PROPOSED_REPO}"

    rm -rf ${PROPOSED_REPO}/*

    cp -a /srv/packages/* ${PROPOSED_REPO}
    release_lock
}

# promote the "proposed repo" to the current repo
function promote_repo() {
    # $1 - repo to promote (optional)

    acquire_lock "repo"
    [ -e ${PROPOSED_REPO} ] || die "No ${PROPOSED_REPO}"

    if [ "${1-}" != "" ]; then
        subrepo=$1
        if [ ! -d ${PROPOSED_REPO}/${subrepo} ]; then
            release_lock
            echo "Bad repo"
            return 1
        fi

        rm -rf /srv/packages/${subrepo}/*
        cp -a ${PROPOSED_REPO}/${subrepo} /srv/packages
    else
        rm -rf /srv/packages/*
        cp -a ${PROPOSED_REPO}/* /srv/packages
    fi

    release_lock
}

# builder a new schroot for pbuilder
function verify_pbuilder() {
    # $1 - schroot template
    # $2 - pbuilder name

    distro_chroot=${1}
    pbuilder=${2}

    lockfile-create /tmp/build-${pbuilder}
    lockfile-touch -o /tmp/build-${pbuilder}

    trap "lockfile-remove /tmp/build-${pbuilder}" SIGINT SIGTERM EXIT ERR

    if ! (schroot --list --all-session | grep -q ${pbuilder}); then
        log "Building pbuilder for ${pbuilder}"

        schroot -c ${distro_chroot} -n ${pbuilder} -b
        log "Updating pbuilder"

        schroot -c ${pbuilder} -r -u root -- apt-get update
        log "Installing pbuilder..."

        schroot -c ${pbuilder} -r -u root -- /bin/bash -c 'DEBIAN_FRONTEND=noninteractive apt-get --force-yes -y install pbuilder aptitude git-buildpackage'
        log "Cleanup"

        schroot -c ${pbuilder} -r -u root -- /etc/init.d/atd stop
    else
        log "pbuilder schroot exists... skipping"
    fi

    lockfile-remove /tmp/build-${pbuilder}
    trap - SIGINT SIGTERM EXIT ERR
}

function build_source_package {
    # $1 - optional, build dir

    local build_args=""
    local relative_build_dir=".."
    if [ "${1-}" != "" ]; then
        build_args="--git-export-dir=${1}"
        relative_build_dir=${1}
    fi

    if [ -e debian/control ]; then
        # kind of cheesy
        set_component_from_dsc debian/control
    fi

    distro_chroot=${SOURCE_BUILD_RELEASE}-${NOVA_RELEASE}-${MILESTONE}
    pbuilder=${USER}-${distro_chroot}-pbuilder

    acquire_lock ${pbuilder}

    verify_pbuilder $distro_chroot $pbuilder

    # apply patches before dpkg-buildpackage
    if [ -s debian/patches/series ]; then
        quilt push -a
    fi

    schroot -c ${pbuilder} -r -u root -- apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 765C5E49F87CBDE0
    schroot -c ${pbuilder} -r -u root -- apt-get update -y
    schroot -c ${pbuilder} -r -u root -- /usr/lib/pbuilder/pbuilder-satisfydepends
    if [[ ${APPEND_BUILD_NUMBER_TO_PACKAGE} = "1" ]]; then
        schroot -c jenkins-precise-rcb-utils-pbuilder -r -- git-dch -a -N ${PACKAGE_VERSION}-${BUILD_NUMBER} --debian-branch=${GIT_BRANCH} -S --id-length=10
        schroot -c jenkins-precise-rcb-utils-pbuilder -r -- git-buildpackage '-i.*' -tc -S --git-ignore-new --git-ignore-branch --git-upstream-tag=${GIT_BRANCH}
        schroot -c jenkins-precise-rcb-utils-pbuilder -r -- git reset --hard HEAD
    else
        schroot -c ${pbuilder} -r -- git-buildpackage --git-pristine-tar -i.* -tc -S --git-ignore-new --git-ignore-branch ${build_args}
    fi

    release_lock

    # hrm... we have packages, but now they are setting in the .. directory
    mv ${relative_build_dir}/*.gz .
    mv ${relative_build_dir}/*changes .
    mv ${relative_build_dir}/*dsc .
    mv ${relative_build_dir}/*build .

    # for the jenkins post-deploy job
    if [ "" != "${JENKINS_HOME-}" ] && [ "" != "${JOB_NAME-}" ] && [ "" != "${BUILD_NUMBER-}" ]; then
        mkdir -p ${JENKINS_HOME}/userContent/${JOB_NAME}/${BUILD_NUMBER}
    fi
}

function set_component_from_dsc() {
    # $1 - dsc

    dsc=${1}
    RCB_COMPONENT=$(grep -i "rcb-component" "${dsc}" | awk '{ print $2 }')
    if [ "${RCB_COMPONENT-}" != "" ]; then
        NOVA_RELEASE=${RCB_COMPONENT%%-*}
        MILESTONE=${RCB_COMPONENT##*-}
    fi
}

function build_binary_packages() {
    dsc=${1}

    # we need to figure out the nova_release and milestone from the .dch
    set_component_from_dsc ${dsc}
    log "Attempting packaging for ${NOVA_RELEASE}-${MILESTONE} on ${DISTRELEASE}"

    if ( ! jenkins_am_interested ${DISTRELEASE} ${NOVA_RELEASE}-${MILESTONE} ); then
        log "Not interested in this package"
        return 0
    fi

    distro_chroot=${BINARY_BUILD_RELEASE}-${NOVA_RELEASE}-${MILESTONE}

    DEB_BUILD_OPTIONS="nodocs nocheck" sbuild \
        -n -A -d ${NOVA_RELEASE}-${MILESTONE} \
        --append-to-version=~${BINARY_BUILD_RELEASE} \
        -m "${DEBEMAIL}" -k ${SIGNING_KEY} \
        -c ${distro_chroot} ${dsc}

    # drop a java properties file with the NOVA_RELEASE and MILESTONE, so
    # we can kick off the right package and kong tests...
    [ "${WORKSPACE-}" != "" ] && echo "COMPONENT=${NOVA_RELEASE}-${MILESTONE}" > ${JENKINS_HOME}/jobs/${PACKAGE}-binaries/lastbuild.properties
}

function upload_to_incoming() {
    # $1 - dsc file
    set_component_from_dsc ${dsc}

    if ( ! jenkins_am_interested ${DISTRELEASE} ${NOVA_RELEASE}-${MILESTONE} ); then
        return 0
    fi

    # dump the packages into proposed packages.  The repotest will
    # merge outstanding packages.
    acquire_lock "incoming"

    mkdir -p ${INCOMING_PACKAGES}/${NOVA_RELEASE}/${MILESTONE}/${BINARY_BUILD_RELEASE}
    mv *.{gz,dsc,changes} ${INCOMING_PACKAGES}/${NOVA_RELEASE}/${MILESTONE}/${BINARY_BUILD_RELEASE}
    cp *.deb ${INCOMING_PACKAGES}/${NOVA_RELEASE}/${MILESTONE}/${BINARY_BUILD_RELEASE}

    release_lock
}

function import_proposed_packages() {
    acquire_lock "repo" 9
    acquire_lock "incoming" 8

    ~/jenkins-build/scripts/merge.py ${PROPOSED_REPO}

    source_packages=$(find ${INCOMING_PACKAGES} -name "*dsc")
    binary_packages=$(find ${INCOMING_PACKAGES} -name "*deb")

    for pkg in $source_packages; do
        base_pkg=$(echo $pkg | sed -e s#${INCOMING_PACKAGES}##)
        base_name=$(basename $base_pkg)

        details=(${base_pkg//\// })

        nova_release=${details[0]}
        milestone=${details[1]}
        release=${details[2]}

        # see if this .dsc has already been imported
        # if ( ! find ${PROPOSED_REPO} -name "${base_name}" ); then
        #     reprepro -b ${PROPOSED_REPO} -S ${nova_release}-${milestone} \
        #       includedsc ${release} ${pkg}
        # else
        #     log "Skipping ${base_name} -- exists in repo"
        # fi

        # naw, on second though, just try and blindly stick it in
        package_name=${base_name%%_*}

        # for dist in ${PROPOSED_REPO}/dists; do
        #     if ( reprepro -b ${PROPOSED_REPO} -C ${nova_release}-${milestone} removesrc ${dist} ${package_name} ); then
        #       log "Removed ${package_name}"
        #     fi
        # done

        if ( reprepro -b ${PROPOSED_REPO}/${nova_release}-${milestone} -C ${nova_release}-${milestone} \
            includedsc ${release} ${pkg} ); then
            log "Uploaded ${pkg}"
        fi
    done

    for pkg in $binary_packages; do
        base_pkg=$(echo $pkg | sed -e s#${INCOMING_PACKAGES}##)
        base_name=$(basename $base_pkg)

        details=(${base_pkg//\// })

        nova_release=${details[0]}
        milestone=${details[1]}
        release=${details[2]}

        # pkg_file=${PROPOSED_REPO}/dists/${release}/${nova_release}-${milestone}/binary-${ARCH}/Packages
        #
        # if ( ! grep -q "$base_name" ${pkg_file} ); then
        #     reprepro -b ${PROPOSED_REPO} -S ${nova_release}-${milestone} \
        #       includedeb ${release} ${pkg}
        # else
        #     log "Skipping ${base_name} - package exists in ${release} repo for ${nova_release}-${milestone}"
        # fi
        package_name=${base_name%%_*}

        if ( reprepro -b ${PROPOSED_REPO}/${nova_release}-${milestone} -C ${nova_release}-${milestone} remove ${release} ${package_name} ); then
            log "Removed package ${package_name}"
        fi

        if ( reprepro -b ${PROPOSED_REPO}/${nova_release}-${milestone} -C ${nova_release}-${milestone} \
            includedeb ${release} ${pkg} ); then
            log "Uploaded ${pkg}"
        fi

    done



    # for source_pkg in ${INCOMING_PACKAGES}/*dsc; do
    #   reprepro -b ${PROPOSED_REPO} -S ${NOVA_RELEASE}-${MILESTONE} \
    #       includedsc ${BINARY_BUILD_RELEASE} ${source_pkg}
    # done

    # for source_pkg in ${INCOMING_PACKAGES}/*deb; do
    #   reprepro -b /src/proposed-packages -S ${NOVA_RELEASE}-${MILESTONE} \
    #       includedeb ${BINARY_BUILD_RELEASE} ${source_pkg}
    # done

    rm -rf ${INCOMING_PACKAGES}/*

    ~/jenkins-build/scripts/merge.py ${PROPOSED_REPO}

    release_lock 8
    release_lock 9
}

function get_ip {
    # $1 - what to get IP for, from range in /etc/jenkins-deb/jenkins-deb-ip.conf
    #      poor-man's IPAM
    #
    # /etc/jenkins-deb/jenkins-deb-ip.conf should look like this:
    # 192.168.1.10 unallocated
    # 192.168.1.11 unallocated
    # ---
    #
    # allocation will be first-come, first-served allocated by name.  Once an
    # ip has been allocated for a name, it will always be allocated to that
    # name.  There is no cleanup, no ping tests, etc.
    #
    # clean it up yourself.
    #

    # first, load in the whole list

    acquire_lock "index"  # trap handler already set

    # declares in functions are by default local (without -x)
    declare -A ip_list
    declare -A host_list
    local ip
    local host

    ip_list=()
    host_list=()

    while read line; do
        ip=${line%% *}
        host=${line##* }
        ip_list[${ip}]=${host}
        host_list[${host}]=${ip}
    done < <(cat /etc/jenkins-deb/jenkins-deb-ip.conf)


    # set the host to the passed-in host name
    host=${1}

    if [ "${host_list[${host}]-}" != "" ]; then
        # already have an ip allocated for this host
        IP=${host_list[${host}]}
    else
        # need to allocate and write the file back out.  Pick
        # the last unallocated
        IP=${host_list[unallocated]}
        ip_list[${IP}]=${host}

        # Now, write out the file
        local tmpfile=$(mktemp)

        for ip in ${!ip_list[@]}; do
            echo "Writing ${ip}"
            echo "${ip} ${ip_list[${ip}]}" >> ${tmpfile}
        done

        sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n ${tmpfile} > /etc/jenkins-deb/jenkins-deb-ip.conf
        rm ${tmpfile}
    fi

    release_lock
}


function aquire_ip {
    # $1 - what to get IP for, from range in /etc/jenkins-deb/jenkins-deb-ip.conf
    #      poor-man's IPAM
    #
    # /etc/jenkins-deb/jenkins-deb-ip.conf should look like this:
    # 192.168.1.10 unallocated
    # 192.168.1.11 unallocated
    # ---
    #
    # allocation will be first-come, first-served allocated by name.  Once an
    # ip has been allocated for a name, it will always be allocated to that
    # name.  There is no cleanup, no ping tests, etc.
    #
    # clean it up yourself.
    #

    # first, load in the whole list

    acquire_lock "index"  # trap handler already set

    # declares in functions are by default local (without -x)
    declare -A ip_list
    declare -A host_list
    local ip
    local host
    local ret

    ip_list=()
    host_list=()

    while read line; do
        ip=${line%% *}
        host=${line##* }
        ip_list[${ip}]=${host}
        host_list[${host}]=${ip}
    done < <(cat /etc/jenkins-deb/jenkins-deb-ip.conf)


    # set the host to the passed-in host name
    host=${1}

    if [ "${host_list[${host}]-}" != "" ]; then
        # already have an ip allocated for this host
        ret=${host_list[${host}]}
    else
        # need to allocate and write the file back out.  Pick
        # the last unallocated
        ret=${host_list[unallocated]}
        ip_list[${IP}]=${host}

        # Now, write out the file
        local tmpfile=$(mktemp)

        for ip in ${!ip_list[@]}; do
            echo "Writing ${ip}"
            echo "${ip} ${ip_list[${ip}]}" >> ${tmpfile}
        done

        sort -t . -k 1,1n -k 2,2n -k 3,3n -k 4,4n ${tmpfile} > /etc/jenkins-deb/jenkins-deb-ip.conf
        rm ${tmpfile}
    fi

    release_lock
    return $ret
}

function increment_counter {
    # $1 - counter to increment
    # $2 - variable to return the result in

    acquire_lock "index"

    # increment the global build number
    . /etc/jenkins-deb/jenkins-deb-counters.conf

    # hackity hack hack hack
    eval ${1}="$(( ${1} + 1 ))"
    eval ${2}=${!1}

#    cat > /etc/jenkins-deb/jenkins-deb-counters.conf <<EOF
    cat <<EOF
GLOBAL_REVNO=${GLOBAL_REVNO}
EOF

    release_lock
}

function lv_remove() {
    local lvm_name=${1}
    local mapper_name=/dev/mapper/$(basename ${LVM_ROOT})-$(echo ${lvm_name} | sed -e 's/-/--/g')

    # remove a lvm volume.  On natty this is easy.  On
    # debian, the mapper devices probably have to get whacked first
    #

    if (! sudo lvremove -f ${LVM_ROOT}/${lvm_name}); then
        # try and remove the mapper entries
        if [ -e ${mapper_name}-cow ]; then
            sudo dmsetup remove ${mapper_name}-cow
        fi

        if [ -e ${mapper_name} ]; then
            sudo dmsetup remove ${mapper_name}
        fi
    fi

    sudo lvremove -f ${LVM_ROOT}/${lvm_name}
}

if [ "${IMPORTED_JENKINS-}" = "" ]; then
    jenkins_init
    jenkins_set_vars
fi

export IMPORTED_JENKINS=1
jenkins_init