1 | # Copyright 1999-2003 Gentoo Technologies, Inc. |
1 | # Copyright 1999-2003 Gentoo Technologies, Inc. |
2 | # Distributed under the terms of the GNU General Public License v2 |
2 | # Distributed under the terms of the GNU General Public License v2 |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.33 2003/03/19 11:54:21 danarmak Exp $ |
3 | # $Header: /var/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.36 2003/04/19 11:52:50 danarmak Exp $ |
4 | # |
4 | # |
5 | # Author Dan Armak <danarmak@gentoo.org> |
5 | # Author Dan Armak <danarmak@gentoo.org> |
6 | # |
6 | # |
7 | # This eclass provides the generic cvs fetching functions. |
7 | # This eclass provides the generic cvs fetching functions. |
|
|
8 | # to use from an ebuild, set the 'ebuild-configurable settings' below in your ebuild before inheriting. |
|
|
9 | # then either leave the default src_unpack or extend over cvs_src_unpack. |
|
|
10 | # if you find that you need to call the cvs_* functions directly, i'd be interested to hear about it. |
8 | |
11 | |
9 | ECLASS=cvs |
12 | ECLASS=cvs |
10 | INHERITED="$INHERITED $ECLASS" |
13 | INHERITED="$INHERITED $ECLASS" |
11 | |
14 | |
12 | # You shouldn't change these settings yourself! The ebuild/eclass inheriting this eclass |
15 | # You shouldn't change these settings yourself! The ebuild/eclass inheriting this eclass |
… | |
… | |
18 | # cvs command to run. you can set fex. "cvs -t" for extensive debug information |
21 | # cvs command to run. you can set fex. "cvs -t" for extensive debug information |
19 | # on the cvs onnection. the default of "cvs -q -f -z4" means to be quiet, to disregard |
22 | # on the cvs onnection. the default of "cvs -q -f -z4" means to be quiet, to disregard |
20 | # the ~/.cvsrc config file and to use maximum compression. |
23 | # the ~/.cvsrc config file and to use maximum compression. |
21 | [ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4" |
24 | [ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4" |
22 | |
25 | |
23 | # cvs options given after the command (i.e. cvs update foo) |
26 | # cvs options given after the cvs command (update or checkout) |
24 | # don't remove -dP or things won't work |
27 | # don't remove -dP from update or things won't work |
|
|
28 | [ -z "$ECVS_UP_OPTS" ] && ECVS_UP_OPTS="-dP" |
25 | [ -z "$ECVS_CVS_OPTIONS" ] && ECVS_CVS_OPTIONS="-dP" |
29 | [ -z "$ECVS_CO_OPTS" ] && ECVS_CO_OPTS="" |
26 | |
30 | |
27 | # set this for the module/subdir to be fetched non-recursively |
31 | # set this to some value for the module/subdir to be fetched non-recursively: ECVS_LOCAL |
28 | #[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l" |
|
|
29 | |
32 | |
30 | # Where the cvs modules are stored/accessed |
33 | # Where the cvs modules are stored/accessed |
31 | [ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src" |
34 | [ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src" |
32 | |
35 | |
33 | # Name of cvs server, set to "offline" to disable fetching |
36 | # Name of cvs server, set to "offline" to disable fetching |
34 | # (i.e. to assume module is checked out already and don't update it). |
37 | # (i.e. to assume module is checked out already and don't update it). |
35 | # Format is server:/dir e.g. "anoncvs.kde.org:/home/kde". remove the other |
38 | # Format is server:/dir e.g. "anoncvs.kde.org:/home/kde". remove the other |
36 | # parts of the full CVSROOT (which looks like |
39 | # parts of the full CVSROOT (which looks like |
37 | # ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from |
40 | # ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from |
38 | # other settings |
41 | # other settings |
|
|
42 | # the special value 'offline' disables fetching, assumes sources are alread in ECVS_TOP_DIR |
39 | [ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline" |
43 | [ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline" |
40 | |
44 | |
41 | # Anonymous cvs login? |
|
|
42 | # if 'yes' uses :pserver: with empty password, if 'no' uses :ext: with $ECVS_PASS, other values not allowed |
|
|
43 | [ -z "$ECVS_ANON" ] && ECVS_ANON="yes" |
|
|
44 | |
|
|
45 | # Authentication method to use on ECVS_ANON="no" - possible values are "pserver" and "ext" |
45 | # Authentication method to use - possible values are "pserver" and "ext" |
|
|
46 | # WARNING ext is NOT supported! (never was, despite what earlier version of this file said) |
46 | [ -z "$ECVS_AUTH" ] && ECVS_AUTH="ext" |
47 | [ -z "$ECVS_AUTH" ] && ECVS_AUTH="pserver" |
|
|
48 | [ "$ECVS_AUTH" == ext ] && die "ERROR: ext auth not supported. If you want it, please contact danarmak@gentoo.org." |
47 | |
49 | |
48 | # Use su to run cvs as user |
50 | # Use su to run cvs as user |
|
|
51 | # Currently b0rked and wouldn't work with portage userpriv anyway without special magic |
49 | [ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`" |
52 | # [ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`" |
50 | |
53 | |
51 | # Username to use |
54 | # Username to give to the server |
52 | [ -z "$ECVS_USER" ] && ECVS_USER="anonymous" |
55 | [ -z "$ECVS_USER" ] && ECVS_USER="anonymous" |
53 | |
56 | |
54 | # Password to use if anonymous login is off, or if 'anonymous' pserver access |
57 | # Password to use |
55 | # uses a password and ECVS_ANON = yes |
|
|
56 | [ -z "$ECVS_PASS" ] && ECVS_PASS="" |
58 | [ -z "$ECVS_PASS" ] && ECVS_PASS="" |
57 | |
59 | |
58 | # Module to be fetched, must be set explicitly - |
60 | # Module to be fetched, must be set when kde_src_unpack is called |
59 | # I don't like the former ="$PN" default setting |
61 | # can include several directory levels, ie foo/bar/baz |
60 | [ -z "$ECVS_MODULE" ] && debug-print "$ECLASS: error: ECVS_MODULE not set, cannot continue" |
62 | #[ -z "$ECVS_MODULE" ] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue" |
61 | |
63 | |
62 | # Branch/tag to use, default is HEAD |
64 | # Branch/tag to use, default is HEAD |
63 | # uncomment the following line to enable the reset-branch-to-HEAD behaviour |
65 | # the following default _will_ reset your branch checkout to head if used |
64 | [ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD" |
66 | #[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD" |
65 | |
67 | |
66 | # Subdirectory in module to be fetched, default is not defined = whole module |
68 | # deprecated - do not use |
67 | # DO NOT set default to "", if it's defined at all code will break! |
69 | [ -n "$ECVS_SUBDIR" ] && die "ERROR: deprecated ECVS_SUBDIR defined. Please fix this ebuild." |
68 | # don't uncomment following line! |
|
|
69 | #[ -z "$ECVS_SUBDIR" ] && ECVS_SUBDIR="" |
|
|
70 | |
70 | |
71 | # --- end ebuild-configurable settings --- |
71 | # --- end ebuild-configurable settings --- |
72 | |
72 | |
73 | # add cvs to deps |
73 | # add cvs to deps |
74 | DEPEND="$DEPEND dev-util/cvs dev-python/pexpect" |
74 | # ssh is used for ext auth |
|
|
75 | # sudo is used to run as a specified user |
|
|
76 | DEPEND="$DEPEND dev-util/cvs app-admin/sudo" |
|
|
77 | #[ "$ECVS_AUTH" == "ext" ] && DEPEND="$DEPEND net-misc/openssh" |
75 | |
78 | |
76 | # since we now longer have src_fetch as a redefinable ebuild function, |
79 | # calls cvs_contorl, is called from cvs_src_unpack |
77 | # we are forced to call this function from cvs_src_unpack |
|
|
78 | cvs_fetch() { |
80 | cvs_fetch() { |
79 | |
81 | |
80 | debug-print-function $FUNCNAME $* |
82 | debug-print-function $FUNCNAME $* |
81 | |
83 | |
82 | debug-print "$FUNCNAME: init: |
84 | # parameters modifying other parameters that should be effective every time cvs_prep is called, and not |
83 | 9ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND |
85 | # just every time cvs.eclas is inherited |
84 | ECVS_CVS_OPTIONS=$ECVS_CVS_OPTIONS |
86 | # 1. parameter for local (non-recursive) fetching |
85 | ECVS_TOP_DIR=$ECVS_TOP_DIR |
87 | if [ -n "$ECVS_LOCAL" ]; then |
86 | ECVS_SERVER=$ECVS_SERVER |
88 | ECVS_UP_OPTS="$ECVS_UP_OPTS -l" |
87 | ECVS_ANON=$ECVS_ANON |
89 | ECVS_CO_OPTS="$ECVS_CO_OPTS -l" |
88 | ECVS_USER=$ECVS_USER |
90 | fi |
89 | ECVS_PASS=$ECVS_PASS |
91 | # 2. cvs auto-switches branches, we just have to pass the correct -rBRANCH option to it when updating. |
90 | ECS_MODULE=$ECVS_MODULE |
92 | # doing it this way we get multiple -rX options - harmless afaik |
91 | ECVS_SUBDIR=$ECVS_SUBDIR |
93 | if [ -n "$ECVS_BRANCH" ]; then |
92 | ECVS_LOCAL=$ECVS_LOCAL |
94 | ECVS_UP_OPTS="$ECVS_UP_OPTS -r$ECVS_BRANCH" |
93 | DIR=$DIR" |
95 | ECVS_CO_OPTS="$ECVS_CO_OPTS -r$ECVS_BRANCH" |
|
|
96 | fi |
94 | |
97 | |
95 | # a shorthand |
98 | # it's easiest to always be in "run-as mode", logic-wise |
96 | DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}" |
99 | # or would be if sudo didn't ask for a password even when sudo'ing to `whoami` |
97 | debug-print "$FUNCNAME: now DIR=$DIR" |
100 | if [ -z "$ECVS_RUNAS" ]; then |
98 | |
101 | run="" |
99 | if [ "$ECVS_SERVER" == "offline" ]; then |
|
|
100 | # we're not required to fetch anything, the module already exists and shouldn't be updated |
|
|
101 | if [ -d "$DIR" ]; then |
|
|
102 | debug-print "$FUNCNAME: offline mode, exiting" |
|
|
103 | return 0 |
|
|
104 | else |
102 | else |
105 | einfo "ERROR: Offline mode specified, but module/subdir not found. Aborting." |
103 | run="sudo -u $ECVS_RUNAS" |
106 | debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error" |
|
|
107 | return 1 |
|
|
108 | fi |
104 | fi |
109 | fi |
|
|
110 | |
105 | |
111 | # create target directory as needed |
106 | # create the top dir if needed |
112 | if [ ! -d "$DIR" ]; then |
107 | if [ ! -d "$ECVS_TOP_DIR" ]; then |
|
|
108 | # note that the addwrite statements in this block are only there to allow creating ECVS_TOP_DIR; |
|
|
109 | # we've already allowed writing inside it |
|
|
110 | # this is because it's simpler than trying to find out the parent path of the directory, which |
|
|
111 | # would need to be the real path and not a symlink for things to work (so we can't just remove |
|
|
112 | # the last path element in the string) |
113 | debug-print "$FUNCNAME: creating cvs directory $DIR" |
113 | debug-print "$FUNCNAME: checkout mode. creating cvs directory" |
114 | #export SANDBOX_WRITE="$SANDBOX_WRITE:/foobar:/" |
|
|
115 | addwrite /foobar |
114 | addwrite /foobar |
116 | addwrite / |
115 | addwrite / |
117 | mkdir -p "/$DIR" |
116 | $run mkdir -p "/$ECVS_TOP_DIR" |
118 | export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}" |
117 | export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}" |
119 | fi |
118 | fi |
120 | |
119 | |
121 | # in case ECVS_TOP_DIR is a symlink to a dir, get the real dir's path, |
120 | # in case ECVS_TOP_DIR is a symlink to a dir, get the real dir's path, |
122 | # otherwise addwrite() doesn't work. |
121 | # otherwise addwrite() doesn't work. |
123 | cd -P "$ECVS_TOP_DIR" > /dev/null |
122 | cd -P "$ECVS_TOP_DIR" > /dev/null |
124 | ECVS_TOP_DIR="`/bin/pwd`" |
123 | ECVS_TOP_DIR="`/bin/pwd`" |
125 | DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}" |
124 | |
126 | cd "$OLDPWD" |
125 | # determine checkout or update mode |
127 | |
126 | if [ ! -d "$ECVS_TOP_DIR/$ECVS_MODULE/CVS" ]; then |
128 | debug-print "$FUNCNAME: now DIR=$DIR" |
127 | mode=checkout |
129 | |
128 | else |
|
|
129 | mode=update |
|
|
130 | fi |
|
|
131 | |
130 | # disable the sandbox for this dir |
132 | # disable the sandbox for this dir |
131 | # not just $DIR because we want to create moduletopdir/CVS too |
133 | addwrite "$ECVS_TOP_DIR" |
|
|
134 | |
|
|
135 | # chowning the directory and all contents |
|
|
136 | if [ -n "$ECVS_RUNAS" ]; then |
|
|
137 | $run chown -R "$ECVS_RUNAS" "/$ECVS_TOP_DIR" |
|
|
138 | fi |
|
|
139 | |
|
|
140 | # our server string (aka CVSHOST), without the password so it can be put in Root |
|
|
141 | server=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" |
|
|
142 | |
|
|
143 | # switch servers automagically if needed |
|
|
144 | if [ "$mode" == "update" ]; then |
132 | addwrite "$ECVS_TOP_DIR/$ECVS_MODULE" |
145 | cd /$ECVS_TOP_DIR/$ECVS_MODULE |
|
|
146 | oldserver="`$run cat CVS/Root`" |
|
|
147 | if [ "$server" != "$oldserver" ]; then |
133 | |
148 | |
134 | # add option for local (non-recursive) fetching |
149 | einfo "Changing CVS server from $oldserver to $server:" |
135 | [ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l" |
150 | debug-print "$FUNCNAME: Changing CVS server from $oldserver to $server:" |
136 | |
151 | |
|
|
152 | einfo "Searching for CVS dirs..." |
|
|
153 | cvsdirs="`$run find . -iname CVS -print`" |
|
|
154 | debug-print "$FUNCNAME: CVS dirs found:" |
|
|
155 | debug-print "$cvsdirs" |
|
|
156 | |
|
|
157 | einfo "Modifying CVS dirs..." |
|
|
158 | for x in $cvsdirs; do |
|
|
159 | debug-print "In $x" |
|
|
160 | $run echo "$server" > "$x/Root" |
|
|
161 | done |
|
|
162 | |
|
|
163 | fi |
|
|
164 | fi |
|
|
165 | |
|
|
166 | # the server string with the password in it |
|
|
167 | # needed for mode=update too as we may not be inside ECVS_MODULE but only inside ECVS_TOP_DIR |
|
|
168 | # however putting the password in in update mode can break (?) |
|
|
169 | if [ "$mode" == "checkout" ]; then |
|
|
170 | export CVSROOT=":${ECVS_AUTH}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}" |
|
|
171 | else |
|
|
172 | export CVSROOT=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" |
|
|
173 | fi |
|
|
174 | |
137 | # prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass |
175 | # prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass |
138 | touch "${T}/cvspass" |
176 | touch "${T}/cvspass" |
139 | export CVS_PASSFILE="${T}/cvspass" |
177 | export CVS_PASSFILE="${T}/cvspass" |
|
|
178 | if [ -n "$ECVS_RUNAS" ]; then |
140 | chown $ECVS_RUNAS "${T}/cvspass" |
179 | chown "$ECVS_RUNAS" "${T}/cvspass" |
141 | |
|
|
142 | # Note: cvs update and checkout commands are unified. |
|
|
143 | # we make sure a CVS/ dir exists in our module subdir with the right |
|
|
144 | # Root and Repository entries in it and cvs update. |
|
|
145 | |
|
|
146 | [ "${ECVS_ANON}" == "yes" ] && \ |
|
|
147 | newserver=":pserver:${ECVS_USER}@${ECVS_SERVER}" || \ |
|
|
148 | newserver=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" |
|
|
149 | |
|
|
150 | |
|
|
151 | # CVS/Repository files can't (I think) contain two concatenated slashes |
|
|
152 | if [ -n "$ECVS_SUBDIR" ]; then |
|
|
153 | repository="${ECVS_MODULE}/${ECVS_SUBDIR}" |
|
|
154 | else |
|
|
155 | repository="${ECVS_MODULE}" |
|
|
156 | fi |
180 | fi |
157 | |
181 | |
158 | debug-print "$FUNCNAME: Root<-$newserver, Repository<-$repository" |
182 | # commands to run |
159 | debug-print "$FUNCNAME: entering directory $DIR" |
183 | cmdupdate="${run} ${ECVS_CVS_COMMAND} update ${ECVS_UP_OPTS} ${ECVS_MODULE}" |
160 | cd "/$DIR" |
184 | cmdcheckout="${run} ${ECVS_CVS_COMMAND} checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}" |
161 | |
185 | |
162 | if [ ! -d "CVS" ]; then |
186 | cd "${ECVS_TOP_DIR}" |
163 | # create a new CVS/ directory (checkout) |
187 | if [ "${ECVS_AUTH}" == "pserver" ]; then |
164 | debug-print "$FUNCNAME: creating new cvs directory" |
188 | if [ "${mode}" == "update" ]; then |
165 | |
189 | $cmdupdate |
166 | mkdir CVS |
190 | elif [ "${mode}" == "checkout" ]; then |
167 | echo $newserver > CVS/Root |
191 | $cmdcheckout |
168 | echo $repository > CVS/Repository |
|
|
169 | touch CVS/Entries |
|
|
170 | |
|
|
171 | # if we're checking out a subdirectory only, create a CVS/ dir |
|
|
172 | # in the module's top dir so that the user (and we) can cvs update |
|
|
173 | # from there to get the full module. |
|
|
174 | if [ ! -d "$ECVS_TOP_DIR/$ECVS_MODULE/CVS" ]; then |
|
|
175 | debug-print "$FUNCNAME: Copying CVS/ directory to module top-level dir" |
|
|
176 | cp -r CVS "$ECVS_TOP_DIR/$ECVS_MODULE/" |
|
|
177 | echo $ECVS_MODULE > "$ECVS_TOP_DIR/$ECVS_MODULE/CVS/Repository" |
|
|
178 | fi |
192 | fi |
179 | |
193 | # elif [ "${ECVS_AUTH}" == "ext" ]; then |
|
|
194 | # # for ext there's also a possible ssh prompt, code not yet written |
|
|
195 | # echo "${ECVS_DELAY} continue connecting&yes" >> "$instruct" |
|
|
196 | # echo "${ECVS_DELAY} CVS password:&${ECVS_PASS}" >> "$instruct" |
|
|
197 | # if [ "$mode" == "update" ]; then |
|
|
198 | # expect "$cvsout" "$instruct" | $cmdupdate > "$cvsout" |
|
|
199 | # elif [ "$mode" == "checkout" ]; then |
|
|
200 | # expect "$cvsout" "$instruct" | $cmdcheckout > "$cvsout" |
|
|
201 | # fi |
|
|
202 | fi |
|
|
203 | |
|
|
204 | # restore ownership. not sure why this is needed, but someone added it in the orig ECVS_RUNAS stuff. |
|
|
205 | if [ -n "$ECVS_RUNAS" ]; then |
|
|
206 | chown `whoami` "${T}/cvspass" |
|
|
207 | fi |
|
|
208 | |
|
|
209 | } |
|
|
210 | |
|
|
211 | |
|
|
212 | cvs_src_unpack() { |
|
|
213 | |
|
|
214 | debug-print-function $FUNCNAME $* |
|
|
215 | |
|
|
216 | debug-print "$FUNCNAME: init: |
|
|
217 | ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND |
|
|
218 | ECVS_UP_OPTS=$ECVS_UP_OPTS |
|
|
219 | ECVS_CO_OPTS=$ECVS_CO_OPTS |
|
|
220 | ECVS_TOP_DIR=$ECVS_TOP_DIR |
|
|
221 | ECVS_SERVER=$ECVS_SERVER |
|
|
222 | ECVS_USER=$ECVS_USER |
|
|
223 | ECVS_PASS=$ECVS_PASS |
|
|
224 | ECS_MODULE=$ECVS_MODULE |
|
|
225 | ECVS_LOCAL=$ECVS_LOCAL |
|
|
226 | ECVS_RUNAS=$ECVS_RUNAS" |
|
|
227 | |
|
|
228 | [ -z "$ECVS_MODULE" ] && die "ERROR: CVS module not set, cannot continue." |
|
|
229 | |
|
|
230 | if [ "$ECVS_SERVER" == "offline" ]; then |
|
|
231 | # we're not required to fetch anything, the module already exists and shouldn't be updated |
|
|
232 | if [ -d "${ECVS_TOP_DIR}/${ECVS_MODULE}" ]; then |
|
|
233 | debug-print "$FUNCNAME: offline mode, exiting" |
|
|
234 | return 0 |
180 | else |
235 | else |
181 | #update existing module |
236 | debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error" |
182 | debug-print "$FUNCNAME: updating existing module/subdir" |
237 | die "ERROR: Offline mode specified, but module/subdir checkout not found. Aborting." |
183 | |
|
|
184 | # Switch servers if needed |
|
|
185 | # cvs keeps the server info in the CVS/Root file in every checked-out dir; |
|
|
186 | # we can fix those files to point to the new server |
|
|
187 | oldserver="`cat CVS/Root`" |
|
|
188 | if [ "$newserver" != "$oldserver" ]; then |
|
|
189 | |
|
|
190 | einfo "Changing CVS server from $oldserver to $newserver:" |
|
|
191 | debug-print "$FUNCNAME: Changing CVS server from $oldserver to $newserver:" |
|
|
192 | |
|
|
193 | einfo "Searching for CVS dirs..." |
|
|
194 | cvsdirs="`find . -iname CVS -print`" |
|
|
195 | debug-print "$FUNCNAME: CVS dirs found:" |
|
|
196 | debug-print "$cvsdirs" |
|
|
197 | |
|
|
198 | einfo "Modifying CVS dirs..." |
|
|
199 | for x in $cvsdirs; do |
|
|
200 | debug-print "In $x" |
|
|
201 | echo $newserver > "$x/Root" |
|
|
202 | done |
|
|
203 | |
|
|
204 | fi |
238 | fi |
205 | |
239 | elif [ -n "$ECVS_SERVER" ]; then # ECVS_SERVER!=offline --> real fetching mode |
206 | fi |
240 | einfo "Fetching cvs module $ECVS_MODULE into $ECVS_TOP_DIR..." |
207 | |
241 | cvs_fetch |
208 | # cvs auto-switches branches, how nice |
242 | else # ECVS_SERVER not set |
209 | # warning: if we do it this way we get multiple -rX options - harmless i think |
243 | die "ERROR: CVS server not set, cannot continue." |
210 | [ -n "$ECVS_BRANCH" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -r$ECVS_BRANCH" |
|
|
211 | |
|
|
212 | # Chowning the directory |
|
|
213 | if [ "${ECVS_RUNAS}" != "`whoami`" ]; then |
|
|
214 | chown -R "$ECVS_RUNAS" "/$DIR" |
|
|
215 | fi |
|
|
216 | |
|
|
217 | # finally run the cvs update command |
|
|
218 | debug-print "$FUNCNAME: is in dir `/bin/pwd`" |
|
|
219 | debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for module $ECVS_MODULE subdir $ECVS_SUBDIR" |
|
|
220 | einfo "Running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for $ECVS_MODULE/$ECVS_SUBDIR..." |
|
|
221 | |
|
|
222 | if [ "${ECVS_ANON}" == "no" ]; then |
|
|
223 | |
|
|
224 | debug-print "$FUNCNAME: starting non-anonymous cvs login..." |
|
|
225 | # CVS Login - written in python :: the right way ;) |
|
|
226 | # Tilman Klar, <phoenix@gentoo.org> |
|
|
227 | |
|
|
228 | export CVS_RSH="/usr/bin/ssh" |
|
|
229 | |
|
|
230 | ############################## inline-python ##################################### |
|
|
231 | /usr/bin/env python << EndOfFile |
|
|
232 | |
|
|
233 | import pexpect,os |
|
|
234 | |
|
|
235 | mypasswd = "${ECVS_PASS}" |
|
|
236 | myauth = "${ECVS_AUTH}" |
|
|
237 | mytimeout = 10 |
|
|
238 | |
|
|
239 | if "${ECVS_RUNAS}" == "`whoami`": |
|
|
240 | mycommand = "${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}" |
|
|
241 | else: |
|
|
242 | mycommand = "su ${ECVS_RUNAS} -c \"${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}\"" |
|
|
243 | |
|
|
244 | if myauth == "ext": |
|
|
245 | child = pexpect.spawn(mycommand) |
|
|
246 | |
|
|
247 | index = child.expect(['continue connecting','word:'], mytimeout) |
|
|
248 | if index == 0: |
|
|
249 | child.sendline('yes') |
|
|
250 | ## Added server to ~/.ssh/known_hosts |
|
|
251 | child.expect('word:', mytimeout) |
|
|
252 | else: |
|
|
253 | ## Server already is in ~/.ssh/known_hosts |
|
|
254 | pass |
|
|
255 | |
|
|
256 | child.sendline(mypasswd) |
|
|
257 | child.expect(pexpect.EOF) |
|
|
258 | |
|
|
259 | elif myauth == "pserver": |
|
|
260 | if "${ECVS_RUNAS}" == "`whoami`": |
|
|
261 | mycommand2 = "cvs login" |
|
|
262 | else: |
|
|
263 | mycommand2 = "su ${ECVS_RUNAS} -c \"cvs login\"" |
|
|
264 | child = pexpect.spawn(mycommand2) |
|
|
265 | child.expect("CVS password:",mytimeout) |
|
|
266 | child.sendline(mypasswd) |
|
|
267 | child.expect(pexpect.EOF) |
|
|
268 | |
|
|
269 | # Logged in - checking out |
|
|
270 | os.system(mycommand) |
|
|
271 | |
|
|
272 | EndOfFile |
|
|
273 | ########################### End of inline-python ################################## |
|
|
274 | else |
|
|
275 | # is anonymous cvs. |
|
|
276 | # is there a password to use for login with this "anonymous" login |
|
|
277 | if [ -n "$ECVS_PASS" ]; then |
|
|
278 | debug-print "$FUNCNAME: using anonymous cvs login with password" |
|
|
279 | |
|
|
280 | # inline-python # |
|
|
281 | /usr/bin/env python << EndOfFile |
|
|
282 | |
|
|
283 | import pexpect,os |
|
|
284 | |
|
|
285 | myuser = "${ECVS_USER}" |
|
|
286 | mypasswd = "${ECVS_PASS}" |
|
|
287 | |
|
|
288 | mytimeout = 10 |
|
|
289 | |
|
|
290 | # implicitly myauth == "pserver" here. |
|
|
291 | mycommand = "cvs login" |
|
|
292 | child = pexpect.spawn(mycommand) |
|
|
293 | child.expect("CVS password:",mytimeout) |
|
|
294 | child.sendline(mypasswd) |
|
|
295 | child.expect(pexpect.EOF) |
|
|
296 | EndOfFile |
|
|
297 | # End of inline-python # |
|
|
298 | |
|
|
299 | else |
|
|
300 | debug-print "$FUNCNAME: using anonymous cvs login (without password)" |
|
|
301 | # passwordless, truly anonymous login; or login with empty (but existing) |
|
|
302 | # password. |
|
|
303 | # make cvs think we're logged in at the cvs server, |
|
|
304 | # because i don't trust myself to write the right code for the case |
|
|
305 | # where the password is empty but still required (what's the bash test |
|
|
306 | # to see if a variable is defined? -n returns false if it is defined |
|
|
307 | # but empty...) |
|
|
308 | echo ":pserver:${ECVS_SERVER} A" > "${T}/cvspass" |
|
|
309 | # remember we did this so we don't try to run cvs logout later |
|
|
310 | DONT_LOGOUT=yes |
|
|
311 | fi |
244 | fi |
312 | |
245 | |
313 | debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS" |
|
|
314 | $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS || die "died running cvs update" |
|
|
315 | |
|
|
316 | fi |
|
|
317 | |
|
|
318 | # log out and restore ownership as needed |
|
|
319 | if [ -z "$DONT_LOGOUT" ]; then |
|
|
320 | debug-print "$FUNCNAME: cvs logout stuff" |
|
|
321 | if [ "$ECVS_RUNAS" == "`whoami`" ]; then |
|
|
322 | cvs logout &> /dev/null |
|
|
323 | else |
|
|
324 | su $ECVS_RUNAS -c "cvs logout" &> /dev/null |
|
|
325 | fi |
|
|
326 | fi |
|
|
327 | chown `whoami` "${T}/cvspass" |
|
|
328 | } |
|
|
329 | |
|
|
330 | cvs_src_unpack() { |
|
|
331 | |
|
|
332 | debug-print-function $FUNCNAME $* |
|
|
333 | cvs_fetch || die "died running cvs_fetch" |
|
|
334 | |
|
|
335 | einfo "Copying $ECVS_MODULE/$ECVS_SUBDIR from $ECVS_TOP_DIR..." |
246 | einfo "Copying $ECVS_MODULE from $ECVS_TOP_DIR..." |
336 | debug-print "Copying module $ECVS_MODULE subdir $ECVS_SUBDIR local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..." |
247 | debug-print "Copying module $ECVS_MODULElocal_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..." |
337 | |
248 | |
338 | # probably redundant, but best to make sure |
249 | # probably redundant, but best to make sure |
339 | mkdir -p "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR" |
250 | mkdir -p "$WORKDIR/$ECVS_MODULE" |
340 | |
251 | |
341 | if [ -n "$ECVS_SUBDIR" ]; then |
|
|
342 | if [ -n "$ECVS_LOCAL" ]; then |
252 | if [ -n "$ECVS_LOCAL" ]; then |
343 | cp -f "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR"/* "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR" |
253 | mkdir -p "$WORKDIR/$ECVS_MODULE" |
344 | else |
|
|
345 | cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR" "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR/.." |
|
|
346 | fi |
|
|
347 | else |
|
|
348 | if [ -n "$ECVS_LOCAL" ]; then |
|
|
349 | cp -f "$ECVS_TOP_DIR/$ECVS_MODULE"/* $WORKDIR/$ECVS_MODULE |
254 | cp -f "$ECVS_TOP_DIR/$ECVS_MODULE"/* "$WORKDIR/$ECVS_MODULE" |
350 | else |
255 | else |
351 | cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR" |
256 | cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR/$ECVS_MODULE/.." |
352 | fi |
257 | fi |
353 | fi |
258 | |
354 | |
|
|
355 | # if the directory is empty, remove it; empty directories cannot exist in cvs. |
259 | # if the directory is empty, remove it; empty directories cannot exist in cvs. |
356 | # this happens when fex. kde-source requests module/doc/subdir which doesn't exist. |
260 | # this happens when fex. kde-source requests module/doc/subdir which doesn't exist. |
357 | # still create the empty directory in workdir though. |
261 | # still create the empty directory in workdir though. |
358 | if [ "`ls -A \"$DIR\"`" == "CVS" ]; then |
262 | if [ "`ls -A \"${ECVS_TOP_DIR}/${ECVS_MODULE}\"`" == "CVS" ]; then |
359 | debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE/$ECVS_SUBDIR" |
263 | debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE" |
360 | rm -rf "$DIR" |
264 | rm -rf "${ECVS_TOP_DIR}/${ECVS_MODULE}" |
361 | fi |
265 | fi |
362 | |
266 | |
363 | # implement some of base_src_unpack's functionality; |
267 | # implement some of base_src_unpack's functionality; |
364 | # note however that base.eclass may not have been inherited! |
268 | # note however that base.eclass may not have been inherited! |
365 | if [ -n "$PATCHES" ]; then |
269 | if [ -n "$PATCHES" ]; then |
366 | debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching" |
270 | debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching" |
367 | cd "$S" |
271 | cd "$S" |