path: root/src/createpkg

#!/bin/bash
#
# createpkg: package builder using http://slack.sarava.org/slackbuilds scripts
# feedback: rhatto at riseup.net | gpl
#
#  createpkg 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 2 of the License, or any later version.
#
#  createpkg 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, write to the Free Software Foundation, Inc., 59 Temple
#  Place - Suite 330, Boston, MA 02111-1307, USA
#
# /etc/simplepkg/slackbuildrc parameters:
#
# SLACKBUILDS="/folder/to/place/slackbuilds", defaults to /var/slackbuilds
# SVN="svn://repository", defaults do svn://slack.sarava.org/slackbuilds
# SYNC="yes|no", whether to always update the repository
#
# TODO
#
# - optionally show a dependency tree before create the package
# - in function solve_dep: resolve program versions
# - mkdir source directory - error... (please check!)

#---------------------------------------------------
#               Createpkg functions
#---------------------------------------------------

function error_codes {

    # Slackbuilds error codes
    ERROR_WGET=31       # wget error
    ERROR_MAKE=32       # make source error
    ERROR_INSTALL=33    # make install error
    ERROR_MD5=34        # md5sum error
    ERROR_CONF=35       # ./configure error
    ERROR_HELP=36       # dasable
    ERROR_TAR=37        # tar error
    ERROR_MKPKG=38      # makepkg error
    ERROR_GPG=39        # gpg check error
    ERROR_PATCH=40      # patch error
    ERROR_VCS=41        # cvs error
    ERROR_MKDIR=42      # make directory error

    # Createpkg error codes
    ERROR_INSTPKG=200    # installpkg error
    ERROR_DEPEN=201      # dependency error
    SCRIPT_OR_PACKAGE_NOT_FOUND=202     # Script or package not found
}

function handle_error {

    # This function deals with internal createpkg errors
    # and also with non-zero exit codes from slackbuilds
    # Input:    $1 - error code
    # Output:   Error mensage
    #
    # check slackbuild exit status are:
    #
    # ERROR_WGET=31;      ERROR_MAKE=32;      ERROR_INSTALL=33
    # ERROR_MD5=34;       ERROR_CONF=35;      ERROR_HELP=36
    # ERROR_TAR=37;       ERROR_MKPKG=38      ERROR_GPG=39
    # ERROR_PATCH=40;     ERROR_VCS=41;       ERROR_MKDIR=42
    #
    # thanks to rudsonalves at yahoo.com.br for this spec.

    # we don't want to process when exit status = 0
    [ "$1" == "0" ] && return

    # Exit codes
    case $1 in
        2)  usage ;;
        3)  echo -e "$CL_ALERT $BASENAME: could not update the repository $2 $CL_OFF" ;;
        4)  echo -e "$CL_ALERT $BASENAME: could not create folder $2 $CL_OFF" ;;
        5)  echo -e "$CL_ALERT $BASENAME: script not found for $2 $CL_OFF" ;;
        $ERROR_WGET)
            echo -e "$CL_ERROR $BASENAME: error downloading source/package for $2 $CL_OFF" ;;
        $ERROR_MAKE)
            echo -e "$CL_ERROR $BASENAME: error compiling $2 source code $CL_OFF" ;;
        $ERROR_INSTALL)
            echo -e "$CL_ERROR $BASENAME: error installing $2 $CL_OFF" ;;
        $ERROR_MD5)
            echo -e "$CL_ERROR $BASENAME: error on source code integrity check for $2 $CL_OFF" ;;
        $ERROR_CONF)
            echo -e "$CL_ERROR $BASENAME: error configuring the source code for $2 $CL_OFF" ;;
        $ERROR_HELP)
            exit 0 ;; # its supposed to never happen here :P
        $ERROR_TAR)
            echo -e "$CL_ERROR $BASENAME: error decompressing source code for $2 $CL_OFF" ;;
        $ERROR_MKPKG)
            echo -e "$CL_ERROR $BASENAME: error creating package $2 $CL_OFF" ;;
        $ERROR_GPG)
            echo -e "$CL_ERROR $BASENAME: error verifying GPG signature the source code for $2 $CL_OFF" ;;
        $ERROR_PATCH)
            echo -e "$CL_ERROR $BASENAME: error patching the source code for $2 $CL_OFF" ;;
        $ERROR_VCS)
            echo -e "$CL_ERROR $BASENAME: error downloading $2 source from version control system $CL_OFF" ;;
        $ERROR_MKDIR)
            echo -e "$CL_ERROR $BASENAME: make directory $2 error, aborting $CL_OFF" ;;
        $ERROR_INSTPKG)
            echo -e "$CL_ERROR $BASENAME: install package $2 error, aborting $CL_OFF" ;;
        $ERROR_DEPEN)
            echo -e "$CL_ERROR $BASENAME: dependency solve error, aborting $CL_OFF" ;;
        *)  echo -e "$CL_ERROR $BASENAME: unknown error or user interrupt $CL_OFF" ;;
        $SCRIPT_OR_PACKAGE_NOT_FOUND)
            echo -e "$CL_ERROR $BASENAME: SlackBuild or package not found $CL_OFF" ;;
    esac

    exit $1

}

