flash

#!/usr/bin/env bash
#
# Flash Kernel compilation script
#
# Copyright (C) 2016-2017 Nathan Chancellor
#
# 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/>


################
#              #
#  PARAMETERS  #
#              #
################

# SOURCE OUR UNIVERSAL FUNCTIONS SCRIPT AND MAC CHECK
source common
# UNSET THE UNIVERSAL OS VARIABLE FOR THIS SCRIPT ONLY
unset OS

# GATHER PARAMETERS
PARAMS="$@"
while [[ $# -ge 1 ]]; do
    case "${1}" in
        # BRANCH TO COMPILE; IF ABSENT, USE CURRENT BRANCH
        "-b"|"--branch")
            shift && enforce_value $@

            KERNEL_BRANCH=${1} ;;

        # DEFCONFIG TO USE WHILE COMPILING; IF ABSENT, USE FLASH_DEFCONFIG
        "-c"|"--config")
            shift && enforce_value $@

            DEFCONFIG=${1} ;;

        # DEVICE TO COMPILE FOR; IF ABSENT, USE ONEPLUS5
        "-d"|"--device")
            shift && enforce_value $@

            DEVICE=${1} ;;

        # SHOW FULL COMPILATION, NOT JUST WARNINGS AND ERRORS
        "-D"|"--debug")
            DEBUG=true ;;

        # EXTRA MAKE FLAGS IF NECESSARY (LIKE MISMATCH CONFIG)
        "-f"|"--flags")
            shift && enforce_value $@

            EXTRA_MAKE_FLAGS=${1} ;;

        # WHERE TO MOVE ZIP AFTER COMPILATION (PRIVATE, TEST, OR PUBLIC)
        "-m"|"--mode")
            shift && enforce_value $@

            MODE=${1} ;;

        # DON'T MOVE/DELETE ZIPS IN ZIP_MOVE FOLDER
        "-n"|"--no-clean")
            NOCLEAN=true ;;

        # (ONEPLUS 5 ONLY) CUSTOM ROMS OR OXYGENOS BUILD
        "-os"|"--operating-system")
            shift && enforce_value $@

            OS=${1} ;;

        # BETA VERSIONING (# IN KERNEL VERSION)
        "-r"|"--revision")
            shift && enforce_value $@

            REVISION=${1} ;;

        # TOOLCHAIN TO USE WHILE COMPILING
        "-t"|"--toolchain")
            shift && enforce_value $@

            TOOLCHAIN_NAME=${1} ;;

        # (ONEPLUS 5 ONLY) VERSION CODE
        "-v"|"--version")
            shift && enforce_value $@

            VERSION=${1} ;;

        *)
            report_error "Invalid parameter" ;;
    esac

    shift
done

# DEFAULT PARAMETERS
[[ -z ${DEFCONFIG} ]] && DEFCONFIG="flash_defconfig"
[[ -z ${DEVICE} ]] && DEVICE="op5"
[[ -z ${MODE} ]] && MODE="personal"
[[ -z ${TOOLCHAIN_NAME} ]] && TOOLCHAIN_NAME="l-7.x"

# DEVICE HANDLING
case ${DEVICE} in
    "angler")
        AK_SFX=public-8.0.0
        TC_TARGET=-a57.a53 ;;

    "op5")
        AK_SFX=7.1.x
        TC_TARGET=-a73.a53

        [[ -z ${OS} ]] && OS=OOS
        [[ -n ${VERSION} ]] && VERSION="-v${VERSION}"
        export LOCALVERSION="-${OS}${VERSION}"

        MATCH_FLAG="--match=*${OS}*"
        OS=/${OS,,} ;;

    *)
        report_error "Invalid device!" ;;
esac


###############
#             #
#  VARIABLES  #
#             #
###############

