get-orig-tarball

#!/bin/bash

VERBOSITY=0
TEMP_D=""
FORMATS=".tar.gz .tar.xz .tar.bz2"
DSC_UBUNTU_BASE_URL="http://launchpad.net/ubuntu/+archive/primary/+files"
DSC_DEBIAN_BASE_URL="http://launchpad.net/debian/+archive/primary/+files"
MSG_BORDER_LINE="========================================"



error() { echo "$@" 1>&2; }
fail() { [ $# -eq 0 ] || error "$@"; exit 1; }

Usage() {
    cat <<EOF
Usage: ${0##*/} [ options ] [changelog [dir]] | [subcommand]

   changelog: the changelog to parse. Default: debian/changelog.
   dir: place to put orig tarball. 
        default: dirname(changelog)/../../

   options:
      -O | --overwrite: overwrite an existing file 


   subcommands:

       for: specify a package and version without parsing debian/changelog
            See '${0##*/} for --help' for more information.
EOF
}

for_Usage() {
    cat <<EOF
Usage: ${0##*/} for [ options ] pkg pkg-version [dir]

   package: the source package
   version: the version of the package
   dir: place to put orig tarball.  default: .

   options:
      -O | --overwrite: overwrite an existing file 
EOF
}

for_bad_Usage() { for_Usage 1>&2; [ $# -eq 0 ] || error "$@"; return 1; }

bad_Usage() { Usage 1>&2; [ $# -eq 0 ] || error "$@"; return 1; }
cleanup() {
    [ -z "${TEMP_D}" -o ! -d "${TEMP_D}" ] || rm -Rf "${TEMP_D}"
}

debug() {
    local level=${1}; shift;
    [ "${level}" -gt "${VERBOSITY}" ] && return
    error "${@}"
}

get_field() {
    local clog="$1" field="$2" offset="$3" ret=""
    local out=""
    out=$(dpkg-parsechangelog \
        ${offset:+"--offset=$offset"} --show-field "$field" --count=1) || {
            ret=$?
            error "failed reading '$field' from '$clog'"
            return $ret
        }
    _RET="$out"
}

is_released() {
    [ "$1" != "UNRELEASED" -a "$1" != "unreleased" ]
}

check_url() {
    local url="$1"
    wget --method=HEAD --quiet "$url"
}

# get_dsc_urls(package, version)
get_dsc_urls() {
    local name="$1" ver="$2" path=""
    ver=$(no_epoch "$ver")
    path="${name}_${ver}.dsc"
    _RET="${DSC_UBUNTU_BASE_URL}/$path ${DSC_DEBIAN_BASE_URL}/$path"
    return
}

get_dsc_url() {
    local name="$1" ver="$2" url=""
    get_dsc_urls "$name" "$ver" || return 1
    for url in $_RET; do
        check_url "$url" && _RET="$url" && return 0
    done
    return 1
}

find_orig() {
    local src="$1" ver="$2" dir="" n="" ext="" nver=""
    shift 2
    nver=$(no_epoch "$ver")
    for dir in "$@"; do
        for ext in $FORMATS; do
            n="${src}_${nver}.orig${ext}"
            [ -f "$dir/$n" ] && _RET="$dir/$n" &&
                echo "$dir/$n" && return 0
        done
    done
    return 1
}

# no_epoch(version): drop a leading epoch from a version
#   no_epoch(1:15.0+dfsg1-1ubuntu2.1) = 15.0+dfsg1-1ubuntu2.1
#   no_epoch("1.0") = "1.0"
no_epoch() {
    case "$1" in
        [0-9]:*|[0-9][0-9]:*) echo "${1#*:}";;
        *) echo "$1"
    esac
}

for_main() {
    local short_opts="hOv"
    local long_opts="help,overwrite,verbose"
    local getopt_out=""
    getopt_out=$(getopt --name "${0##*/}" \
        --options "${short_opts}" --long "${long_opts}" -- "$@") &&
        eval set -- "${getopt_out}" ||
        { for_bad_Usage; return; }

    local cur="" next="" overwrite=false orig="" sdir="$PWD"
    local odir="."
    while [ $# -ne 0 ]; do
        cur="$1"; next="$2";
        case "$cur" in
            -h|--help) for_Usage ; exit 0;;
            -O|--overwrite) overwrite=true;;
            -v|--verbose) VERBOSITY=$((VERBOSITY+1));;
            --) shift; break;;
        esac
        shift;
    done

    local src="$1" ver="$2"
    [ $# -eq 2 -o $# -eq 3 ] || {
        for_bad_Usage "expected 2 or 3 args, got $#: $*";
        return
    }

    if [ $# -ge 3 ]; then
        odir="$3"
        [ -d "$odir" ] || { error "$odir: not a directory"; return 1; }
    else
        odir=$PWD
    fi

    local pver=""

    case "$ver" in
       upstream-*) ver="${ver#upstream-}"; uver=$ver; pver="not-provided";;
       *-*) 
          uver=${ver%-*}
          pver=${ver##*-};;
       *) uver="$ver"; pver="not-provided";;
    esac
    debug 1 "uver=${uver} pver=${pver}"

    if [ "$pver" = "not-provided" ]; then
        local ext="" name="" tname="" nver="" url="" urls=""
        nver=$(no_epoch "$ver")
        debug 1 "downloading without a dsc, poking for $src and $ver"
        for url in "${DSC_UBUNTU_BASE_URL}" "${DSC_DEBIAN_BASE_URL}"; do
            for ext in ${FORMATS}; do
                name="${src}_${nver}.orig$ext"
                tname="$name.tmp.$$"
                debug 2 "trying $url/${src}_${nver}.orig${ext}"
                urls="$urls $url/$name"
                check_url "$url/$name" || continue
                wget "$url/$name" -O "$odir/$tname" &&
                    mv "$odir/$tname" "$odir/$name" &&
                    { error "wrote ${name} to $odir"; return 0; } ||
                    rm -f "$tname"
            done
        done
        error "failed download of $src at $nver. tried orig formats $FORMATS. Tried:"
        for url in $urls; do
            error "   $url"
        done
        return 1
    else
        debug 1 "src=$src ver=$ver uver=$uver pver=$pver"
        dl_to_dir "$src" "$ver" "$odir" "$overwrite"
    fi
}

main() {
    local short_opts="hOv"
    local long_opts="help,offset:,overwrite,unreleased,verbose"
    local getopt_out=""
    getopt_out=$(getopt --name "${0##*/}" \
        --options "${short_opts}" --long "${long_opts}" -- "$@") &&
        eval set -- "${getopt_out}" ||
        { bad_Usage; return; }

    local cur="" next="" overwrite=false orig="" sdir="$PWD" offset="0"
    local changelog="debian/changelog" odir="" use_unreleased=false
    while [ $# -ne 0 ]; do
        cur="$1"; next="$2";
        case "$cur" in
            -h|--help) Usage ; exit 0;;
            -O|--overwrite) overwrite=true;;
               --offset) offset=$next; shift;;
               --unreleased) unreleased=true;;
            -v|--verbose) VERBOSITY=$((VERBOSITY+1));;
            --) shift; break;;
        esac
        shift;
    done

    [ $# -lt 3 ] || {
        bad_Usage "expected < 0, 1 or 2 args, got $#: $*";
    }

    if [ $# -ge 1 ]; then
        changelog="$1"
        [ -f "$changelog" ] || {
            error "$changelog: not a file"
            return 1
        }
    else
        [ -f "$changelog" ] || {
            Usage 1>&2
            error "no '$changelog' exists in under $PWD."
            return 1
        }
    fi

    if [ $# -ge 2 ]; then
        odir="$2"
        [ -d "$odir" ] || { error "$odir: not a directory"; return 1; }
    else
        odir=$(dirname "$changelog") &&
            odir=$(cd "$odir/../.." && pwd) ||
            { error "failed dirname for '$changelog'"; return 1; }
    fi

    local ver="" dist="UNRELEASED"
    while :; do
        get_field "$changelog" Version $offset && ver="$_RET" || return
        get_field "$changelog" Distribution $offset && dist="$_RET" || return
        get_field "$changelog" Source $offset && src="$_RET" || return
        [ "$unreleased" = "true" ] && break
        is_released "$dist" && break
        offset=$(($offset+1))
    done

    # walk back through versions at the same upstream version as this.
    while :; do
        debug 1 "src=$src ver=$ver upstream=${ver%-*} package=${ver##*-}" \
            "offset=$offset"
        dl_to_dir "$src" "$ver" "$odir" "$overwrite" && return 0
        get_field "$changelog" Version $((offset+1)) && nver="$_RET" || return
        if [ "${nver%-*}" != "${ver%-*}" ]; then
            error "Failed getting upstream tarball."
            return
        fi
        offset=$((offset+1))
        debug 1 "Failed getting at version $ver, trying at $nver"
        ver=${nver}
    done
}

dl_to_dir() {
    local src="$1" ver="$2" odir="$3" overwrite=${4:-false} orig=""
    local uver="${ver%-*}"

    get_dsc_url "$src" "$ver" || return
    dsc_url=$_RET
    debug 1 "dsc_url=$dsc_url"

    TEMP_D=$(mktemp -d "${TMPDIR:-/tmp}/${0##*/}.XXXXXX") ||
        fail "failed to make tempdir"
    trap cleanup EXIT

    cd "$TEMP_D"
    local vflag="--quiet"
    if [ "$VERBOSITY" -ge 1 ]; then
        vflag=""
    fi
    # unauthenticated is fine because we use https to launchpad
    dget $vflag --allow-unauthenticated --download-only "$dsc_url" || {
        error "failed: dget --download-only $dsc_url"
        cd "$sdir"
        return 1
    }

    upstream_orig=$(find_orig "$src" "$uver" "$TEMP_D") || {
        error "dget succeeded, but no orig tarball found."
        cat "$TEMP_D/${src}_${ver}.dsc" 1>&2
        ls $TEMP_D 1>&2;
        cd "$sdir"
        return 1
    }

    if orig=$(find_orig "$src" "$uver" "$odir"); then
        ORIG_SUM=$(sha256sum "${orig}" | awk '{print $1}' )
        UPSTREAM_SUM=$(sha256sum "${upstream_orig}" | awk '{print $1}' )
        if [ "${ORIG_SUM}" == "${UPSTREAM_SUM}" ]; then
            error ${MSG_BORDER_LINE}
            error "No difference between upstream orig.tar.gz and local."
            error "No changes made to ${orig}"
            error ${MSG_BORDER_LINE}
            _RET="${odir}/${orig##*/}"
            return 0
        fi
        error ${MSG_BORDER_LINE}
        error " orig tarball existed at $orig and differs from upstream"
        error " sha256sums of local and upstream:"
        error "   (local) ${ORIG_SUM}"
        error "   (upstream) ${UPSTREAM_SUM}"
        error " Use --overwrite to use upstream automatically in the future"
        error ${MSG_BORDER_LINE}
        if [ "${overwrite}" = "false" ]; then
            echo "Do you want to overwrite ${orig} with upstream? (y/n)"
            read RESP
            if [ "${RESP}" = "y" ]; then
                orig=${upstream_orig}
            fi
        fi
    else
        # No preexisting orig.tar.gz, so copy it to output dir
        orig=${upstream_orig}
    fi

    cd "$sdir"
    mv "$orig" "$odir/"
    _RET="${odir}/${orig##*/}"
    error "wrote $odir/${orig##*/}"
}

if [ "$1" = "for" ]; then
    shift
    for_main "$@"
else
    main "$@"
fi

# vi: ts=4 expandtab