function build_repo {

    # Checkout a new slackbuild working copy
    BASEDIR="`dirname $SLACKBUILDS`"
    mkdir -p $BASEDIR || handle_error 4 $BASEDIR
    cd $BASEDIR
    svn checkout $SVN
    cd $SLACKBUILDS

}

function usage {

    # Help mensage
    echo -e "$CL_COMMU Usage: createpkg [--install/-i] package-name $CL_OFF"
    echo -e "$CL_COMMU        createpkg --no-deps/-np package-name $CL_OFF"
    echo -e "$CL_COMMU        createpkg --search/-s package-name $CL_OFF"
    echo -e "$CL_COMMU        createpkg --info/-f package-name $CL_OFF"
    echo -e "$CL_COMMU        createpkg --list/-l $CL_OFF"
    echo -e "$CL_COMMU        createpkg --sync $CL_OFF"
    echo -e "$CL_COMMU        createpkg --help/-h $CL_OFF"

}

function check_config {

    # check the configuration
    TMP=${TMP:=/tmp};
    REPOS=${REPOS:=$TMP};
    # Create $TMP and $REPOS if need
    [ ! -e $TPM ] && mkdir $TMP
    [ ! -e $REPOS ] && mkdir $REPOS
    #
    SLACKBUILDS=${SLACKBUILDS:=/var/slackbuilds}
    SVN=${SVN:=svn://slack.sarava.org/slackbuilds}
    SYNC=${SYNC:=no}
    BASEDIR="`dirname $SLACKBUILDS`"

}

function solve_dep {
    # Solve dependency
    local PACK="$1"
    local COND="$2"
    local VER="$3"

    # Check package in local system
    local INSTALLED=`eval "ls /var/log/packages/ | egrep '^$PACK-[^-]+-[^-]+-[^-]+$'"`

    # TODO: Make check version procedures
    if [ -z "$INSTALLED" ]; then
        if [ $? -ne 0 ]; then
            # Check package in SlackBuilds tree
            echo -e "$CL_MENSG $BASENAME: processing $PACKAGE dependency $PACK $CL_OFF"
            SYNC=no CREATEPKG_CHILD=$CREATEPKG_CHILD createpkg --install $PACK

            # check if the package was built and installed
            EXIT_CODE="$?"

            if [ "$EXIT_CODE" == "5" ]; then

                # exit code 5 == slackbuild not found
                # try to use simplaret
                ARCH=$DEFAULT_ARCH simplaret --update
                ARCH=$DEFAULT_ARCH simplaret --install $PACK
                EXIT_CODE="$?"
                if [ "$EXIT_CODE" != "0" ]; then
                    handle_error $SCRIPT_OR_PACKAGE_NOT_FOUND $PACK
                fi

            elif [ "$EXIT_CODE" != "0" ]; then
                handle_error $EXIT_CODE $PACK
            fi

        fi
    fi

}

function check_repo {

    # Verify if repository exist
    [ ! -d "$SLACKBUILDS" ] && build_repo

}

function sync_repo {

    # Synchronize repository
    cd $SLACKBUILDS
    svn update || build_repo
    #simplaret --update

}

function find_slackbuild {

    # Find SlackBuild script in the repository
    find $SLACKBUILDS -iname $1.SlackBuild

}

function info_builds {

    # Show packages info
    if [ "$PKG_PATH" != "" ]; then
        for i in $PKG_PATH; do
            PACKAGE=`basename $i .SlackBuild`
            NAME_UP=`echo $PACKAGE | tr [a-z] [A-Z]`
            echo -e "$CL_COMMU $NAME_UP: $CL_OFF"

            PKG_DIR=`dirname $i`
            if [ -e $PKG_DIR/slack-desc ]; then
                eval "cat $PKG_DIR/slack-desc | grep '^$PACKAGE:' | cut -f2- -d:"
                echo -e "$CL_OFF"
            else
                eval "cat $i | grep '^$PACKAGE:' | cut -f2- -d:"
                echo -e "$CL_OFF"
            fi

            if [ -e $PKG_DIR/slack-required ]; then
                echo -e "$CL_COMMU slack-required $CL_OFF"
                cat $PKG_DIR/slack-required | sed 's/^/ /'
            fi
        done
    fi

}

function list_builds {

    # List all available SlackBuilds
    cd $SLACKBUILDS
    echo "Sarava SlackBuilds list"
    # level 1
    for i in *; do
        if [ -d $i ]; then
            echo -e "  $i: "
            (
            cd $i
            # level 2
            for j in *; do
                if [ -d $j ]; then
                    echo -e "$CL_COMMU    $j $CL_OFF"
                    (
                    cd $j
                    BUILD="`ls *.SlackBuild 2>/dev/null`"
                    if [ "$BUILD" != "" ]; then
                        # level 3
                        for k in $BUILD; do
                            echo -e "$CL_MENSG      $k $CL_OFF"
                        done
                    else
                        BUILD=""
                    fi
                    for k in *; do
                        if [ -d $k ]; then
                            echo -e "$CL_MENSG      $k.SlackBuild $CL_OFF"
                        fi
                    done
                    )
                fi
            done
            )
        fi
    done
}

function color_select {
    # Select color mode: gray, color or none (*)
    # CL_COMMU - Communication
    # CL_MENSG - Commum messages
    # CL_ERROR - Error messages
    # CL_OFF   - turn off color
    case "$1" in
    'gray')
        CL_COMMU="\033[37;1m"
        CL_MENSG="\033[37;1m"
        CL_ERROR="\033[30;1m"
        CL_ALERT="\033[37m"
        CL_OFF="\033[m"
        ;;
    'color')
        CL_COMMU="\033[34;1m" # green
        CL_MENSG="\033[32;1m" # blue
        CL_ERROR="\033[31;1m" # red
        CL_ALERT="\033[33;1m" # yellow
        CL_OFF="\033[m"       # normal
        ;;
    *)
        CL_COMMU=""
        CL_MENSG=""
        CL_ERROR=""
        CL_ALERT=""
        CL_OFF=""
        ;;
    esac
}

