eclass/git-r3.eclass

   1 # Copyright 1999-2019 Gentoo Authors
   2 # Distributed under the terms of the GNU General Public License v2
   3
   4 # @ECLASS: git-r3.eclass
   5 # @MAINTAINER:
   6 # Michał Górny <mgorny@gentoo.org>
   7 # @SUPPORTED_EAPIS: 4 5 6 7
   8 # @BLURB: Eclass for fetching and unpacking git repositories.
   9 # @DESCRIPTION:
  10 # Third generation eclass for easing maintenance of live ebuilds using
  11 # git as remote repository.
  12
  13 case "${EAPI:-0}" in
  14         0|1|2|3)
  15                 die "Unsupported EAPI=${EAPI} (obsolete) for ${ECLASS}"
  16                 ;;
  17         4|5|6|7)
  18                 ;;
  19         *)
  20                 die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
  21                 ;;
  22 esac
  23
  24 EXPORT_FUNCTIONS src_unpack
  25
  26 if [[ ! ${_GIT_R3} ]]; then
  27
  28 PROPERTIES+=" live"
  29
  30 if [[ ! ${_INHERITED_BY_GIT_2} ]]; then
  31         if [[ ${EAPI:-0} != [0123456] ]]; then
  32                 BDEPEND=">=dev-vcs/git-1.8.2.1[curl]"
  33         else
  34                 DEPEND=">=dev-vcs/git-1.8.2.1[curl]"
  35         fi
  36 fi
  37
  38 # @ECLASS-VARIABLE: EGIT_CLONE_TYPE
  39 # @DESCRIPTION:
  40 # Type of clone that should be used against the remote repository.
  41 # This can be either of: 'mirror', 'single', 'shallow'.
  42 #
  43 # This is intended to be set by user in make.conf. Ebuilds are supposed
  44 # to set EGIT_MIN_CLONE_TYPE if necessary instead.
  45 #
  46 # The 'mirror' type clones all remote branches and tags with complete
  47 # history and all notes. EGIT_COMMIT can specify any commit hash.
  48 # Upstream-removed branches and tags are purged from the local clone
  49 # while fetching. This mode is suitable for cloning the local copy
  50 # for development or hosting a local git mirror. However, clones
  51 # of repositories with large diverged branches may quickly grow large.
  52 #
  53 # The 'single+tags' type clones the requested branch and all tags
  54 # in the repository. All notes are fetched as well. EGIT_COMMIT
  55 # can safely specify hashes throughout the current branch and all tags.
  56 # No purging of old references is done (if you often switch branches,
  57 # you may need to remove stale branches yourself). This mode is intended
  58 # mostly for use with broken git servers such as Google Code that fail
  59 # to fetch tags along with the branch in 'single' mode.
  60 #
  61 # The 'single' type clones only the requested branch or tag. Tags
  62 # referencing commits throughout the branch history are fetched as well,
  63 # and all notes. EGIT_COMMIT can safely specify only hashes
  64 # in the current branch. No purging of old references is done (if you
  65 # often switch branches, you may need to remove stale branches
  66 # yourself). This mode is suitable for general use.
  67 #
  68 # The 'shallow' type clones only the newest commit on requested branch
  69 # or tag. EGIT_COMMIT can only specify tags, and since the history is
  70 # unavailable calls like 'git describe' will not reference prior tags.
  71 # No purging of old references is done. This mode is intended mostly for
  72 # embedded systems with limited disk space.
  73 : ${EGIT_CLONE_TYPE:=single}
  74
  75 # @ECLASS-VARIABLE: EGIT_MIN_CLONE_TYPE
  76 # @DESCRIPTION:
  77 # 'Minimum' clone type supported by the ebuild. Takes same values
  78 # as EGIT_CLONE_TYPE. When user sets a type that's 'lower' (that is,
  79 # later on the list) than EGIT_MIN_CLONE_TYPE, the eclass uses
  80 # EGIT_MIN_CLONE_TYPE instead.
  81 #
  82 # This variable is intended to be used by ebuilds only. Users are
  83 # supposed to set EGIT_CLONE_TYPE instead.
  84 #
  85 # A common case is to use 'single' whenever the build system requires
  86 # access to full branch history, or 'single+tags' when Google Code
  87 # or a similar remote is used that does not support shallow clones
  88 # and fetching tags along with commits. Please use sparingly, and to fix
  89 # fatal errors rather than 'non-pretty versions'.
  90 : ${EGIT_MIN_CLONE_TYPE:=shallow}
  91
  92 # @ECLASS-VARIABLE: EGIT3_STORE_DIR
  93 # @DESCRIPTION:
  94 # Storage directory for git sources.
  95 #
  96 # This is intended to be set by user in make.conf. Ebuilds must not set
  97 # it.
  98 #
  99 # EGIT3_STORE_DIR=${DISTDIR}/git3-src
 100
 101 # @ECLASS-VARIABLE: EGIT_MIRROR_URI
 102 # @DEFAULT_UNSET
 103 # @DESCRIPTION:
 104 # 'Top' URI to a local git mirror. If specified, the eclass will try
 105 # to fetch from the local mirror instead of using the remote repository.
 106 #
 107 # The mirror needs to follow EGIT3_STORE_DIR structure. The directory
 108 # created by eclass can be used for that purpose.
 109 #
 110 # Example:
 111 # @CODE
 112 # EGIT_MIRROR_URI="git://mirror.lan/"
 113 # @CODE
 114
 115 # @ECLASS-VARIABLE: EGIT_REPO_URI
 116 # @REQUIRED
 117 # @DESCRIPTION:
 118 # URIs to the repository, e.g. https://foo. If multiple URIs are
 119 # provided, the eclass will consider the remaining URIs as fallbacks
 120 # to try if the first URI does not work. For supported URI syntaxes,
 121 # read the manpage for git-clone(1).
 122 #
 123 # URIs should be using https:// whenever possible. http:// and git://
 124 # URIs are completely unsecured and their use (even if only as
 125 # a fallback) renders the ebuild completely vulnerable to MITM attacks.
 126 #
 127 # Can be a whitespace-separated list or an array.
 128 #
 129 # Example:
 130 # @CODE
 131 # EGIT_REPO_URI="https://a/b.git https://c/d.git"
 132 # @CODE
 133
 134 # @ECLASS-VARIABLE: EVCS_OFFLINE
 135 # @DEFAULT_UNSET
 136 # @DESCRIPTION:
 137 # If non-empty, this variable prevents any online operations.
 138
 139 # @ECLASS-VARIABLE: EVCS_UMASK
 140 # @DEFAULT_UNSET
 141 # @DESCRIPTION:
 142 # Set this variable to a custom umask. This is intended to be set by
 143 # users. By setting this to something like 002, it can make life easier
 144 # for people who do development as non-root (but are in the portage
 145 # group), and then switch over to building with FEATURES=userpriv.
 146 # Or vice-versa. Shouldn't be a security issue here as anyone who has
 147 # portage group write access already can screw the system over in more
 148 # creative ways.
 149
 150 # @ECLASS-VARIABLE: EGIT_BRANCH
 151 # @DEFAULT_UNSET
 152 # @DESCRIPTION:
 153 # The branch name to check out. If unset, the upstream default (HEAD)
 154 # will be used.
 155
 156 # @ECLASS-VARIABLE: EGIT_COMMIT
 157 # @DEFAULT_UNSET
 158 # @DESCRIPTION:
 159 # The tag name or commit identifier to check out. If unset, newest
 160 # commit from the branch will be used. Note that if set to a commit
 161 # not on HEAD branch, EGIT_BRANCH needs to be set to a branch on which
 162 # the commit is available.
 163
 164 # @ECLASS-VARIABLE: EGIT_COMMIT_DATE
 165 # @DEFAULT_UNSET
 166 # @DESCRIPTION:
 167 # Attempt to check out the repository state for the specified timestamp.
 168 # The date should be in format understood by 'git rev-list'. The commits
 169 # on EGIT_BRANCH will be considered.
 170 #
 171 # The eclass will select the last commit with commit date preceding
 172 # the specified date. When merge commits are found, only first parents
 173 # will be considered in order to avoid switching into external branches
 174 # (assuming that merges are done correctly). In other words, each merge
 175 # will be considered alike a single commit with date corresponding
 176 # to the merge commit date.
 177
 178 # @ECLASS-VARIABLE: EGIT_CHECKOUT_DIR
 179 # @DESCRIPTION:
 180 # The directory to check the git sources out to.
 181 #
 182 # EGIT_CHECKOUT_DIR=${WORKDIR}/${P}
 183
 184 # @ECLASS-VARIABLE: EGIT_SUBMODULES
 185 # @DEFAULT_UNSET
 186 # @DESCRIPTION:
 187 # An array of inclusive and exclusive wildcards on submodule names,
 188 # stating which submodules are fetched and checked out. Exclusions
 189 # start with '-', and exclude previously matched submodules.
 190 #
 191 # If unset, all submodules are enabled. Empty list disables all
 192 # submodules. In order to use an exclude-only list, start the array
 193 # with '*'.
 194 #
 195 # Remember that wildcards need to be quoted in order to prevent filename
 196 # expansion.
 197 #
 198 # Examples:
 199 # @CODE
 200 # # Disable all submodules
 201 # EGIT_SUBMODULES=()
 202 #
 203 # # Include only foo and bar
 204 # EGIT_SUBMODULES=( foo bar )
 205 #
 206 # # Use all submodules except for test-* but include test-lib
 207 # EGIT_SUBMODULES=( '*' '-test-*' test-lib )
 208 # @CODE
 209
 210 # @FUNCTION: _git-r3_env_setup
 211 # @INTERNAL
 212 # @DESCRIPTION:
 213 # Set the eclass variables as necessary for operation. This can involve
 214 # setting EGIT_* to defaults or ${PN}_LIVE_* variables.
 215 _git-r3_env_setup() {
 216         debug-print-function ${FUNCNAME} "$@"
 217
 218         # check the clone type
 219         case "${EGIT_CLONE_TYPE}" in
 220                 mirror|single+tags|single|shallow)
 221                         ;;
 222                 *)
 223                         die "Invalid EGIT_CLONE_TYPE=${EGIT_CLONE_TYPE}"
 224         esac
 225         case "${EGIT_MIN_CLONE_TYPE}" in
 226                 shallow)
 227                         ;;
 228                 single)
 229                         if [[ ${EGIT_CLONE_TYPE} == shallow ]]; then
 230                                 einfo "git-r3: ebuild needs to be cloned in '\e[1msingle\e[22m' mode, adjusting"
 231                                 EGIT_CLONE_TYPE=single
 232                         fi
 233                         ;;
 234                 single+tags)
 235                         if [[ ${EGIT_CLONE_TYPE} == shallow || ${EGIT_CLONE_TYPE} == single ]]; then
 236                                 einfo "git-r3: ebuild needs to be cloned in '\e[1msingle+tags\e[22m' mode, adjusting"
 237                                 EGIT_CLONE_TYPE=single+tags
 238                         fi
 239                         ;;
 240                 mirror)
 241                         if [[ ${EGIT_CLONE_TYPE} != mirror ]]; then
 242                                 einfo "git-r3: ebuild needs to be cloned in '\e[1mmirror\e[22m' mode, adjusting"
 243                                 EGIT_CLONE_TYPE=mirror
 244                         fi
 245                         ;;
 246                 *)
 247                         die "Invalid EGIT_MIN_CLONE_TYPE=${EGIT_MIN_CLONE_TYPE}"
 248         esac
 249
 250         if [[ ${EGIT_SUBMODULES[@]+1} && $(declare -p EGIT_SUBMODULES) != "declare -a"* ]]
 251         then
 252                 die 'EGIT_SUBMODULES must be an array.'
 253         fi
 254
 255         local esc_pn livevar
 256         esc_pn=${PN//[-+]/_}
 257         [[ ${esc_pn} == [0-9]* ]] && esc_pn=_${esc_pn}
 258
 259         # note: deprecated, use EGIT_OVERRIDE_* instead
 260         livevar=${esc_pn}_LIVE_REPO
 261         EGIT_REPO_URI=${!livevar-${EGIT_REPO_URI}}
 262         [[ ${!livevar} ]] \
 263                 && ewarn "Using ${livevar}, no support will be provided"
 264
 265         livevar=${esc_pn}_LIVE_BRANCH
 266         EGIT_BRANCH=${!livevar-${EGIT_BRANCH}}
 267         [[ ${!livevar} ]] \
 268                 && ewarn "Using ${livevar}, no support will be provided"
 269
 270         livevar=${esc_pn}_LIVE_COMMIT
 271         EGIT_COMMIT=${!livevar-${EGIT_COMMIT}}
 272         [[ ${!livevar} ]] \
 273                 && ewarn "Using ${livevar}, no support will be provided"
 274
 275         livevar=${esc_pn}_LIVE_COMMIT_DATE
 276         EGIT_COMMIT_DATE=${!livevar-${EGIT_COMMIT_DATE}}
 277         [[ ${!livevar} ]] \
 278                 && ewarn "Using ${livevar}, no support will be provided"
 279
 280         if [[ ${EGIT_COMMIT} && ${EGIT_COMMIT_DATE} ]]; then
 281                 die "EGIT_COMMIT and EGIT_COMMIT_DATE can not be specified simultaneously"
 282         fi
 283
 284         # Migration helpers. Remove them when git-2 is removed.
 285
 286         if [[ ${EGIT_SOURCEDIR} ]]; then
 287                 eerror "EGIT_SOURCEDIR has been replaced by EGIT_CHECKOUT_DIR. While updating"
 288                 eerror "your ebuild, please check whether the variable is necessary at all"
 289                 eerror "since the default has been changed from \${S} to \${WORKDIR}/\${P}."
 290                 eerror "Therefore, proper setting of S may be sufficient."
 291                 die "EGIT_SOURCEDIR has been replaced by EGIT_CHECKOUT_DIR."
 292         fi
 293
 294         if [[ ${EGIT_MASTER} ]]; then
 295                 eerror "EGIT_MASTER has been removed. Instead, the upstream default (HEAD)"
 296                 eerror "is used by the eclass. Please remove the assignment or use EGIT_BRANCH"
 297                 eerror "as necessary."
 298                 die "EGIT_MASTER has been removed."
 299         fi
 300
 301         if [[ ${EGIT_HAS_SUBMODULES} ]]; then
 302                 eerror "EGIT_HAS_SUBMODULES has been removed. The eclass no longer needs"
 303                 eerror "to switch the clone type in order to support submodules and therefore"
 304                 eerror "submodules are detected and fetched automatically. If you need to"
 305                 eerror "disable or filter submodules, see EGIT_SUBMODULES."
 306                 die "EGIT_HAS_SUBMODULES is no longer necessary."
 307         fi
 308
 309         if [[ ${EGIT_PROJECT} ]]; then
 310                 eerror "EGIT_PROJECT has been removed. Instead, the eclass determines"
 311                 eerror "the local clone path using path in canonical EGIT_REPO_URI."
 312                 eerror "If the current algorithm causes issues for you, please report a bug."
 313                 die "EGIT_PROJECT is no longer necessary."
 314         fi
 315
 316         if [[ ${EGIT_BOOTSTRAP} ]]; then
 317                 eerror "EGIT_BOOTSTRAP has been removed. Please create proper src_prepare()"
 318                 eerror "instead."
 319                 die "EGIT_BOOTSTRAP has been removed."
 320         fi
 321
 322         if [[ ${EGIT_NOUNPACK} ]]; then
 323                 eerror "EGIT_NOUNPACK has been removed. The eclass no longer calls default"
 324                 eerror "unpack function. If necessary, please declare proper src_unpack()."
 325                 die "EGIT_NOUNPACK has been removed."
 326         fi
 327 }
 328
 329 # @FUNCTION: _git-r3_set_gitdir
 330 # @USAGE: <repo-uri>
 331 # @INTERNAL
 332 # @DESCRIPTION:
 333 # Obtain the local repository path and set it as GIT_DIR. Creates
 334 # a new repository if necessary.
 335 #
 336 # <repo-uri> may be used to compose the path. It should therefore be
 337 # a canonical URI to the repository.
 338 _git-r3_set_gitdir() {
 339         debug-print-function ${FUNCNAME} "$@"
 340
 341         local repo_name=${1#*://*/}
 342
 343         # strip the trailing slash
 344         repo_name=${repo_name%/}
 345
 346         # strip common prefixes to make paths more likely to match
 347         # e.g. git://X/Y.git vs https://X/git/Y.git
 348         # (but just one of the prefixes)
 349         case "${repo_name}" in
 350                 # gnome.org... who else?
 351                 browse/*) repo_name=${repo_name#browse/};;
 352                 # cgit can proxy requests to git
 353                 cgit/*) repo_name=${repo_name#cgit/};;
 354                 # pretty common
 355                 git/*) repo_name=${repo_name#git/};;
 356                 # gentoo.org
 357                 gitroot/*) repo_name=${repo_name#gitroot/};;
 358                 # sourceforge
 359                 p/*) repo_name=${repo_name#p/};;
 360                 # kernel.org
 361                 pub/scm/*) repo_name=${repo_name#pub/scm/};;
 362         esac
 363         # ensure a .git suffix, same reason
 364         repo_name=${repo_name%.git}.git
 365         # now replace all the slashes
 366         repo_name=${repo_name//\//_}
 367
 368         local distdir=${PORTAGE_ACTUAL_DISTDIR:-${DISTDIR}}
 369         : ${EGIT3_STORE_DIR:=${distdir}/git3-src}
 370
 371         GIT_DIR=${EGIT3_STORE_DIR}/${repo_name}
 372
 373         if [[ ! -d ${EGIT3_STORE_DIR} && ! ${EVCS_OFFLINE} ]]; then
 374                 (
 375                         addwrite /
 376                         mkdir -p "${EGIT3_STORE_DIR}"
 377                 ) || die "Unable to create ${EGIT3_STORE_DIR}"
 378         fi
 379
 380         addwrite "${EGIT3_STORE_DIR}"
 381         if [[ ! -d ${GIT_DIR} ]]; then
 382                 if [[ ${EVCS_OFFLINE} ]]; then
 383                         eerror "A clone of the following repository is required to proceed:"
 384                         eerror "  ${1}"
 385                         eerror "However, networking activity has been disabled using EVCS_OFFLINE and there"
 386                         eerror "is no local clone available."
 387                         die "No local clone of ${1}. Unable to proceed with EVCS_OFFLINE."
 388                 fi
 389
 390                 local saved_umask
 391                 if [[ ${EVCS_UMASK} ]]; then
 392                         saved_umask=$(umask)
 393                         umask "${EVCS_UMASK}" || die "Bad options to umask: ${EVCS_UMASK}"
 394                 fi
 395                 mkdir "${GIT_DIR}" || die
 396                 git init --bare || die
 397                 if [[ ${saved_umask} ]]; then
 398                         umask "${saved_umask}" || die
 399                 fi
 400         fi
 401 }
 402
 403 # @FUNCTION: _git-r3_set_submodules
 404 # @USAGE: <file-contents>
 405 # @INTERNAL
 406 # @DESCRIPTION:
 407 # Parse .gitmodules contents passed as <file-contents>
 408 # as in "$(cat .gitmodules)"). Composes a 'submodules' array that
 409 # contains in order (name, URL, path) for each submodule.
 410 _git-r3_set_submodules() {
 411         debug-print-function ${FUNCNAME} "$@"
 412
 413         local data=${1}
 414
 415         # ( name url path ... )
 416         submodules=()
 417
 418         local l
 419         while read l; do
 420                 # submodule.<path>.path=<path>
 421                 # submodule.<path>.url=<url>
 422                 [[ ${l} == submodule.*.url=* ]] || continue
 423
 424                 l=${l#submodule.}
 425                 local subname=${l%%.url=*}
 426
 427                 # filter out on EGIT_SUBMODULES
 428                 if declare -p EGIT_SUBMODULES &>/dev/null; then
 429                         local p l_res res=
 430                         for p in "${EGIT_SUBMODULES[@]}"; do
 431                                 if [[ ${p} == -* ]]; then
 432                                         p=${p#-}
 433                                         l_res=
 434                                 else
 435                                         l_res=1
 436                                 fi
 437
 438                                 [[ ${subname} == ${p} ]] && res=${l_res}
 439                         done
 440
 441                         if [[ ! ${res} ]]; then
 442                                 einfo "Skipping submodule \e[1m${subname}\e[22m"
 443                                 continue
 444                         fi
 445                 fi
 446
 447                 # skip modules that have 'update = none', bug #487262.
 448                 local upd=$(echo "${data}" | git config -f /dev/fd/0 \
 449                         submodule."${subname}".update)
 450                 [[ ${upd} == none ]] && continue
 451
 452                 # https://github.com/git/git/blob/master/refs.c#L31
 453                 # we are more restrictive than git itself but that should not
 454                 # cause any issues, #572312, #606950
 455                 # TODO: check escaped names for collisions
 456                 local enc_subname=${subname//[^a-zA-Z0-9-]/_}
 457
 458                 submodules+=(
 459                         "${enc_subname}"
 460                         "$(echo "${data}" | git config -f /dev/fd/0 \
 461                                 submodule."${subname}".url || die)"
 462                         "$(echo "${data}" | git config -f /dev/fd/0 \
 463                                 submodule."${subname}".path || die)"
 464                 )
 465         done < <(echo "${data}" | git config -f /dev/fd/0 -l || die)
 466 }
 467
 468 # @FUNCTION: _git-r3_set_subrepos
 469 # @USAGE: <submodule-uri> <parent-repo-uri>...
 470 # @INTERNAL
 471 # @DESCRIPTION:
 472 # Create 'subrepos' array containing absolute (canonical) submodule URIs
 473 # for the given <submodule-uri>. If the URI is relative, URIs will be
 474 # constructed using all <parent-repo-uri>s. Otherwise, this single URI
 475 # will be placed in the array.
 476 _git-r3_set_subrepos() {
 477         debug-print-function ${FUNCNAME} "$@"
 478
 479         local suburl=${1}
 480         subrepos=( "${@:2}" )
 481
 482         if [[ ${suburl} == ./* || ${suburl} == ../* ]]; then
 483                 # drop all possible trailing slashes for consistency
 484                 subrepos=( "${subrepos[@]%%/}" )
 485
 486                 while true; do
 487                         if [[ ${suburl} == ./* ]]; then
 488                                 suburl=${suburl:2}
 489                         elif [[ ${suburl} == ../* ]]; then
 490                                 suburl=${suburl:3}
 491
 492                                 # XXX: correctness checking
 493
 494                                 # drop the last path component
 495                                 subrepos=( "${subrepos[@]%/*}" )
 496                                 # and then the trailing slashes, again
 497                                 subrepos=( "${subrepos[@]%%/}" )
 498                         else
 499                                 break
 500                         fi
 501                 done
 502
 503                 # append the preprocessed path to the preprocessed URIs
 504                 subrepos=( "${subrepos[@]/%//${suburl}}")
 505         else
 506                 subrepos=( "${suburl}" )
 507         fi
 508 }
 509
 510
 511 # @FUNCTION: _git-r3_is_local_repo
 512 # @USAGE: <repo-uri>
 513 # @INTERNAL
 514 # @DESCRIPTION:
 515 # Determine whether the given URI specifies a local (on-disk)
 516 # repository.
 517 _git-r3_is_local_repo() {
 518         debug-print-function ${FUNCNAME} "$@"
 519
 520         local uri=${1}
 521
 522         [[ ${uri} == file://* || ${uri} == /* ]]
 523 }
 524
 525 # @FUNCTION: git-r3_fetch
 526 # @USAGE: [<repo-uri> [<remote-ref> [<local-id> [<commit-date>]]]]
 527 # @DESCRIPTION:
 528 # Fetch new commits to the local clone of repository.
 529 #
 530 # <repo-uri> specifies the repository URIs to fetch from, as a space-
 531 # -separated list. The first URI will be used as repository group
 532 # identifier and therefore must be used consistently. When not
 533 # specified, defaults to ${EGIT_REPO_URI}.
 534 #
 535 # <remote-ref> specifies the remote ref or commit id to fetch.
 536 # It is preferred to use 'refs/heads/<branch-name>' for branches
 537 # and 'refs/tags/<tag-name>' for tags. Other options are 'HEAD'
 538 # for upstream default branch and hexadecimal commit SHA1. Defaults
 539 # to the first of EGIT_COMMIT, EGIT_BRANCH or literal 'HEAD' that
 540 # is set to a non-null value.
 541 #
 542 # <local-id> specifies the local branch identifier that will be used to
 543 # locally store the fetch result. It should be unique to multiple
 544 # fetches within the repository that can be performed at the same time
 545 # (including parallel merges). It defaults to ${CATEGORY}/${PN}/${SLOT%/*}.
 546 # This default should be fine unless you are fetching multiple trees
 547 # from the same repository in the same ebuild.
 548 #
 549 # <commit-id> requests attempting to use repository state as of specific
 550 # date. For more details, see EGIT_COMMIT_DATE.
 551 #
 552 # The fetch operation will affect the EGIT_STORE only. It will not touch
 553 # the working copy, nor export any environment variables.
 554 # If the repository contains submodules, they will be fetched
 555 # recursively.
 556 git-r3_fetch() {
 557         debug-print-function ${FUNCNAME} "$@"
 558
 559         # process repos first since we create repo_name from it
 560         local repos
 561         if [[ ${1} ]]; then
 562                 repos=( ${1} )
 563         elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
 564                 repos=( "${EGIT_REPO_URI[@]}" )
 565         else
 566                 repos=( ${EGIT_REPO_URI} )
 567         fi
 568
 569         [[ ${repos[@]} ]] || die "No URI provided and EGIT_REPO_URI unset"
 570
 571         local r
 572         for r in "${repos[@]}"; do
 573                 if [[ ${r} == git:* || ${r} == http:* ]]; then
 574                         ewarn "git-r3: ${r%%:*} protocol is completely unsecure and may render the ebuild"
 575                         ewarn "easily susceptible to MITM attacks (even if used only as fallback). Please"
 576                         ewarn "use https instead."
 577                         ewarn "[URI: ${r}]"
 578                 fi
 579         done
 580
 581         local -x GIT_DIR
 582         _git-r3_set_gitdir "${repos[0]}"
 583
 584         einfo "Repository id: ${GIT_DIR##*/}"
 585
 586         # prepend the local mirror if applicable
 587         if [[ ${EGIT_MIRROR_URI} ]]; then
 588                 repos=(
 589                         "${EGIT_MIRROR_URI%/}/${GIT_DIR##*/}"
 590                         "${repos[@]}"
 591                 )
 592         fi
 593
 594         # get the default values for the common variables and override them
 595         local branch_name=${EGIT_BRANCH}
 596         local commit_id=${2:-${EGIT_COMMIT}}
 597         local commit_date=${4:-${EGIT_COMMIT_DATE}}
 598
 599         # support new override API for EAPI 6+
 600         if ! has "${EAPI:-0}" 0 1 2 3 4 5; then
 601                 # get the name and do some more processing:
 602                 # 1) kill .git suffix,
 603                 # 2) underscore (remaining) non-variable characters,
 604                 # 3) add preceding underscore if it starts with a digit,
 605                 # 4) uppercase.
 606                 local override_name=${GIT_DIR##*/}
 607                 override_name=${override_name%.git}
 608                 override_name=${override_name//[^a-zA-Z0-9_]/_}
 609                 override_name=${override_name^^}
 610
 611                 local varmap=(
 612                         REPO:repos
 613                         BRANCH:branch_name
 614                         COMMIT:commit_id
 615                         COMMIT_DATE:commit_date
 616                 )
 617
 618                 local localvar livevar live_warn= override_vars=()
 619                 for localvar in "${varmap[@]}"; do
 620                         livevar=EGIT_OVERRIDE_${localvar%:*}_${override_name}
 621                         localvar=${localvar#*:}
 622                         override_vars+=( "${livevar}" )
 623
 624                         if [[ -n ${!livevar} ]]; then
 625                                 [[ ${localvar} == repos ]] && repos=()
 626                                 live_warn=1
 627                                 ewarn "Using ${livevar}=${!livevar}"
 628                                 declare "${localvar}=${!livevar}"
 629                         fi
 630                 done
 631
 632                 if [[ ${live_warn} ]]; then
 633                         ewarn "No support will be provided."
 634                 else
 635                         einfo "To override fetched repository properties, use:"
 636                         local x
 637                         for x in "${override_vars[@]}"; do
 638                                 einfo "  ${x}"
 639                         done
 640                         einfo
 641                 fi
 642         fi
 643
 644         # set final variables after applying overrides
 645         local branch=${branch_name:+refs/heads/${branch_name}}
 646         local remote_ref=${commit_id:-${branch:-HEAD}}
 647         local local_id=${3:-${CATEGORY}/${PN}/${SLOT%/*}}
 648         local local_ref=refs/git-r3/${local_id}/__main__
 649
 650         # try to fetch from the remote
 651         local success saved_umask
 652         if [[ ${EVCS_UMASK} ]]; then
 653                 saved_umask=$(umask)
 654                 umask "${EVCS_UMASK}" || die "Bad options to umask: ${EVCS_UMASK}"
 655         fi
 656         for r in "${repos[@]}"; do
 657                 if [[ ! ${EVCS_OFFLINE} ]]; then
 658                         einfo "Fetching \e[1m${r}\e[22m ..."
 659
 660                         local fetch_command=( git fetch "${r}" )
 661                         local clone_type=${EGIT_CLONE_TYPE}
 662
 663                         if [[ ${clone_type} == mirror ]]; then
 664                                 fetch_command+=(
 665                                         --prune
 666                                         # mirror the remote branches as local branches
 667                                         "+refs/heads/*:refs/heads/*"
 668                                         # pull tags explicitly in order to prune them properly
 669                                         "+refs/tags/*:refs/tags/*"
 670                                         # notes in case something needs them
 671                                         "+refs/notes/*:refs/notes/*"
 672                                         # and HEAD in case we need the default branch
 673                                         # (we keep it in refs/git-r3 since otherwise --prune interferes)
 674                                         "+HEAD:refs/git-r3/HEAD"
 675                                 )
 676                         else # single or shallow
 677                                 local fetch_l fetch_r
 678
 679                                 if [[ ${remote_ref} == HEAD ]]; then
 680                                         # HEAD
 681                                         fetch_l=HEAD
 682                                 elif [[ ${remote_ref} == refs/* ]]; then
 683                                         # regular branch, tag or some other explicit ref
 684                                         fetch_l=${remote_ref}
 685                                 else
 686                                         # tag or commit id...
 687                                         # let ls-remote figure it out
 688                                         local tagref=$(git ls-remote "${r}" "refs/tags/${remote_ref}")
 689
 690                                         # if it was a tag, ls-remote obtained a hash
 691                                         if [[ ${tagref} ]]; then
 692                                                 # tag
 693                                                 fetch_l=refs/tags/${remote_ref}
 694                                         else
 695                                                 # commit id
 696                                                 # so we need to fetch the whole branch
 697                                                 if [[ ${branch} ]]; then
 698                                                         fetch_l=${branch}
 699                                                 else
 700                                                         fetch_l=HEAD
 701                                                 fi
 702
 703                                                 # fetching by commit in shallow mode? can't do.
 704                                                 if [[ ${clone_type} == shallow ]]; then
 705                                                         clone_type=single
 706                                                 fi
 707                                         fi
 708                                 fi
 709
 710                                 # checkout by date does not make sense in shallow mode
 711                                 if [[ ${commit_date} && ${clone_type} == shallow ]]; then
 712                                         clone_type=single
 713                                 fi
 714
 715                                 if [[ ${fetch_l} == HEAD ]]; then
 716                                         fetch_r=refs/git-r3/HEAD
 717                                 else
 718                                         fetch_r=${fetch_l}
 719                                 fi
 720
 721                                 fetch_command+=(
 722                                         "+${fetch_l}:${fetch_r}"
 723                                 )
 724
 725                                 if [[ ${clone_type} == single+tags ]]; then
 726                                         fetch_command+=(
 727                                                 # pull tags explicitly as requested
 728                                                 "+refs/tags/*:refs/tags/*"
 729                                         )
 730                                 fi
 731                         fi
 732
 733                         if [[ ${clone_type} == shallow ]]; then
 734                                 if _git-r3_is_local_repo; then
 735                                         # '--depth 1' causes sandbox violations with local repos
 736                                         # bug #491260
 737                                         clone_type=single
 738                                 elif [[ ! $(git rev-parse --quiet --verify "${fetch_r}") ]]
 739                                 then
 740                                         # use '--depth 1' when fetching a new branch
 741                                         fetch_command+=( --depth 1 )
 742                                 fi
 743                         else # non-shallow mode
 744                                 if [[ -f ${GIT_DIR}/shallow ]]; then
 745                                         fetch_command+=( --unshallow )
 746                                 fi
 747                         fi
 748
 749                         set -- "${fetch_command[@]}"
 750                         echo "${@}" >&2
 751                         "${@}" || continue
 752
 753                         if [[ ${clone_type} == mirror || ${fetch_l} == HEAD ]]; then
 754                                 # update our HEAD to match our remote HEAD ref
 755                                 git symbolic-ref HEAD refs/git-r3/HEAD \
 756                                                 || die "Unable to update HEAD"
 757                         fi
 758                 fi
 759
 760                 # now let's see what the user wants from us
 761                 if [[ ${commit_date} ]]; then
 762                         local dated_commit_id=$(
 763                                 git rev-list --first-parent --before="${commit_date}" \
 764                                         -n 1 "${remote_ref}"
 765                         )
 766                         if [[ ${?} -ne 0 ]]; then
 767                                 die "Listing ${remote_ref} failed (wrong ref?)."
 768                         elif [[ ! ${dated_commit_id} ]]; then
 769                                 die "Unable to find commit for date ${commit_date}."
 770                         else
 771                                 set -- git update-ref --no-deref "${local_ref}" "${dated_commit_id}"
 772                         fi
 773                 else
 774                         local full_remote_ref=$(
 775                                 git rev-parse --verify --symbolic-full-name "${remote_ref}"
 776                         )
 777
 778                         if [[ ${full_remote_ref} ]]; then
 779                                 # when we are given a ref, create a symbolic ref
 780                                 # so that we preserve the actual argument
 781                                 set -- git symbolic-ref "${local_ref}" "${full_remote_ref}"
 782                         else
 783                                 # otherwise, we were likely given a commit id
 784                                 set -- git update-ref --no-deref "${local_ref}" "${remote_ref}"
 785                         fi
 786                 fi
 787
 788                 echo "${@}" >&2
 789                 if ! "${@}"; then
 790                         if [[ ${EVCS_OFFLINE} ]]; then
 791                                 eerror "A clone of the following repository is required to proceed:"
 792                                 eerror "  ${r}"
 793                                 eerror "However, networking activity has been disabled using EVCS_OFFLINE and the local"
 794                                 eerror "clone does not have requested ref:"
 795                                 eerror "  ${remote_ref}"
 796                                 die "Local clone of ${r} does not have requested ref: ${remote_ref}. Unable to proceed with EVCS_OFFLINE."
 797                         else
 798                                 die "Referencing ${remote_ref} failed (wrong ref?)."
 799                         fi
 800                 fi
 801
 802                 success=1
 803                 break
 804         done
 805         if [[ ${saved_umask} ]]; then
 806                 umask "${saved_umask}" || die
 807         fi
 808         [[ ${success} ]] || die "Unable to fetch from any of EGIT_REPO_URI"
 809
 810         # submodules can reference commits in any branch
 811         # always use the 'mirror' mode to accomodate that, bug #503332
 812         local EGIT_CLONE_TYPE=mirror
 813
 814         # recursively fetch submodules
 815         if git cat-file -e "${local_ref}":.gitmodules &>/dev/null; then
 816                 local submodules
 817                 _git-r3_set_submodules \
 818                         "$(git cat-file -p "${local_ref}":.gitmodules || die)"
 819
 820                 while [[ ${submodules[@]} ]]; do
 821                         local subname=${submodules[0]}
 822                         local url=${submodules[1]}
 823                         local path=${submodules[2]}
 824
 825                         # use only submodules for which path does exist
 826                         # (this is in par with 'git submodule'), bug #551100
 827                         # note: git cat-file does not work for submodules
 828                         if [[ $(git ls-tree -d "${local_ref}" "${path}") ]]
 829                         then
 830                                 local commit=$(git rev-parse "${local_ref}:${path}" || die)
 831
 832                                 if [[ ! ${commit} ]]; then
 833                                         die "Unable to get commit id for submodule ${subname}"
 834                                 fi
 835
 836                                 local subrepos
 837                                 _git-r3_set_subrepos "${url}" "${repos[@]}"
 838
 839                                 git-r3_fetch "${subrepos[*]}" "${commit}" "${local_id}/${subname}"
 840                         fi
 841
 842                         submodules=( "${submodules[@]:3}" ) # shift
 843                 done
 844         fi
 845 }
 846
 847 # @FUNCTION: git-r3_checkout
 848 # @USAGE: [<repo-uri> [<checkout-path> [<local-id> [<checkout-paths>...]]]]
 849 # @DESCRIPTION:
 850 # Check the previously fetched tree to the working copy.
 851 #
 852 # <repo-uri> specifies the repository URIs, as a space-separated list.
 853 # The first URI will be used as repository group identifier
 854 # and therefore must be used consistently with git-r3_fetch.
 855 # The remaining URIs are not used and therefore may be omitted.
 856 # When not specified, defaults to ${EGIT_REPO_URI}.
 857 #
 858 # <checkout-path> specifies the path to place the checkout. It defaults
 859 # to ${EGIT_CHECKOUT_DIR} if set, otherwise to ${WORKDIR}/${P}.
 860 #
 861 # <local-id> needs to specify the local identifier that was used
 862 # for respective git-r3_fetch.
 863 #
 864 # If <checkout-paths> are specified, then the specified paths are passed
 865 # to 'git checkout' to effect a partial checkout. Please note that such
 866 # checkout will not cause the repository to switch branches,
 867 # and submodules will be skipped at the moment. The submodules matching
 868 # those paths might be checked out in a future version of the eclass.
 869 #
 870 # The checkout operation will write to the working copy, and export
 871 # the repository state into the environment. If the repository contains
 872 # submodules, they will be checked out recursively.
 873 git-r3_checkout() {
 874         debug-print-function ${FUNCNAME} "$@"
 875
 876         local repos
 877         if [[ ${1} ]]; then
 878                 repos=( ${1} )
 879         elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
 880                 repos=( "${EGIT_REPO_URI[@]}" )
 881         else
 882                 repos=( ${EGIT_REPO_URI} )
 883         fi
 884
 885         local out_dir=${2:-${EGIT_CHECKOUT_DIR:-${WORKDIR}/${P}}}
 886         local local_id=${3:-${CATEGORY}/${PN}/${SLOT%/*}}
 887         local checkout_paths=( "${@:4}" )
 888
 889         local -x GIT_DIR
 890         _git-r3_set_gitdir "${repos[0]}"
 891
 892         einfo "Checking out \e[1m${repos[0]}\e[22m to \e[1m${out_dir}\e[22m ..."
 893
 894         if ! git cat-file -e refs/git-r3/"${local_id}"/__main__; then
 895                 die "Logic error: no local clone of ${repos[0]}. git-r3_fetch not used?"
 896         fi
 897         local remote_ref=$(
 898                 git symbolic-ref --quiet refs/git-r3/"${local_id}"/__main__
 899         )
 900         local new_commit_id=$(
 901                 git rev-parse --verify refs/git-r3/"${local_id}"/__main__
 902         )
 903
 904         git-r3_sub_checkout() {
 905                 local orig_repo=${GIT_DIR}
 906                 local -x GIT_DIR=${out_dir}/.git
 907                 local -x GIT_WORK_TREE=${out_dir}
 908
 909                 mkdir -p "${out_dir}" || die
 910
 911                 # use git init+fetch instead of clone since the latter doesn't like
 912                 # non-empty directories.
 913
 914                 git init --quiet || die
 915                 # setup 'alternates' to avoid copying objects
 916                 echo "${orig_repo}/objects" > "${GIT_DIR}"/objects/info/alternates || die
 917                 # now copy the refs
 918                 cp -R "${orig_repo}"/refs/* "${GIT_DIR}"/refs/ || die
 919                 if [[ -f ${orig_repo}/packed-refs ]]; then
 920                         cp "${orig_repo}"/packed-refs "${GIT_DIR}"/packed-refs || die
 921                 fi
 922
 923                 # (no need to copy HEAD, we will set it via checkout)
 924
 925                 if [[ -f ${orig_repo}/shallow ]]; then
 926                         cp "${orig_repo}"/shallow "${GIT_DIR}"/ || die
 927                 fi
 928
 929                 set -- git checkout --quiet
 930                 if [[ ${remote_ref} ]]; then
 931                         set -- "${@}" "${remote_ref#refs/heads/}"
 932                 else
 933                         set -- "${@}" "${new_commit_id}"
 934                 fi
 935                 if [[ ${checkout_paths[@]} ]]; then
 936                         set -- "${@}" -- "${checkout_paths[@]}"
 937                 fi
 938                 echo "${@}" >&2
 939                 "${@}" || die "git checkout ${remote_ref:-${new_commit_id}} failed"
 940         }
 941         git-r3_sub_checkout
 942         unset -f git-r3_sub_checkout
 943
 944         local old_commit_id=$(
 945                 git rev-parse --quiet --verify refs/git-r3/"${local_id}"/__old__
 946         )
 947         if [[ ! ${old_commit_id} ]]; then
 948                 echo "GIT NEW branch -->"
 949                 echo "   repository:               ${repos[0]}"
 950                 echo "   at the commit:            ${new_commit_id}"
 951         else
 952                 # diff against previous revision
 953                 echo "GIT update -->"
 954                 echo "   repository:               ${repos[0]}"
 955                 # write out message based on the revisions
 956                 if [[ "${old_commit_id}" != "${new_commit_id}" ]]; then
 957                         echo "   updating from commit:     ${old_commit_id}"
 958                         echo "   to commit:                ${new_commit_id}"
 959
 960                         set -- git --no-pager diff --stat \
 961                                 ${old_commit_id}..${new_commit_id}
 962                         if [[ ${checkout_paths[@]} ]]; then
 963                                 set -- "${@}" -- "${checkout_paths[@]}"
 964                         fi
 965                         "${@}"
 966                 else
 967                         echo "   at the commit:            ${new_commit_id}"
 968                 fi
 969         fi
 970         git update-ref --no-deref refs/git-r3/"${local_id}"/{__old__,__main__} || die
 971
 972         # recursively checkout submodules
 973         if [[ -f ${out_dir}/.gitmodules && ! ${checkout_paths} ]]; then
 974                 local submodules
 975                 _git-r3_set_submodules \
 976                         "$(<"${out_dir}"/.gitmodules)"
 977
 978                 while [[ ${submodules[@]} ]]; do
 979                         local subname=${submodules[0]}
 980                         local url=${submodules[1]}
 981                         local path=${submodules[2]}
 982
 983                         # use only submodules for which path does exist
 984                         # (this is in par with 'git submodule'), bug #551100
 985                         if [[ -d ${out_dir}/${path} ]]; then
 986                                 local subrepos
 987                                 _git-r3_set_subrepos "${url}" "${repos[@]}"
 988
 989                                 git-r3_checkout "${subrepos[*]}" "${out_dir}/${path}" \
 990                                         "${local_id}/${subname}"
 991                         fi
 992
 993                         submodules=( "${submodules[@]:3}" ) # shift
 994                 done
 995         fi
 996
 997         # keep this *after* submodules
 998         export EGIT_DIR=${GIT_DIR}
 999         export EGIT_VERSION=${new_commit_id}
1000 }
1001
1002 # @FUNCTION: git-r3_peek_remote_ref
1003 # @USAGE: [<repo-uri> [<remote-ref>]]
1004 # @DESCRIPTION:
1005 # Peek the reference in the remote repository and print the matching
1006 # (newest) commit SHA1.
1007 #
1008 # <repo-uri> specifies the repository URIs to fetch from, as a space-
1009 # -separated list. When not specified, defaults to ${EGIT_REPO_URI}.
1010 #
1011 # <remote-ref> specifies the remote ref to peek.  It is preferred to use
1012 # 'refs/heads/<branch-name>' for branches and 'refs/tags/<tag-name>'
1013 # for tags. Alternatively, 'HEAD' may be used for upstream default
1014 # branch. Defaults to the first of EGIT_COMMIT, EGIT_BRANCH or literal
1015 # 'HEAD' that is set to a non-null value.
1016 #
1017 # The operation will be done purely on the remote, without using local
1018 # storage. If commit SHA1 is provided as <remote-ref>, the function will
1019 # fail due to limitations of git protocol.
1020 #
1021 # On success, the function returns 0 and writes hexadecimal commit SHA1
1022 # to stdout. On failure, the function returns 1.
1023 git-r3_peek_remote_ref() {
1024         debug-print-function ${FUNCNAME} "$@"
1025
1026         local repos
1027         if [[ ${1} ]]; then
1028                 repos=( ${1} )
1029         elif [[ $(declare -p EGIT_REPO_URI) == "declare -a"* ]]; then
1030                 repos=( "${EGIT_REPO_URI[@]}" )
1031         else
1032                 repos=( ${EGIT_REPO_URI} )
1033         fi
1034
1035         local branch=${EGIT_BRANCH:+refs/heads/${EGIT_BRANCH}}
1036         local remote_ref=${2:-${EGIT_COMMIT:-${branch:-HEAD}}}
1037
1038         [[ ${repos[@]} ]] || die "No URI provided and EGIT_REPO_URI unset"
1039
1040         local r success
1041         for r in "${repos[@]}"; do
1042                 einfo "Peeking \e[1m${remote_ref}\e[22m on \e[1m${r}\e[22m ..." >&2
1043
1044                 local lookup_ref
1045                 if [[ ${remote_ref} == refs/* || ${remote_ref} == HEAD ]]
1046                 then
1047                         lookup_ref=${remote_ref}
1048                 else
1049                         # ls-remote by commit is going to fail anyway,
1050                         # so we may as well pass refs/tags/ABCDEF...
1051                         lookup_ref=refs/tags/${remote_ref}
1052                 fi
1053
1054                 # split on whitespace
1055                 local ref=(
1056                         $(git ls-remote "${r}" "${lookup_ref}")
1057                 )
1058
1059                 if [[ ${ref[0]} ]]; then
1060                         echo "${ref[0]}"
1061                         return 0
1062                 fi
1063         done
1064
1065         return 1
1066 }
1067
1068 git-r3_src_fetch() {
1069         debug-print-function ${FUNCNAME} "$@"
1070
1071         if [[ ! ${EGIT3_STORE_DIR} && ${EGIT_STORE_DIR} ]]; then
1072                 ewarn "You have set EGIT_STORE_DIR but not EGIT3_STORE_DIR. Please consider"
1073                 ewarn "setting EGIT3_STORE_DIR for git-r3.eclass. It is recommended to use"
1074                 ewarn "a different directory than EGIT_STORE_DIR to ease removing old clones"
1075                 ewarn "when git-2 eclass becomes deprecated."
1076         fi
1077
1078         _git-r3_env_setup
1079         git-r3_fetch
1080 }
1081
1082 git-r3_src_unpack() {
1083         debug-print-function ${FUNCNAME} "$@"
1084
1085         _git-r3_env_setup
1086         git-r3_src_fetch
1087         git-r3_checkout
1088 }
1089
1090 # https://bugs.gentoo.org/show_bug.cgi?id=482666
1091 git-r3_pkg_needrebuild() {
1092         debug-print-function ${FUNCNAME} "$@"
1093
1094         local new_commit_id=$(git-r3_peek_remote_ref)
1095         [[ ${new_commit_id} && ${EGIT_VERSION} ]] || die "Lookup failed"
1096
1097         if [[ ${EGIT_VERSION} != ${new_commit_id} ]]; then
1098                 einfo "Update from \e[1m${EGIT_VERSION}\e[22m to \e[1m${new_commit_id}\e[22m"
1099         else
1100                 einfo "Local and remote at \e[1m${EGIT_VERSION}\e[22m"
1101         fi
1102
1103         [[ ${EGIT_VERSION} != ${new_commit_id} ]]
1104 }
1105
1106 # 'export' locally until this gets into EAPI
1107 pkg_needrebuild() { git-r3_pkg_needrebuild; }
1108
1109 _GIT_R3=1
1110 fi