| # Copyright 1999-2014 Gentoo Foundation | |
| # Distributed under the terms of the GNU General Public License v2 | |
| # @ECLASS: git-2.eclass | |
| # @MAINTAINER: | |
| # maintainer-needed@gentoo.org | |
| # @BLURB: Eclass for fetching and unpacking git repositories. | |
| # @DESCRIPTION: | |
| # Eclass for easing maintenance of live ebuilds using git as remote repository. | |
| # Eclass support working with git submodules and branching. | |
| # | |
| # This eclass is DEPRECATED. Please use git-r3 instead. | |
| # This eclass support all EAPIs. | |
| EXPORT_FUNCTIONS src_unpack | |
| PROPERTIES+=" live" | |
| # NB: We omit git for older EAPI's to avoid circular deps in board sysroots. | |
| if [[ ${EAPI:-0} != [0123456] ]]; then | |
| BDEPEND="dev-vcs/git" | |
| fi | |
| # @ECLASS-VARIABLE: EGIT_SOURCEDIR | |
| # @DESCRIPTION: | |
| # This variable specifies destination where the cloned | |
| # data are copied to. | |
| # | |
| # EGIT_SOURCEDIR="${S}" | |
| # @ECLASS-VARIABLE: EGIT_STORE_DIR | |
| # @DESCRIPTION: | |
| # Storage directory for git sources. | |
| # | |
| # EGIT_STORE_DIR="${DISTDIR}/egit-src" | |
| # @ECLASS-VARIABLE: EGIT_HAS_SUBMODULES | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable enables support for git submodules in our | |
| # checkout. Also this makes the checkout to be non-bare for now. | |
| # @ECLASS-VARIABLE: EGIT_OPTIONS | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # Variable specifying additional options for fetch command. | |
| # @ECLASS-VARIABLE: EGIT_MASTER | |
| # @DESCRIPTION: | |
| # Variable for specifying master branch. | |
| # Useful when upstream don't have master branch or name it differently. | |
| # | |
| # EGIT_MASTER="master" | |
| # @ECLASS-VARIABLE: EGIT_PROJECT | |
| # @DESCRIPTION: | |
| # Variable specifying name for the folder where we check out the git | |
| # repository. Value of this variable should be unique in the | |
| # EGIT_STORE_DIR as otherwise you would override another repository. | |
| # | |
| # EGIT_PROJECT="${EGIT_REPO_URI##*/}" | |
| # @ECLASS-VARIABLE: EGIT_DIR | |
| # @DESCRIPTION: | |
| # Directory where we want to store the git data. | |
| # This variable should not be overridden. | |
| # | |
| # EGIT_DIR="${EGIT_STORE_DIR}/${EGIT_PROJECT}" | |
| # @ECLASS-VARIABLE: EGIT_REPO_URI | |
| # @REQUIRED | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # URI for the repository | |
| # e.g. http://foo, git://bar | |
| # | |
| # It can be overridden via env using packagename_LIVE_REPO | |
| # variable. | |
| # | |
| # Support multiple values: | |
| # EGIT_REPO_URI="git://a/b.git http://c/d.git" | |
| # @ECLASS-VARIABLE: EVCS_OFFLINE | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable prevents performance of any online | |
| # operations. | |
| # @ECLASS-VARIABLE: EGIT_BRANCH | |
| # @DESCRIPTION: | |
| # Variable containing branch name we want to check out. | |
| # It can be overridden via env using packagename_LIVE_BRANCH | |
| # variable. | |
| # | |
| # EGIT_BRANCH="${EGIT_MASTER}" | |
| # @ECLASS-VARIABLE: EGIT_COMMIT | |
| # @DESCRIPTION: | |
| # Variable containing commit hash/tag we want to check out. | |
| # It can be overridden via env using packagename_LIVE_COMMIT | |
| # variable. | |
| # | |
| # EGIT_COMMIT="${EGIT_BRANCH}" | |
| # @ECLASS-VARIABLE: EGIT_REPACK | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable specifies that repository will be repacked to | |
| # save space. However this can take a REALLY LONG time with VERY big | |
| # repositories. | |
| # @ECLASS-VARIABLE: EGIT_PRUNE | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable enables pruning all loose objects on each fetch. | |
| # This is useful if upstream rewinds and rebases branches often. | |
| # @ECLASS-VARIABLE: EGIT_NONBARE | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable specifies that all checkouts will be done using | |
| # non bare repositories. This is useful if you can't operate with bare | |
| # checkouts for some reason. | |
| # @ECLASS-VARIABLE: EGIT_NOUNPACK | |
| # @DEFAULT_UNSET | |
| # @DESCRIPTION: | |
| # If non-empty this variable bans unpacking of ${A} content into the srcdir. | |
| # Default behavior is to unpack ${A} content. | |
| # @FUNCTION: git-2_init_variables | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function initializing all git variables. | |
| # We define it in function scope so user can define | |
| # all the variables before and after inherit. | |
| git-2_init_variables() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local esc_pn liverepo livebranch livecommit | |
| esc_pn=${PN//[-+]/_} | |
| : ${EGIT_SOURCEDIR="${S}"} | |
| : ${EGIT_STORE_DIR:="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/egit-src"} | |
| : ${EGIT_HAS_SUBMODULES:=} | |
| : ${EGIT_OPTIONS:=} | |
| : ${EGIT_MASTER:=master} | |
| liverepo=${esc_pn}_LIVE_REPO | |
| EGIT_REPO_URI=${!liverepo:-${EGIT_REPO_URI}} | |
| [[ ${EGIT_REPO_URI} ]] || die "EGIT_REPO_URI must have some value" | |
| : ${EVCS_OFFLINE:=} | |
| livebranch=${esc_pn}_LIVE_BRANCH | |
| [[ ${!livebranch} ]] && ewarn "QA: using \"${esc_pn}_LIVE_BRANCH\" variable, you won't get any support" | |
| EGIT_BRANCH=${!livebranch:-${EGIT_BRANCH:-${EGIT_MASTER}}} | |
| livecommit=${esc_pn}_LIVE_COMMIT | |
| [[ ${!livecommit} ]] && ewarn "QA: using \"${esc_pn}_LIVE_COMMIT\" variable, you won't get any support" | |
| EGIT_COMMIT=${!livecommit:-${EGIT_COMMIT:-${EGIT_BRANCH}}} | |
| : ${EGIT_REPACK:=} | |
| : ${EGIT_PRUNE:=} | |
| } | |
| # @FUNCTION: git-2_submodules | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function wrapping the submodule initialisation and update. | |
| git-2_submodules() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| if [[ ${EGIT_HAS_SUBMODULES} ]]; then | |
| if [[ ${EVCS_OFFLINE} ]]; then | |
| # for submodules operations we need to be online | |
| debug-print "${FUNCNAME}: not updating submodules in offline mode" | |
| return 1 | |
| fi | |
| debug-print "${FUNCNAME}: working in \"${1}\"" | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| debug-print "${FUNCNAME}: git submodule init" | |
| git submodule init || die | |
| debug-print "${FUNCNAME}: git submodule sync" | |
| git submodule sync || die | |
| debug-print "${FUNCNAME}: git submodule update" | |
| git submodule update || die | |
| popd > /dev/null || die | |
| fi | |
| } | |
| # @FUNCTION: git-2_branch | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function that changes branch for the repo based on EGIT_COMMIT and | |
| # EGIT_BRANCH variables. | |
| git-2_branch() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local branchname src | |
| debug-print "${FUNCNAME}: working in \"${EGIT_SOURCEDIR}\"" | |
| pushd "${EGIT_SOURCEDIR}" > /dev/null || die | |
| local branchname=branch-${EGIT_BRANCH} src=origin/${EGIT_BRANCH} | |
| if [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]]; then | |
| branchname=tree-${EGIT_COMMIT} | |
| src=${EGIT_COMMIT} | |
| fi | |
| debug-print "${FUNCNAME}: git checkout -b ${branchname} ${src}" | |
| git checkout -b ${branchname} ${src} \ | |
| || die "${FUNCNAME}: changing the branch failed" | |
| popd > /dev/null || die | |
| } | |
| # @FUNCTION: git-2_gc | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function running garbage collector on checked out tree. | |
| git-2_gc() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local args | |
| if [[ ${EGIT_REPACK} || ${EGIT_PRUNE} ]]; then | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| ebegin "Garbage collecting the repository" | |
| [[ ${EGIT_PRUNE} ]] && args='--prune' | |
| debug-print "${FUNCNAME}: git gc ${args}" | |
| git gc ${args} | |
| eend $? | |
| popd > /dev/null || die | |
| fi | |
| } | |
| # @FUNCTION: git-2_prepare_storedir | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function preparing directory where we are going to store SCM | |
| # repository. | |
| git-2_prepare_storedir() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local clone_dir | |
| # initial clone, we have to create master git storage directory and play | |
| # nicely with sandbox | |
| if [[ ! -d ${EGIT_STORE_DIR} ]]; then | |
| debug-print "${FUNCNAME}: Creating git main storage directory" | |
| addwrite / | |
| mkdir -m 775 -p "${EGIT_STORE_DIR}" \ | |
| || die "${FUNCNAME}: can't mkdir \"${EGIT_STORE_DIR}\"" | |
| fi | |
| # allow writing into EGIT_STORE_DIR | |
| addwrite "${EGIT_STORE_DIR}" | |
| # calculate git.eclass store dir for data | |
| # We will try to clone the old repository, | |
| # and we will remove it if we don't need it anymore. | |
| EGIT_OLD_CLONE= | |
| if [[ ${EGIT_STORE_DIR} == */egit-src ]]; then | |
| local old_store_dir=${EGIT_STORE_DIR/%egit-src/git-src} | |
| local old_location=${old_store_dir}/${EGIT_PROJECT:-${PN}} | |
| if [[ -d ${old_location} ]]; then | |
| EGIT_OLD_CLONE=${old_location} | |
| # required to remove the old clone | |
| addwrite "${old_store_dir}" | |
| fi | |
| fi | |
| # calculate the proper store dir for data | |
| # If user didn't specify the EGIT_DIR, we check if he did specify | |
| # the EGIT_PROJECT or get the folder name from EGIT_REPO_URI. | |
| EGIT_REPO_URI=${EGIT_REPO_URI%/} | |
| if [[ ! ${EGIT_DIR} ]]; then | |
| if [[ ${EGIT_PROJECT} ]]; then | |
| clone_dir=${EGIT_PROJECT} | |
| else | |
| local strippeduri=${EGIT_REPO_URI%/.git} | |
| clone_dir=${strippeduri##*/} | |
| fi | |
| EGIT_DIR=${EGIT_STORE_DIR}/${clone_dir} | |
| if [[ ${EGIT_OLD_CLONE} && ! -d ${EGIT_DIR} ]]; then | |
| elog "${FUNCNAME}: ${CATEGORY}/${PF} will be cloned from old location." | |
| elog "It will be necessary to rebuild the package to fetch updates." | |
| EGIT_REPO_URI="${EGIT_OLD_CLONE} ${EGIT_REPO_URI}" | |
| fi | |
| fi | |
| export EGIT_DIR=${EGIT_DIR} | |
| debug-print "${FUNCNAME}: Storing the repo into \"${EGIT_DIR}\"." | |
| } | |
| # @FUNCTION: git-2_move_source | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function moving sources from the EGIT_DIR to EGIT_SOURCEDIR dir. | |
| git-2_move_source() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| debug-print "${FUNCNAME}: ${MOVE_COMMAND} \"${EGIT_DIR}\" \"${EGIT_SOURCEDIR}\"" | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| mkdir -p "${EGIT_SOURCEDIR}" \ | |
| || die "${FUNCNAME}: failed to create ${EGIT_SOURCEDIR}" | |
| ${MOVE_COMMAND} "${EGIT_SOURCEDIR}" \ | |
| || die "${FUNCNAME}: sync to \"${EGIT_SOURCEDIR}\" failed" | |
| popd > /dev/null || die | |
| } | |
| # @FUNCTION: git-2_initial_clone | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function running initial clone on specified repo_uri. | |
| git-2_initial_clone() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local repo_uri | |
| EGIT_REPO_URI_SELECTED="" | |
| for repo_uri in ${EGIT_REPO_URI}; do | |
| debug-print "${FUNCNAME}: git clone ${EGIT_LOCAL_OPTIONS} \"${repo_uri}\" \"${EGIT_DIR}\"" | |
| local retry=3 | |
| while [[ $retry != 0 ]]; do | |
| if git clone ${EGIT_LOCAL_OPTIONS} "${repo_uri}" "${EGIT_DIR}"; then | |
| # global variable containing the repo_name we will be using | |
| debug-print "${FUNCNAME}: EGIT_REPO_URI_SELECTED=\"${repo_uri}\"" | |
| EGIT_REPO_URI_SELECTED="${repo_uri}" | |
| break | |
| fi | |
| retry=$(($retry-1)) | |
| done | |
| [[ -n ${EGIT_REPO_URI_SELECTED} ]] && break | |
| done | |
| [[ ${EGIT_REPO_URI_SELECTED} ]] \ | |
| || die "${FUNCNAME}: can't fetch from ${EGIT_REPO_URI}" | |
| } | |
| # @FUNCTION: git-2_update_repo | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function running update command on specified repo_uri. | |
| git-2_update_repo() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local repo_uri | |
| if [[ ${EGIT_LOCAL_NONBARE} ]]; then | |
| # checkout master branch and drop all other local branches | |
| git checkout ${EGIT_MASTER} || die "${FUNCNAME}: can't checkout master branch ${EGIT_MASTER}" | |
| for x in $(git branch | grep -v "* ${EGIT_MASTER}" | tr '\n' ' '); do | |
| debug-print "${FUNCNAME}: git branch -D ${x}" | |
| git branch -D ${x} > /dev/null | |
| done | |
| fi | |
| EGIT_REPO_URI_SELECTED="" | |
| for repo_uri in ${EGIT_REPO_URI}; do | |
| # git urls might change, so reset it | |
| git config remote.origin.url "${repo_uri}" | |
| debug-print "${EGIT_UPDATE_CMD}" | |
| if ${EGIT_UPDATE_CMD} > /dev/null; then | |
| # global variable containing the repo_name we will be using | |
| debug-print "${FUNCNAME}: EGIT_REPO_URI_SELECTED=\"${repo_uri}\"" | |
| EGIT_REPO_URI_SELECTED="${repo_uri}" | |
| break | |
| fi | |
| done | |
| [[ ${EGIT_REPO_URI_SELECTED} ]] \ | |
| || die "${FUNCNAME}: can't update from ${EGIT_REPO_URI}" | |
| } | |
| # @FUNCTION: git-2_fetch | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function fetching repository from EGIT_REPO_URI and storing it in | |
| # specified EGIT_STORE_DIR. | |
| git-2_fetch() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local oldsha cursha repo_type | |
| [[ ${EGIT_LOCAL_NONBARE} ]] && repo_type="non-bare repository" || repo_type="bare repository" | |
| # Acquire a file lock on EGIT_DIR so that concurrent emerge jobs don't hit | |
| # errors due to git contention. | |
| [[ -z "${EGIT_DIR}" ]] && die "EGIT_DIR is unset!" | |
| mkdir -p "$(dirname "${EGIT_DIR}")" | |
| # Strip all trailing slashes from EGIT_DIR and add suffix to generate a | |
| # canonical lockfile location for a given git repository. | |
| # This lockfile can't be in EGIT_DIR itself because that directory must be | |
| # empty for an initial clone to succeed. | |
| local lockfile="$(realpath -m "${EGIT_DIR}")-EMERGE_LOCKFILE" | |
| exec 200>"${lockfile}" || \ | |
| die "Unable to access file lock in EGIT_DIR: ${EGIT_DIR}" | |
| flock -x 200 | |
| # If the repo directory is corrupt, delete EGIT_DIR to force a fresh clone. | |
| if [[ -d "${EGIT_DIR}" ]]; then | |
| git -C "${EGIT_DIR}" rev-parse HEAD &>/dev/null | |
| if [[ $? -ne 0 ]]; then | |
| ewarn "Existing git repo corrupt, removing and initialing clean checkout in ${EGIT_DIR}" | |
| rm -rf "${EGIT_DIR}" | |
| fi | |
| fi | |
| if [[ ! -d "${EGIT_DIR}" ]]; then | |
| git-2_initial_clone | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| cursha=$(git rev-parse ${UPSTREAM_BRANCH}) | |
| echo "GIT NEW clone -->" | |
| echo " repository: ${EGIT_REPO_URI_SELECTED}" | |
| echo " at the commit: ${cursha}" | |
| popd > /dev/null || die | |
| elif [[ ${EVCS_OFFLINE} ]]; then | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| cursha=$(git rev-parse ${UPSTREAM_BRANCH}) | |
| echo "GIT offline update -->" | |
| echo " repository: $(git config remote.origin.url)" | |
| echo " at the commit: ${cursha}" | |
| popd > /dev/null || die | |
| else | |
| pushd "${EGIT_DIR}" > /dev/null || die | |
| oldsha=$(git rev-parse ${UPSTREAM_BRANCH}) | |
| git-2_update_repo | |
| cursha=$(git rev-parse ${UPSTREAM_BRANCH}) | |
| # fetch updates | |
| echo "GIT update -->" | |
| echo " repository: ${EGIT_REPO_URI_SELECTED}" | |
| # write out message based on the revisions | |
| if [[ "${oldsha}" != "${cursha}" ]]; then | |
| echo " updating from commit: ${oldsha}" | |
| echo " to commit: ${cursha}" | |
| else | |
| echo " at the commit: ${cursha}" | |
| fi | |
| # print nice statistic of what was changed | |
| git --no-pager diff --stat ${oldsha}..${UPSTREAM_BRANCH} | |
| popd > /dev/null || die | |
| fi | |
| # Be sure to drop our file lock and close the file descriptor. | |
| flock -u 200 | |
| exec 200>&- | |
| # export the version the repository is at | |
| export EGIT_VERSION="${cursha}" | |
| # log the repo state | |
| [[ ${EGIT_COMMIT} != ${EGIT_BRANCH} ]] \ | |
| && echo " commit: ${EGIT_COMMIT}" | |
| echo " branch: ${EGIT_BRANCH}" | |
| echo " storage directory: \"${EGIT_DIR}\"" | |
| echo " checkout type: ${repo_type}" | |
| # Cleanup after git.eclass | |
| if [[ ${EGIT_OLD_CLONE} ]]; then | |
| einfo "${FUNCNAME}: removing old clone in ${EGIT_OLD_CLONE}." | |
| rm -rf "${EGIT_OLD_CLONE}" | |
| fi | |
| } | |
| # @FUNCTION: git_bootstrap | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function that runs bootstrap command on unpacked source. | |
| git-2_bootstrap() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| # @ECLASS-VARIABLE: EGIT_BOOTSTRAP | |
| # @DESCRIPTION: | |
| # Command to be executed after checkout and clone of the specified | |
| # repository. | |
| # enviroment the package will fail if there is no update, thus in | |
| # combination with --keep-going it would lead in not-updating | |
| # pakcages that are up-to-date. | |
| if [[ ${EGIT_BOOTSTRAP} ]]; then | |
| pushd "${EGIT_SOURCEDIR}" > /dev/null || die | |
| einfo "Starting bootstrap" | |
| if [[ -f ${EGIT_BOOTSTRAP} ]]; then | |
| # we have file in the repo which we should execute | |
| debug-print "${FUNCNAME}: bootstraping with file \"${EGIT_BOOTSTRAP}\"" | |
| if [[ -x ${EGIT_BOOTSTRAP} ]]; then | |
| eval "./${EGIT_BOOTSTRAP}" \ | |
| || die "${FUNCNAME}: bootstrap script failed" | |
| else | |
| eerror "\"${EGIT_BOOTSTRAP}\" is not executable." | |
| eerror "Report upstream, or bug ebuild maintainer to remove bootstrap command." | |
| die "\"${EGIT_BOOTSTRAP}\" is not executable" | |
| fi | |
| else | |
| # we execute some system command | |
| debug-print "${FUNCNAME}: bootstraping with commands \"${EGIT_BOOTSTRAP}\"" | |
| eval "${EGIT_BOOTSTRAP}" \ | |
| || die "${FUNCNAME}: bootstrap commands failed" | |
| fi | |
| einfo "Bootstrap finished" | |
| popd > /dev/null || die | |
| fi | |
| } | |
| # @FUNCTION: git-2_migrate_repository | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function migrating between bare and normal checkout repository. | |
| # This is based on usage of EGIT_SUBMODULES, at least until they | |
| # start to work with bare checkouts sanely. | |
| # This function also set some global variables that differ between | |
| # bare and non-bare checkout. | |
| git-2_migrate_repository() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| local bare returnstate | |
| # first find out if we have submodules | |
| # or user explicitly wants us to use non-bare clones | |
| if ! [[ ${EGIT_HAS_SUBMODULES} || ${EGIT_NONBARE} ]]; then | |
| bare=1 | |
| fi | |
| # test if we already have some repo and if so find out if we have | |
| # to migrate the data | |
| if [[ -d ${EGIT_DIR} ]]; then | |
| if [[ ${bare} && -d ${EGIT_DIR}/.git ]]; then | |
| debug-print "${FUNCNAME}: converting \"${EGIT_DIR}\" to bare copy" | |
| ebegin "Converting \"${EGIT_DIR}\" from non-bare to bare copy" | |
| mv "${EGIT_DIR}/.git" "${EGIT_DIR}.bare" | |
| export GIT_DIR="${EGIT_DIR}.bare" | |
| git config core.bare true > /dev/null | |
| returnstate=$? | |
| unset GIT_DIR | |
| rm -rf "${EGIT_DIR}" | |
| mv "${EGIT_DIR}.bare" "${EGIT_DIR}" | |
| eend ${returnstate} | |
| elif [[ ! ${bare} && ! -d ${EGIT_DIR}/.git ]]; then | |
| debug-print "${FUNCNAME}: converting \"${EGIT_DIR}\" to non-bare copy" | |
| ebegin "Converting \"${EGIT_DIR}\" from bare to non-bare copy" | |
| git clone -l "${EGIT_DIR}" "${EGIT_DIR}.nonbare" > /dev/null | |
| returnstate=$? | |
| rm -rf "${EGIT_DIR}" | |
| mv "${EGIT_DIR}.nonbare" "${EGIT_DIR}" | |
| eend ${returnstate} | |
| fi | |
| fi | |
| if [[ ${returnstate} -ne 0 ]]; then | |
| debug-print "${FUNCNAME}: converting \"${EGIT_DIR}\" failed, removing to start from scratch" | |
| # migration failed, remove the EGIT_DIR to play it safe | |
| einfo "Migration failed, removing \"${EGIT_DIR}\" to start from scratch." | |
| rm -rf "${EGIT_DIR}" | |
| fi | |
| # set various options to work with both targets | |
| if [[ ${bare} ]]; then | |
| debug-print "${FUNCNAME}: working in bare repository for \"${EGIT_DIR}\"" | |
| EGIT_LOCAL_OPTIONS+="${EGIT_OPTIONS} --bare" | |
| MOVE_COMMAND="git clone -l -s -n ${EGIT_DIR// /\\ }" | |
| EGIT_UPDATE_CMD="git fetch -t -f -u origin ${EGIT_BRANCH}:${EGIT_BRANCH}" | |
| UPSTREAM_BRANCH="${EGIT_BRANCH}" | |
| EGIT_LOCAL_NONBARE= | |
| else | |
| debug-print "${FUNCNAME}: working in bare repository for non-bare \"${EGIT_DIR}\"" | |
| MOVE_COMMAND="cp -pPR ." | |
| EGIT_LOCAL_OPTIONS="${EGIT_OPTIONS}" | |
| EGIT_UPDATE_CMD="git pull -f -u ${EGIT_OPTIONS}" | |
| UPSTREAM_BRANCH="origin/${EGIT_BRANCH}" | |
| EGIT_LOCAL_NONBARE="true" | |
| fi | |
| } | |
| # @FUNCTION: git-2_cleanup | |
| # @INTERNAL | |
| # @DESCRIPTION: | |
| # Internal function cleaning up all the global variables | |
| # that are not required after the unpack has been done. | |
| git-2_cleanup() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| # Here we can unset only variables that are GLOBAL | |
| # defined by the eclass, BUT NOT subject to change | |
| # by user (like EGIT_PROJECT). | |
| # If ebuild writer polutes his environment it is | |
| # his problem only. | |
| unset EGIT_DIR | |
| unset MOVE_COMMAND | |
| unset EGIT_LOCAL_OPTIONS | |
| unset EGIT_UPDATE_CMD | |
| unset UPSTREAM_BRANCH | |
| unset EGIT_LOCAL_NONBARE | |
| } | |
| # @FUNCTION: git-2_src_unpack | |
| # @DESCRIPTION: | |
| # Default git src_unpack function. | |
| git-2_src_unpack() { | |
| debug-print-function ${FUNCNAME} "$@" | |
| git-2_init_variables | |
| git-2_prepare_storedir | |
| git-2_migrate_repository | |
| git-2_fetch "$@" | |
| git-2_gc | |
| git-2_submodules | |
| git-2_move_source | |
| git-2_branch | |
| git-2_bootstrap | |
| git-2_cleanup | |
| echo ">>> Unpacked to ${EGIT_SOURCEDIR}" | |
| # Users can specify some SRC_URI and we should | |
| # unpack the files too. | |
| if [[ ! ${EGIT_NOUNPACK} ]]; then | |
| if has ${EAPI:-0} 0 1; then | |
| [[ ${A} ]] && unpack ${A} | |
| else | |
| default_src_unpack | |
| fi | |
| fi | |
| } |