#---------------------------------------------------
#                 Starting createpkg
#---------------------------------------------------
# Common functions
COMMON="/usr/libexec/simplepkg/common.sh"
SIMPLEPKG_CONF="/etc/simplepkg/simplepkg.conf"

# Loading error codes
error_codes

# First load simplepkg helper functions
source $COMMON && source $SIMPLEPKG_CONF
if [ $? -ne 0 ]; then
    echo -e "$CL_ERROR error: file $COMMON not found, check your $BASENAME installation $CL_OFF"
    exit 1
fi

# Load slackbuildrc definitions
if [ -f ~/.slackbuildrc ]; then
    source ~/.slackbuildrc
else
    source /etc/slackbuildrc 2>/dev/null
fi

# Select color mode: gray, color or none (*)
color_select $COLOR

# This is used to show how many children process we have
if [ -z "$CREATEPKG_CHILD" ]; then
    CREATEPKG_CHILD="1"
else
    let CREATEPKG_CHILD++
fi

BASENAME="`basename $0`[$CREATEPKG_CHILD]"

check_config
check_repo

case $1 in
    '--search'|'-s')
        [ $# -ne 2 ] && handle_error 2   # two parameters is required
        find_slackbuild $2
        exit
    ;;
    '--info'|'-f')
        [ $# -ne 2 ] && handle_error 2   # two parameters is required
        PKG_PATH=`find_slackbuild $2`
        info_builds
        exit
    ;;
    '--install'|'-i')
        [ $# -ne 2 ] && handle_error 2   # two parameters is required
        PACKAGE="$2"
        INSTALL="1"
    ;;
    '--no-deps'|'-nd')
        [ $# -ne 2 ] && handle_error 2   # two parameters is required
        NO_DEPS="1"
        PACKAGE="$2"
    ;;
    '--sync')
        sync_repo
        exit 0
    ;;
    '--help'|'-h'|'')
        usage
        exit 0
    ;;
    '--list'|'-l')
        list_builds
        exit 0
    ;;
    *)
        if [ "${1:0:1}" != "-" ]; then
            PACKAGE="$1"
        else
            handle_error 2
        fi
    ;;
