bcm_git.sh

#! /bin/bash

set -e
bcm_modules=" \
data_full_release \
data_gfast_src \
voice_addon \
xpon_src \
bdkuserspace_src \
openwrtsupport_src \
voice_eptapp_addon \
"
bcm_pre_versions="\
test1 \
test2 \
test3 \
test4 \
test5 \
rc1 \
rc2"

cd_repo()
{
    local repo=$1
    if ! cd ${repo} 2>/dev/null
    then
        echo "repo [${repo}] does not exist. aborting!"
        exit 1
    fi
}


#
create_new_repo ()
{
    local repo=$1

    echo "-------------------------------------------------------------------------------"
    echo "creating new repo [$repo]!"

    if [ -e $repo ]
    then
        echo "repo already exising. aborting!!"
        exit 1
    fi

    mkdir -p $repo
    (
        cd_repo $repo
        git init
        echo "Master branch not used"  > readme.md
        git add readme.md
        git commit -m "created repo"
        git branch broadcom
    )
    echo "-------------------------------------------------------------------------------"
}

git_new_branch()
{
    local version=$1
    local module=$2

    # clean working dir
    git reset --hard
    git clean -ffxd

    # new branch
    git checkout bcm_${version}_t
    git branch bcm_${version}_${module}
    git checkout bcm_${version}_${module}

    # clean working dir
    git reset --hard
    git clean -ffdx

}

is_module_already_added_to_repo()
{
    local repo="$1"
    local module="$2"
    local version="$3"

    case "$module" in
    "data_full_release")
        git -C "$repo" tag | grep "bcm_${version}_t$" > /dev/null || return $?
        ;;
    *)
        git -C "$repo" branch -a | grep "bcm_${version}_${module}$" > /dev/null || return $?
    esac
}