# FOLDERS
SOURCE_FOLDER=${KERNEL_FOLDER}/${DEVICE}
OUT_FOLDER=${SOURCE_FOLDER}/out
ANYKERNEL_FOLDER=${KERNEL_FOLDER}/anykernel
ANYKERNEL_BRANCH=${DEVICE}-flash-${AK_SFX}
MODULES_FOLDER=${ANYKERNEL_FOLDER}/modules
ZIP_MOVE_HEAD=${WEB_FOLDER}/downloads

case ${MODE} in
    "alpha"|"beta"|"rc"|"stable")
        ZIP_MOVE=${ZIP_MOVE_HEAD}/kernels/${DEVICE}${OS}/${MODE}
        ZIP_MOVE_OLD=$(readlink -f ${ZIP_MOVE}/../archive) ;;
    "personal")
        ZIP_MOVE=$(readlink -f ${ZIP_MOVE_HEAD}/../me/fk) ;;
    "transfer")
        ZIP_MOVE=${ANYKERNEL_FOLDER} ;;
    *)
        report_error "Invalid mode specified!" ;;
esac

case ${TOOLCHAIN_NAME} in
    "a-4.9")
        unset TC_TARGET
        TOOLCHAIN_PREFIX=aarch64-linux-android- ;;
    "l-7.x")
        TOOLCHAIN_PREFIX=aarch64-linaro-linux-android- ;;
    "g-8.x")
        TOOLCHAIN_PREFIX=aarch64-gnu-linux-gnu- ;;
    *)
        report_error "Invalid toolchain specified!" ;;
esac

# COMPILATION VARIABLES
ARCHITECTURE=arm64
CCACHE=$(command -v ccache)
IMAGE=${OUT_FOLDER}/arch/${ARCHITECTURE}/boot/Image.gz-dtb
TOOLCHAIN=/opt/${TOOLCHAIN_NAME}${TC_TARGET}/bin/${TOOLCHAIN_PREFIX}


###############
#             #
#  FUNCTIONS  #
#             #
###############


# CLEAN UP
function clean_up() {
    # CLEAN ANYKERNEL FOLDER
    cd "${ANYKERNEL_FOLDER}"
    git checkout ${ANYKERNEL_BRANCH}
    git clean -fxd

    # ONLY CHECKOUT IF KERNEL_BRANCH EXISTS AND WE AREN'T BISECTING OR REBASING
    cd "${SOURCE_FOLDER}"
    if [[ -n ${KERNEL_BRANCH} ]]; then
        [[ ! $(git status | ag "bisec|rebas") ]] && git checkout ${KERNEL_BRANCH}
    # OTHERWISE, NOTATE CURRENT BRANCH FOR CHANGELOG
    else
        export KERNEL_BRANCH=$(git rev-parse --abbrev-ref HEAD)
    fi
    # CLEAN SOURCE FOLDER:
    git clean -fxd
    # MAKE OUT FOLDER (IT GETS REMOVED PER CLEAN UP FUNCTION)
    mkdir -p ${OUT_FOLDER}
}

# MAKE WRAPPER FOR MAKE FUNCTION
function make_wrapper() {
    make ${JOBS_FLAG} \
         ARCH=${ARCHITECTURE} \
         CROSS_COMPILE="${CCACHE} ${TOOLCHAIN}" \
         O=${OUT_FOLDER} \
         "$@"
}


# SILENCE OUTPUT FUNCTION
function kmake() {
    # ONLY SHOW ERRORS, WARNINGS, AND THE IMAGE LINE WHEN COMPILING (UNLESS DEBUG)
    [[ ${DEBUG} = true ]] && make_wrapper "$@" \
                          || make_wrapper "$@" |& ag --no-color "error:|warning:" && echo
}


