debutant

#!/bin/bash
#
#    debutant - Debian packaging framework for binary blobs
#    Copyright (C) 2015 - 2022  GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
#    Author: Christopher Huhn <c.huhn@gsi.de>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#


###################
#
# helper function definitions for recipes:
#

abort() {
    echo "$*" >&2
    exit 1
}


# Add a dependency to debian/control
#  -b : Add a build-dependency
add_dependency() {
    local depends="Depends"

    if [ "$1" = "-b" ]; then
        depends="Build-Depends"
        shift
    fi

    for PKG in "$@"; do
        if grep -q "^${depends}: .*" "$PKG_DIR/debian/control"; then
            grep -q "^${depends}: .*\<$PKG\>" "$PKG_DIR/debian/control" \
                || sed -i -e "s/^\(${depends}: .*\)/\1, $PKG/" "$PKG_DIR/debian/control"
        else
            echo "${depends}: $PKG" >> "$PKG_DIR/debian/control"
        fi
    done
}


# install an initscript the debian way
#  recommendation for custom init scripts:
#  place in $RECIPE_DIR/debian/(init|default) and use add_debian_files
add_initscript() {
    local init=$1

    [ "$init" ] || init="$RECIPE_DIR/debian/init"
    cp "$init" "$PKG_DIR/debian/init"
    # also copy over the default file if found:
    if [ -e "$(dirname $init)/default" ]; then
        cp "$(dirname $init)/default" "$PKG_DIR/debian/default"
    fi
    # 'modern' initscripts make use of lsb functions:
    #add_dependency "lsb-base (>= 3.2-14)" # versioned depends not supported by add_dependency yet
}

## DEPRECATED: use add_debian_files and $RECIPE_DIR/debian instead
add_install_scripts() {
    for file in preinst postinst prerm postrm; do
        [ -e "$RECIPE_DIR/$file" ] || continue
        cp "$RECIPE_DIR/$file" "$PKG_DIR/debian/"
        chmod a+rx "$PKG_DIR/debian/$file"
    done
}


#
# load prepared packaging files from $RECIPE_DIR/debian
#
add_debian_files() {
    if [ -z "$PACKAGE" ]; then
        if [ "$1" ]; then
            # read package name from the command line
            PACKAGE=$1
        elif [ -r "$PKG_DIR/debian/control" ]; then
            # we already have a debian/control in place (e.g. from alien)
            #  and read the package name from there:
            PACKAGE=$(sed -ne 's/^Source: //p' "$PKG_DIR/debian/control")
        fi
    fi

    if [ "$PACKAGE" -a -d "$RECIPE_DIR/$PACKAGE.debian" ]; then
        cp -br "$RECIPE_DIR/$PACKAGE.debian/." "$PKG_DIR/debian"
    elif [ -d "$RECIPE_DIR/debian" ]; then
        cp -br "$RECIPE_DIR/debian/." "$PKG_DIR/debian"
    fi
}

#
# there are some lintian warnings we cannot do anything about
#
add_lintian_overrides() {
    local package=$1
    cat <<EOF >> "$PKG_DIR/debian/$package.lintian-overrides"
${package} binary: binary-or-shlib-defines-rpath
${package} binary: embedded-library
${package} binary: hardening-no-relro
${package} binary: shlib-with-non-pic-code
# we override dh_strip as it might break stuff:
${package} binary: unstripped-binary-or-object
EOF
}

# sometimes the debian architecture has to be set explicitly
#  e.g. if we want to build i386 packages on amd64
build_architecture() {
    DEB_HOST_ARCH=$1
    [ "$DEB_HOST_ARCH" ] || DEB_HOST_ARCH=`dpkg-architecture -qDEB_BUILD_ARCH`
    export DEB_HOST_ARCH
    debian_control Architecture $DEB_HOST_ARCH
}

# add a build dependency to debian/control
build_depends() {
    for PKG in "$@"; do
        add_dependency -b "$PKG"
        # TODO: install it if required ?!
    done
}

