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