esac

# Synchronize repository
[ "$SYNC" == "yes" ] && sync_repo

# Get SlackBuild script
BUILD_SCRIPT="`find_slackbuild $PACKAGE`"

# Select one SlackBuild
if [ "`echo $BUILD_SCRIPT | wc -w`" -gt 1 ]; then
    AUX="$PS3"
    PS3="Choice: "
    LIST=`echo $BUILD_SCRIPT | sed 's/ /\n/g' | sed -r 's/.*\/(.*)\.SlackBuild$/\1/'`" EXIT"
    select PACKAGE in `echo $LIST`; do
        break
    done
    if [ "$PACKAGE" = "EXIT" ]; then
        echo -e "$CL_ERROR error: None package select $CL_OFF"
        exit 1
    fi
    # Select only one SlackBuild in BUILD_SCRIPT
    BUILD_SCRIPT=`echo $BUILD_SCRIPT | sed 's/ /\n/g' | grep "/$PACKAGE.SlackBuild"`
    PS3="$AUX"
else
    PACKAGE=`echo $BUILD_SCRIPT | sed -r 's/.*\/(.*)\.SlackBuild$/\1/'`
fi

# Check SlackBuild script found
[ -z "$BUILD_SCRIPT" ] && handle_error 5 $PACKAGE

# Get dirname and script name from slackbuild
SCRIPT_BASE="`dirname $BUILD_SCRIPT`"
SCRIPT_NAME="`basename $BUILD_SCRIPT`"
echo -e "$CL_MENSG $BASENAME: found script $PACKAGE.SlackBuild, now checking for dependencies $CL_OFF"

# Sets the package's slack-required
if [ -f "$SCRIPT_BASE/$PACKAGE.slack-required" ]; then
    SLACK_REQUIRED="$SCRIPT_BASE/$PACKAGE.slack-required"
elif [ -f "$SCRIPT_BASE/slack-required" ]; then
    SLACK_REQUIRED="$SCRIPT_BASE/slack-required"
fi

if [ ! -z "$SLACK_REQUIRED" -a "$NO_DEPS" != "1" ]; then
    # this routine checks for dependencies in package's slack-required
    ( cat $SLACK_REQUIRED | while read dep; do
        if [ ! -z "$dep" ]; then
            PROGRAM="`echo $dep | awk '{ print $1 }'`"
            CONDITION="`echo $dep | awk '{ print $2 }' | tr [=\>\<] [egl]`"
            VERSION="`echo $dep | awk '{ print $3 }' | tr -dc '[:digit:]'`"
            solve_dep $PROGRAM $CONDITION $VERSION
        fi
        true
    done )
    if [ $? -ne 0 ]; then
        echo -e "$CL_MENSG $BASENAME: dependency solve error $CL_OFF"
        exit 1
    fi
    echo -e "$CL_MENSG $BASENAME: done checking for $PACKAGE dependencies $CL_OFF"
else
    echo -e "$CL_MENSG $BASENAME: no unmet dependencies for $PACKAGE $CL_OFF"
fi

echo -e "$CL_MENSG $BASENAME: processing $SCRIPT_NAME $CL_OFF"

# Built package
cd $SCRIPT_BASE
# Execute SlackBuild script with variables protection
( INTERACT=no ./$SCRIPT_NAME )

# Check if package was built
handle_error $? $PACKAGE

PKG_TGZ="`ls -1 -c $REPOS/$PACKAGE-*-*-*tgz | head -n 1`"

#mkdir -p $REPOS${SCRIPT_BASE/$SLACKBUILDS}
#mv $PKG_TGZ $REPOS${SCRIPT_BASE/$SLACKBUILDS}/

if [ "$INSTALL" == "1" ]; then
    # as we dont have the full package file name, we'll
    # use the newer file name that matches our wildcard:

    upgradepkg --install-new $PKG_TGZ
fi