# build the package
#  adds a revision (default 1) unless --keep-revision is given
build_package() {
    (
        local current_version
        cd "$PKG_DIR"

        current_version=$(head -1 debian/changelog |
                                 sed -e 's/.*(\([[:alnum:]:_+.~-]\+\)).*/\1/')

        if [ "$1" != "--keep-revision" ]; then
            if [ -z "$VERSION" ]; then
                new_version=$current_version
            else
                new_version=$VERSION
            fi
            if [[ $new_version =~ '-' ]]; then
                # change the existing revision suffix
                new_version=${new_version//-*/-$REVISION}
            else
                # add a revision suffix
                new_version=${new_version}-${REVISION}
            fi

            debchange='debchange'
            [ "$PACKAGE" ] && debchange="$debchange --package $PACKAGE"
            $debchange -v "$new_version" -b \
                       -D "$(lsb_release -cs)" \
                       --force-distribution \
                      "Build by debutant"
        fi
        if [ "$PBUILDER" ]; then
            pdebuild  --pbuilder cowbuilder
        else
            debuild -b -us -uc -a${DEB_HOST_ARCH}
        fi
    )
}

#
# test ths SHA256 sum of a file
#  OK: rc 0
#  Not OK or error: rc 1
check_sha256sum() {
    sha256sum -c <<<"$2  $1"
}

cleanup() {
    [ -d $BUILD_DIR ] && rm -r $BUILD_DIR
}

#
# create initial packaging files with dh_make
#
#  TODO: add option to send -p packagename_version to dh_make
#
debut_dh_make() {
    ( cd ${PKG_DIR}; yes | dh_make -y -s --native "$@")
    # modify rules file to override dh_strip
    debian_rules
    add_lintian_overrides
    # remove README file dummies:
    rm ${PKG_DIR}/debian/README*
    cat <<EOF > ${PKG_DIR}/debian/README.Debian
This package was generated with debutant.
EOF

}

# change an option in debian/control
debian_control()  {
    local key=$1
    local value="$2"

    sed -i -e "s|^\($key:\) .*|\1 $value|" ${PKG_DIR}/debian/control
}

# install a generic debian/rules
debian_rules() {
    [ -e "${PKG_DIR}/debian/rules" ] &&
        cp "${PKG_DIR}/debian/rules" "${PKG_DIR}/debian/rules.orig"
    cat > "${PKG_DIR}/debian/rules" <<EOF
#!/usr/bin/make -f
%:
EOF
# emacs tends to turn tabs into spaces, we'll clarify this:
    /bin/echo -e "\tdh \$@" >> "${PKG_DIR}/debian/rules"

    # stripping the provided binaries may or may not be a good idea
    # and breaks building for foreign architectures
    echo "override_dh_strip:" >> "${PKG_DIR}/debian/rules"

    chmod a+rx "${PKG_DIR}/debian/rules"
}


# TODO: Not implemented yet: add an override to a dh-style debian/rules file
#  (as created by debian_rules (see above) or dh_make
debian_rules_add_override() {
    :
}


# add something to debian/install
debian_install() {
    local pkg
    if [ "$1" == "-p" ]; then
        pkg=$2
        shift 2
    elif [ "$PACKAGE" ]; then
        # read the package name from the global envar,
        #  but only if debian/$PACKAGE.install exists
        #  or debian/install does not exist
        if  [ -e "$PKG_DIR/debian/$PACKAGE.install" ] ||
                [ ! -e "$PKG_DIR/debian/install" ]; then
            pkg=$PACKAGE
        fi
    fi

    echo "$@" >> "$PKG_DIR/debian/${pkg:+$pkg.}install"
}


# add something to debian/docs
debian_installdocs() {
    echo "$@" >> "$PKG_DIR/debian/docs"
}

# add something to debian/examples
debian_installexamples() {
    echo "$@" >> "$PKG_DIR/debian/examples"
}


# move pkg install scripts out of the way
#  TODO: Add them to the pkg documentation
disable_install_scripts() {
    SCRIPT_DIR=debutant/original_install_scripts
    mkdir -vp "$PKG_DIR/$SCRIPT_DIR"
    for script in preinst postinst prerm postrm; do
        [ -r "${PKG_DIR}/debian/$script" ] \
            && mv -v "${PKG_DIR}/debian/$script" "$PKG_DIR/$SCRIPT_DIR"
    done
    debian_installdocs $SCRIPT_DIR/
}


# copy over the created debs:
drop_result() {
    if [ "$1" ]; then
        cp -v "$@" .
    else
        find  "$BUILD_DIR" -maxdepth 1 \
              -\( -name \*.deb -o -name \*.changes -o -name \*.build -\) \
              -exec cp -v {} . \;
    fi
}


# detect the archive type of the given archive and extract it
extract() {
    local blob="$1"
    local dir=$2
    local mime

    if [ ! -r "$blob" ]; then
        [ -r "$BUILD_DIR/$blob" ] && blob=$BUILD_DIR/$blob
    fi

    [ "$dir" ] || dir=$BUILD_DIR

    [ -d "$dir" ] || mkdir -p "$dir"

    mime=$(mime_type "$blob")

    case $mime in

        application/gzip|application/x-gzip)
            case $blob in
                # TAR file:
                *.tar.gz|*.tgz)
                    tar xfz "$blob" -C "$dir"
                    ;;
                # something else:
                *)
                    gunzip -cd > "$dir/$(basename "$blob") .gz"
                    ;;
            esac
            ;;

       application/x-tar)
            tar xf "$blob" -C "$dir"
            ;;

        application/zip)
            unzip -d $dir $blob
            ;;

        application/x-dosexec)
            cabextract -d $dir $blob
            ;;

        application/x-rpm)
            (
                archive=`readlink -f "$blob"`
                cd $dir
                fakeroot alien -dsg --scripts --verbose "$archive"
                # TODO: replace alien comment in package description
                #  with debutant comment
                # sed -i -e 's/(Converted from a rpm package by alien .*/Package created by debutant .../' */debian/control
            )
            ;;

        # Debian package: extract with dpkg-deb; metadata goes to DEBIAN/
        application/x-debian-package|application/vnd.debian.binary-package|application/octet-stream)

            # on Squeeze debs are application/octet-stream
            if expr $blob : '.*\.deb' > /dev/null; then

                dpkg-deb -x $blob $dir         # normal package content
                mkdir -p $dir/DEBIAN
                dpkg-deb -e $blob $dir/DEBIAN  # debian metadata
            else
                abort "Unknown archive type $mine for $blob: $mime"
            fi
            ;;

        *)
            abort "Unknown archive type $mine for $blob: $mime"
            ;;
    esac
}