add_release ()
{
    local version=$1
    local repo=$2
    local do_merge=0;  # only merge if the data_full_release was installed else skip.

    # to add a release the full src needs to exist
    if [ ! -f ${tar_dir}/bcm963xx_${version}_data_full_release.tar.gz ]
    then
        echo "Release bcm963xx_${version}_data_full_release.tar.gz does not exist skipping version ${version}"
        return
    fi

    for module in $bcm_modules
    do
        tar="bcm963xx_${version}_${module}.tar.gz"
        if is_module_already_added_to_repo "$repo" "$module" "$version"
        then
            echo "Already added ${version} "$module" (corresponding branch/tag exists already). Skipping!"
            continue
        fi

        if [ -f ${tar_dir}/${tar} ]
        then
            case ${module} in
            "data_full_release")
                echo -e "\t${tar}  this is the base module"

                # prep repo. clean out all old files
                git -C ${repo} checkout broadcom
                git -C ${repo} rm -rq .

                # unpack new release
                mkdir ${repo}/git_tmp
                echo "unpack $tar"
                tar_md5=$(cat ${tar_dir}/${tar} | md5sum)
                tar_name=$(basename $tar)
                pv ${tar_dir}/${tar}  | tar -xz -C ${repo}/git_tmp

                tar_src=$( basename $tar | sed -e "s/${module}/data_src/")
                echo "unpack $tar_src"
                mkdir ${repo}/bcm963xx
                # exclude any included git repo
                pv ${repo}/git_tmp/${tar_src} | tar -xz --exclude=\.git -C ${repo}/bcm963xx
                rm -rf ${repo}/git_tmp

                # add files to git
                echo "Now adding files to git. this takes some time"
                git -C ${repo} add -A -f
                git -C ${repo} commit --author="broadcom release<broadcom_release@broadcom.com>" \
                    -q -m "New release from broadcom added. $version" \
                    -m "file used is ${tar_md5} ${tar_name}"
                git -C ${repo} tag bcm_${version}_t
                do_merge=1
                ;;
            "voice_addon"|"voice_eptapp_addon")
                ( cd_repo $repo
                git_new_branch ${version} ${module}

                mkdir git_tmp
                tar_md5=$(cat ${tar_dir}/${tar} | md5sum)
                tar_name=$(basename $tar)
                pv ${tar_dir}/${tar} | tar -xz --exclude=\.git -C git_tmp
                cd git_tmp
                # if you think that you can do "yes | ./bcmvoiceinstall ../" you are wrong. does not work.
                echo "yy" | ./bcmvoiceinstall ../bcm963xx
                cd ..
                rm -rf git_tmp
                git add -A -f
                git commit --author="broadcom release<broadcom_release@broadcom.com>" \
                    -q -m "Add ${module} to release ${version}" \
                    -m "file used is ${tar_md5} ${tar_name}"
                )
                ;;
            "data_gfast_src")
                ( cd_repo $repo
                git_new_branch ${version} ${module}

                mkdir git_tmp
                tar_md5=$(cat ${tar_dir}/${tar} | md5sum)
                tar_name=$(basename $tar)
                pv ${tar_dir}/${tar} | tar -xz --exclude=\.git -C git_tmp
                tar -xf git_tmp/*tar.gz -C bcm963xx
                rm -rf git_tmp
                git add -A -f
                git commit --author="broadcom release<broadcom_release@broadcom.com>" \
                    -q -m "Add ${module} to release ${version}" \
                    -m "file used is ${tar_md5} ${tar_name}"
                )
                ;;
            "xpon_src")
                ( cd_repo $repo
                git_new_branch ${version} ${module}

                mkdir git_tmp
                tar_md5=$(cat ${tar_dir}/${tar} | md5sum)
                tar_name=$(basename $tar)
                pv ${tar_dir}/${tar} | tar -xz --exclude=\.git -C git_tmp

                rm -rf bcm963xx/userspace/private/apps/omcid/*
                rm -rf bcm963xx/bcmdrivers/broadcom/char/gpon/*
                rm -rf bcm963xx/userspace/private/libs/eponsdk

                tar -xf git_tmp/*tar.gz -C bcm963xx
                rm -rf git_tmp
                git add -A -f
                git commit --author="broadcom release<broadcom_release@broadcom.com>" \
                    -q -m "Add ${module} to release ${version}" \
                    -m "file used is ${tar_md5} ${tar_name}"
                )
                ;;
            "bdkuserspace_src"|"openwrtsupport_src")
                ( cd_repo $repo
                git_new_branch ${version} ${module}

                mkdir git_tmp
                tar_md5=$(cat ${tar_dir}/${tar} | md5sum)
                tar_name=$(basename $tar)
                pv ${tar_dir}/${tar} | tar -xz --exclude=\.git -C git_tmp

                for tar in git_tmp/*tar.gz
                do
                    tar --overwrite -xf $tar -C bcm963xx
                done
                rm -rf git_tmp
                git add -A -f
                git commit --author="broadcom release<broadcom_release@broadcom.com>" \
                    -q -m "Add ${module} to release ${version}" \
                    -m "file used is ${tar_md5} ${tar_name}"
                )
                ;;

            *)
                echo -e "\t${tar}"
                ;;
            esac
        else
            echo -e "\ttar not found. skipping $tar"
        fi
    done
    # all modules added make the main branch and do the octopus merge.
    # but only if the tag exist.
    # BUG: so octopus do not work since broadcom adds the same binary file in mutiple addon modules. :(
    if [ "$do_merge" == "1" ]
    then
        if git -C ${repo} tag  | grep "bcm_${version}_t$"
        then
            git -C ${repo} reset --hard
            git -C ${repo} clean -ffxd
            git -C ${repo} checkout bcm_${version}_t
            git -C ${repo} branch bcm_${version}
            git -C ${repo} checkout bcm_${version}
            git -C ${repo} reset --hard
            git -C ${repo} clean -ffxd
            branch_list=""
            for module in $bcm_modules
            do
                case ${module} in
                "data_full_release")
                    true
                    ;;
                *)
                    echo "trying to merge ${module} from branch ${version}_${module}"
                    if git -C ${repo} branch | grep "bcm_${version}_${module}$"
                    then
                        if ! git -C ${repo} merge --no-commit --no-ff -Xtheirs bcm_${version}_${module}
                        then
                            # so this merge did not work. clean up and skip it.
                            git -C ${repo} merge --abort
                            git -C ${repo} reset --hard
                            git -C ${repo} clean -ffxd
                        return
                        fi
                        git -C ${repo} commit --author="broadcom release<broadcom_release@broadcom.com>" \
                        -m "Merge in bcm_${version}_${module}"
                    fi
                    ;;
                esac
            done
        fi
    fi
}

add_all()
{
    local bcm_base_versions=$@

    for base_version in $bcm_base_versions
    do
        # pre release
        for pre_version in $bcm_pre_versions
        do
            echo "Adding release ${base_version}${pre_version}"
            add_release ${base_version}${pre_version} $repo_name
        done
        # real release
        echo "Adding release ${base_version}"
        add_release $base_version $repo_name
    done
}

usage()
{
 cat <<EOF
NAME
	bcm_git - adds Broadcom SDK and addons to a git repo

SYNOIPSIS
	bcm_git [OPTION]...

DESCRIPTION
	Will add a Broadcom release to a git repository. If the repository is empty is


	-r, --repo
		path to the git repository to use. If it do not exist it will be created.

	-R, --revision
		string of broadcom versions to add. ex
		-R "5.04L.01 5.04L.02"

	-t,--tars
		directory where the Broadcom SDK tar files is located.

	-v, --verbose
		bla bla

	-h, ---help
		display help thene exit.

EOF
}

# Convert long opts to short opts
for arg in "$@"; do
    shift
    case "$arg" in
    "--help")          set -- "$@" "-h" ;;
    "--revision")      set -- "$@" "-R" ;;
    "--repo")          set -- "$@" "-r" ;;
    "--tars")          set -- "$@" "-t" ;;
    "--prerelease")    set -- "$@" "-p" ;;
    *)                 set -- "$@" "$arg"
    esac
done

prerelease=0 # include prerelease ?? that is run add_all or add_release

# parse short opts
while getopts "hr:R:t:p" opt; do
    case ${opt} in
    h )
        usage
        exit 0
        ;;
    R )
        bcm_version=$OPTARG
        ;;
    t )
        # path to tar files needs to be absolute from / since the script is doing
        # cd into the git repo and the tar files needs to be accessed after that cd is done.
        if [ -d $(pwd)/$OPTARG ]
        then
            tar_dir=$(pwd)/$OPTARG
        else
            if [ -d$OPTARG ]
            then
                tar_dir=$OPTARG
            else
                echo "directory for tar files do not exist [$OPTARG]"
                exit 1
            fi
        fi
        ;;
    r )
        repo_name=$OPTARG
        ;;
    p )
        prerelease=1
        ;;

    esac
done
shift $((OPTIND -1))


# sanity check.
if [ -z "$bcm_version" ]
then
    echo "one revision needs to be given. ex  -R 5.04L.01 "
    exit 1
fi

if [ -z "$tar_dir" ]
then
    echo "The directory for the SDK tar files needs to be specified. ex -t ~/Downloads/"
    exit 1
fi

if [ -z "$repo_name" ]
then
    echo "The directory for the git repository needs to be specified. ex -r /tmp/testing"
    exit 1
fi

# if repo do not exist create it
if [ ! -d ${repo_name} ]
then
    create_new_repo $repo_name
fi

# do the import of tar files.
if  [ "$prerelease" == "1" ]
then
    add_all $bcm_version
else
    add_release $bcm_version $repo_name
fi

###############################################################################
#add_all "5.04L.01 5.04L.02"
#add_release 5.04L.01 $repo_name
#add_release 5.04L.02 $repo_name