# SETUP COMPILATION
function setup_compilation() {
    # POINT TO PROPER DEFCONFIG AND GENERATE VERSION FILES
    kmake ${DEFCONFIG} prepare

    FULL_VERSION=$(cat ${OUT_FOLDER}/include/config/kernel.release)
    FLASH_VERSION=$(echo ${FULL_VERSION} | sed s/"$(make kernelversion)"-//)

    # REVISION IS PASSED AS A PARAMETER FOR ANYTHING OTHER THAN STABLE VERSIONS
    [[ -n ${REVISION} ]] && REVISION=".${MODE::1}${REVISION}"

    # IF THE MODE ISN'T STABLE, ADD SHA INFORMATION TO THE ZIP
    [[ "${MODE}" != "stable" ]] && SHA="-g$(git rev-parse --verify --short HEAD)"

    # EXPORT KERNEL_NAME BASED ON THE ABOVE INFORMATION
    export KERNEL_NAME=${FLASH_VERSION}${REVISION}${SHA}

    # SET ZIP NAMES
    export UNSIGNED_ZIP=${KERNEL_NAME}-unsigned.zip
    export SIGNAPK_ZIP=${KERNEL_NAME}-signapk.zip
    export ADJUSTED_ZIP=${KERNEL_NAME}-adjusted.zip
    export SIGNED_ZIP=${KERNEL_NAME}.zip

    [[ -n ${CCACHE} ]] && CCACHE_SUPPORT="${GRN}Yes, found at ${CCACHE}${RST}" \
                       || CCACHE_SUPPORT="${RED}No, please install it!${RST}"

    echo "${BOLD}Kernel version:${RST}    ${FULL_VERSION}\n"

    echo "${BOLD}Full zip name:${RST}     ${SIGNED_ZIP}\n"

    echo "${BOLD}Current branch:${RST}    ${KERNEL_BRANCH}\n"

    echo "${BOLD}Toolchain path:${RST}    ${TOOLCHAIN}\n"

    echo "${BOLD}GCC version:${RST}       $(${TOOLCHAIN}gcc --version | head -1)\n"

    echo "${BOLD}ccache support?${RST}    ${CCACHE_SUPPORT}\n"
}


# MAKE KERNEL
function build_kernel() {
    # INCREMENT DIRTY VERSION NUMBER IF PASSED ABOVE
    [[ -n ${REVISION} && ${REVISION:2:3} -gt 0 ]] && \
            echo $((${REVISION:2:3} - 1)) > ${OUT_FOLDER}/.version

    # MAKE THE KERNEL
    kmake ${EXTRA_MAKE_FLAGS}
}


# SETUP FOLDERS
function setup_folders() {
    # THIS IS A NO-OP FOR TRANSFER MODE
    [[ ${MODE} = "transfer" ]] && return

    echo "  - Setting up final folders"

    # IF ZIPMOVE DOESN'T EXIST, MAKE IT
    [[ ! -d "${ZIP_MOVE}" ]] && mkdir -p "${ZIP_MOVE}"

    # IF IT ISN'T A STABLE BUILD, CLEAN THE FOLDER
    if [[ ${MODE} != "stable" ]]; then
        [[ -z ${NOCLEAN} ]] && rm -rf "${ZIP_MOVE}"/*
    else
        # OTHERWISE, MOVE THE OLD FILES TO AN "OLD" FOLDER
        [[ ! -d "${ZIP_MOVE_OLD}" ]] && mkdir -p "${ZIP_MOVE_OLD}"
        mv $(find "${ZIP_MOVE}"/* -maxdepth 0 -type f) \
           "${ZIP_MOVE_OLD}" &>/dev/null
    fi
}


# PACKAGE ZIP
function package_zip() {
    echo "  - Packaging zip file"

    cd "${ANYKERNEL_FOLDER}"

    # MOVE THE KERNEL IMAGE
    cp "${IMAGE}" "${ANYKERNEL_FOLDER}"

    # GRAB MODULES TOO IF THEY ARE PRESENT
    mkdir -p ${MODULES_FOLDER}
    find ${OUT_FOLDER} -name "*.ko" -exec cp {} ${MODULES_FOLDER} \;
    [[ $(ls -A ${MODULES_FOLDER}) ]] \
            && ${TOOLCHAIN}strip --strip-unneeded ${MODULES_FOLDER}/*.ko \
            || rm -rf ${MODULES_FOLDER}

    # PACKAGE THE ZIP WITHOUT THE README
    zip -q -r9 ${UNSIGNED_ZIP} * -x README.md ${UNSIGNED_ZIP}

    # SIGN ZIP
    java -jar ${BIN_FOLDER}/signapk.jar \
              ${BIN_FOLDER}/testkey.x509.pem \
              ${BIN_FOLDER}/testkey.pk8 \
              ${UNSIGNED_ZIP} \
              ${SIGNAPK_ZIP}

    ${BIN_FOLDER}/zipadjust ${SIGNAPK_ZIP} ${ADJUSTED_ZIP} &>/dev/null

    java -jar ${BIN_FOLDER}/minsignapk.jar \
              ${BIN_FOLDER}/testkey.x509.pem \
              ${BIN_FOLDER}/testkey.pk8 \
              ${ADJUSTED_ZIP} \
              ${SIGNED_ZIP}

    # IF PACKAGING FAILED, ERROR OUT
    [[ ! -f ${SIGNED_ZIP} ]] && report_error "Kernel zip not found after signing!"
}

# MOVE FILES AND GENERATE MD5SUM
function move_files() {
    # THIS IS A NO-OP FOR TRANSFER MODE
    [[ ${MODE} = "transfer" ]] && return

    echo "  - Moving files to web folder"

    mv ${SIGNED_ZIP} "${ZIP_MOVE}"

    md5sum "${ZIP_MOVE}"/${SIGNED_ZIP} > "${ZIP_MOVE}"/${SIGNED_ZIP}.md5
}


# GENERATE CHANGELOG
function generate_changelog() {
    # THIS IS A NO-OP FOR TRANSFER MODE
    [[ ${MODE} = "transfer" ]] && return

    echo "  - Generating changelog"

    GITHUB="http://github.com/nathanchance"
    CHANGELOG="${ZIP_MOVE}"/${KERNEL_NAME}-changelog.txt

    # KERNEL SOURCE FIRST
    cd "${SOURCE_FOLDER}"

    # WE NEED TO MARK THE PREVIOUS TAG FOR CHANGELOG
    PREV_TAG_NAME=$(git describe --abbrev=0 --tags ${MATCH_FLAG})
    RANGE=${PREV_TAG_NAME}..HEAD

    # SHOW WHERE COMMITS ARE LOCATED
    echo "${GITHUB}/${DEVICE}/commits/${KERNEL_BRANCH}\n" > ${CHANGELOG}

    # USE SHORTLOG FOR PRETTY OUTPUT
    git log ${RANGE} | git shortlog >> ${CHANGELOG}

    # GENERATE A DIFF AS WELL
    git diff -M --stat --summary ${RANGE} >> ${CHANGELOG}

    # ANYKERNEL NEXT
    cd "${ANYKERNEL_FOLDER}"

    # WE ONLY WANT TO SHOW ANYKERNEL CHANGES IF THERE HAVE BEEN SOME
    NUM_COMMITS=$(git log ${RANGE} --pretty=oneline | wc -l)

    if [[ ${NUM_COMMITS} -gt 0 ]]; then
        echo "\n\n${GITHUB}/AnyKernel2/commits/${ANYKERNEL_BRANCH}\n" >> ${CHANGELOG}

        git log ${RANGE} | git shortlog >> ${CHANGELOG}

        git diff -M --stat --summary ${RANGE} >> ${CHANGELOG}
    fi
}


# PUSH KERNEL ZIPS TO GITHUB
function push_zip() {
    if [[ ${MODE} = "transfer" ]]; then
        echo "  - Uploading zip to transfer.sh"
        TRANSFER_LINK=$(curl -s --upload-file \
                        "${ZIP_MOVE}"/${SIGNED_ZIP} \
                        https://transfer.sh/${SIGNED_ZIP})
        return
    fi

    echo "  - Pushing files to GitHub"

    cd "${ZIP_MOVE}"

    git add ..

    git commit -q --signoff -m "$(date +%Y%m%d): ${KERNEL_NAME}"

    git push -q
}


# TAG FOR STABLE RELEASES
function tag_stable() {
    echo "  - Tagging ${KERNEL_NAME} as stable"

    cd "${SOURCE_FOLDER}"

    git tag -a "${KERNEL_NAME}" -m "${KERNEL_NAME}"
    git push -q origin "${KERNEL_NAME}"

    cd "${ANYKERNEL_FOLDER}"

    git tag -a "${KERNEL_NAME}" -m "${KERNEL_NAME}"
    git push -q origin "${KERNEL_NAME}"
}


# PRINT FILE INFO
function ending_info() {
    echo "\n$(date +"%m/%d/%Y %H:%M:%S"): ${BASH_SOURCE} ${PARAMS}" >> ${LOG}
    echo "${BUILD_RESULT} IN $(format_time ${END} ${START})" >> ${LOG}

    if [[ ${BUILD_RESULT} = "BUILD SUCCESSFUL" ]]; then
        [[ -n ${TRANSFER_LINK} ]] && FILE_LOCATION=${TRANSFER_LINK} \
                                  || FILE_LOCATION=$(web_link ${ZIP_MOVE})

        echo "FILE LINK: ${FILE_LOCATION}" >> ${LOG}

        echo ${RED}"FILE LOCATION: ${FILE_LOCATION}"
        echo "SIZE: $(du -h ${ZIP_MOVE}/${SIGNED_ZIP} |
                          awk '{print $1}')"${RST}
    fi

    echo ${RED}"TIME: $(date +%D\ %r | awk '{print toupper($0)}')"
    echo "DURATION: $(format_time ${END} ${START})"${RST}; echo
}



################
#              #
# SCRIPT START #
#              #
################

START=$(date +"%s")

clear
echo ${RED}
echo
echo "================================================================================================"
echo
echo
echo "  ___________________________________  __   ______ _______________________   ________________   "
echo "  ___  ____/__  /___    |_  ___/__  / / /   ___  //_/__  ____/__  __ \__  | / /__  ____/__  /   "
echo "  __  /_   __  / __  /| |____ \__  /_/ /    __  ,<  __  __/  __  /_/ /_   |/ /__  __/  __  /    "
echo "  _  __/   _  /___  ___ |___/ /_  __  /     _  /| | _  /___  _  _, _/_  /|  / _  /___  _  /___  "
echo "  /_/      /_____/_/  |_/____/ /_/ /_/      /_/ |_| /_____/  /_/ |_| /_/ |_/  /_____/  /_____/  "
echo
echo
echo
echo "================================================================================================"
echo


#################
# MAKING KERNEL #
#################

header "CLEANING UP AND MAKING KERNEL"

# DON'T SHOW CLEAN UP OUTPUT
clean_up &>/dev/null

# SETUP FOR COMPILATION
setup_compilation

# BUILD KERNEL
build_kernel


######################
# IF KERNEL COMPILED #
######################

if [[ -f ${IMAGE} ]]; then
    BUILD_RESULT="BUILD SUCCESSFUL"

    header "BUILDING FLASHABLE ZIP"

    setup_folders
    package_zip
    move_files
    generate_changelog

    [[ ${MODE} != "personal" ]] && push_zip

    [[ ${MODE} = "stable" ]] && tag_stable

    echo

###################
# IF BUILD FAILED #
###################

else
    BUILD_RESULT="BUILD FAILED"
fi


######################
# ENDING INFORMATION #
######################

END=$(date +"%s")

header "${BUILD_RESULT}!"

ending_info

echo "\a"