fetch() {
    local url=$1

    # guess the filename from the Location: header of the HTTP response
    #  (to prevent downloaded files being called 'download' aso.
    curl --silent --show-error --location --remote-name --remote-header-name \
         -\# $url -w "%{filename_effective}"
}


#
# list all available recipes:
#
list_recipes() {
    # TODO: Add a recipe description to the output
    echo "Available recipes:"
    for D in $RECIPE_DIRS; do
        [ -d $D ] || continue
        ls $D/*/recipe | xargs -n1 dirname | xargs -n1 basename | sort |
            sed -e "s/^/  /"
    done
}

# detect the mime type of a file
mime_type() {
    file --brief --mime-type "$1"
}

prepare() {
    # some preparations:
    ME=$(whoami)
    [ "$DEBEMAIL" ]    || DEBEMAIL="$ME@$(hostname -f)"
    [ "$DEBFULLNAME" ] ||
        DEBFULLNAME=$(getent passwd $ME | cut -f 5 -d : | cut -f 1 -d,)

    BUILD_DIR=$(mktemp -d -p .)

    PKG_DIR="${BUILD_DIR}/${RECIPE_NAME}"
    PACKAGE=$RECIPE_NAME

    DEBIAN_VERSION="$(lsb_release -is | tr [:upper:] [:lower:])$(lsb_release -rs)"
}


usage() {
    cat <<EOF
Usage: $(basename $0) [opts] <recipe>
Avalable options:
  -d:            debug output
  -l:            list available recipes
  -p:            use pbuilder for packaging
  -r <revision>: Debian package revision (default: 1)

EOF
    list_recipes
}

#export these functions to subshells (ie. our recipes):
export abort add_dependency cleanup debian_control debian_rules \
    disable_install_scripts extract fetch prepare

#########
#
# minimal recipe invocation logic
#

# search path for recipes:
# ... /usr/local/lib/debutnt/recipes??, /var/lib/debutant/recipes???
RECIPE_DIRS="$(dirname $0)/recipes /usr/lib/debutant/recipes"

REVISION=1

while : ; do
    case $1 in
        -d|--debug)
            DEBUG=1
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        -l|--list)
            list_recipes
            exit 0
            ;;
        -r|--revision)
            REVISION=$2
            shift
            ;;
        -p|--pbuilder)
            PBUILDER=1
            ;;
        *)
            break
            ;;
    esac

    shift
done

RECIPE_NAME=$1
shift

if [ -z "$RECIPE_NAME" ]; then
    list_recipes
    exit
fi

FOUND=

for D in $RECIPE_DIRS; do
    [ -d "$D" ] || continue
    if [ -e "$D/$RECIPE_NAME/recipe" ]; then
        FOUND=1

        set -e
        [ $DEBUG ] && set -x

        RECIPE_DIR="$(dirname $0)/recipes/$RECIPE_NAME"

        # preparations are performed here, not inside recipes
        prepare

        # now we have a BUILD_DIR
        # stage 1: extract and convert the archive
        . "$RECIPE_DIR/recipe" "$@"

        # now we have a PKG_DIR and put debian/... into it:
        #dh_make ... #preseeded with recipe config?
        #cp -b $RECIPE_DIR/debian/* $PKG_DIR/debian/

        # stage 2: customize debian files:
        #. $RECIPE_DIR/recipe package $@

        # stage 3: we build the package and clean up

        if [ $DEBUG ]; then
            set +x
        else
            # cleanup:
            [ -d "$BUILD_DIR" ] && rm -rf "$BUILD_DIR"
        fi
        break
    fi
done

[ "$FOUND" ] || abort "No recipe found for '$RECIPE_NAME'"