/[gentoo-x86]/eclass/cvs.eclass
Gentoo

Diff of /eclass/cvs.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.49 Revision 1.61
1# Copyright 1999-2003 Gentoo Technologies, Inc. 1# Copyright 1999-2004 Gentoo Foundation
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.49 2003/09/28 17:24:18 coredumb Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.61 2005/09/21 23:22:56 vapier Exp $
4# 4
5# Current Maintainer: Tal Peer <coredumb@gentoo.org> 5inherit eutils
6# Original Author: Dan Armak <danarmak@gentoo.org> 6
7#
8# SSH auth code by Danny <danny.milo@gmx.net>
9#
10# This eclass provides the generic cvs fetching functions. 7# This eclass provides the generic cvs fetching functions. To use
11# to use from an ebuild, set the 'ebuild-configurable settings' below in your ebuild before inheriting. 8# this from an ebuild, set the `ebuild-configurable settings' as
9# specified below in your ebuild before inheriting. Then either leave
12# then either leave the default src_unpack or extend over cvs_src_unpack. 10# the default src_unpack or extend over cvs_src_unpack. If you find
13# if you find that you need to call the cvs_* functions directly, i'd be interested to hear about it. 11# that you need to call the cvs_* functions directly, I'd be
12# interested to hear about it.
14 13
15# TODO: 14# TODO:
15
16# Implement more auth types (gserver?, kserver?) 16# Implement more auth types (gserver?, kserver?)
17# Implement more 'ext' auth methods (do anyone actually use it with anything other than ssh?)
18# Add support for password-based ssh (only keys supported now)
19 17
20ECLASS=cvs 18# Support additional remote shells with `ext' authentication (does
21INHERITED="$INHERITED $ECLASS" 19# anyone actually need to use it with anything other than SSH?)
22 20
21
22
23# You shouldn't change these settings yourself! The ebuild/eclass inheriting this eclass 23# Users shouldn't change these settings! The ebuild/eclass inheriting
24# will take care of that. If you want to set the global KDE cvs ebuilds' settings, 24# this eclass will take care of that. If you want to set the global
25# see the comments in kde-source.eclass. 25# KDE cvs ebuilds' settings, see the comments in kde-source.eclass.
26 26
27# --- begin ebuild-configurable settings 27# --- begin ebuild-configurable settings
28 28
29# ECVS_CVS_COMMAND -- CVS command to run
30#
29# cvs command to run. you can set fex. "cvs -t" for extensive debug information 31# You can set, for example, "cvs -t" for extensive debug information
30# on the cvs onnection. the default of "cvs -q -f -z4" means to be quiet, to disregard 32# on the cvs connection. The default of "cvs -q -f -z4" means to be
31# the ~/.cvsrc config file and to use maximum compression. 33# quiet, to disregard the ~/.cvsrc config file and to use maximum
34# compression.
35
32[ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4" 36[ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4"
33 37
34# cvs options given after the cvs command (update or checkout) 38
39# ECVS_UP_OPTS, ECVS_CO_OPTS -- CVS options given after the cvs
40# command (update or checkout).
41#
35# don't remove -dP from update or things won't work 42# Don't remove -dP from update or things won't work.
43
36[ -z "$ECVS_UP_OPTS" ] && ECVS_UP_OPTS="-dP" 44[ -z "$ECVS_UP_OPTS" ] && ECVS_UP_OPTS="-dP"
37[ -z "$ECVS_CO_OPTS" ] && ECVS_CO_OPTS="" 45[ -z "$ECVS_CO_OPTS" ] && ECVS_CO_OPTS=""
38 46
39# set this to some value for the module/subdir to be fetched non-recursively: ECVS_LOCAL
40 47
41# local name of module. useful if the module on the server is called 48# ECVS_LOCAL -- If this is set, the CVS module will be fetched
49# non-recursively. Refer to the information in the CVS man page
50# regarding the -l command option (not the -l global option).
51
52
53# ECVS_LOCALNAME -- local name of checkout directory
54#
55# This is useful if the module on the server is called something
42# something common like 'driver' or is nested deep in a tree, and you don't 56# common like 'driver' or is nested deep in a tree, and you don't like
43# like useless empty directories. 57# useless empty directories.
58#
44# WARNING: to be set only from within ebuilds! if set in your shell or some such, 59# WARNING: Set this only from within ebuilds! If set in your shell or
45# things wil break because the ebuild won't expect it and have e.g. a wrong $S setting. 60# some such, things will break because the ebuild won't expect it and
46# ECVS_LOCALNAME 61# have e.g. a wrong $S setting.
47 62
48# Where the cvs modules are stored/accessed 63
64# ECVS_TOP_DIR -- The directory under which CVS modules are checked
65# out.
66
49[ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src" 67[ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src"
50 68
51# Name of cvs server, set to "offline" to disable fetching 69# ECVS_SERVER -- CVS path
52# (i.e. to assume module is checked out already and don't update it). 70#
53# Format is server:/dir e.g. "anoncvs.kde.org:/home/kde". remove the other 71# The format is "server:/dir", e.g. "anoncvs.kde.org:/home/kde".
54# parts of the full CVSROOT (which looks like 72# Remove the other parts of the full CVSROOT, which might look like
55# ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from 73# ":pserver:anonymous@anoncvs.kde.org:/home/kde"; this is generated
56# other settings 74# using other settings also.
57# the special value 'offline' disables fetching, assumes sources are alread in ECVS_TOP_DIR 75#
76# Set this to "offline" to disable fetching (i.e. to assume the module
77# is already checked out in ECVS_TOP_DIR).
78
58[ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline" 79[ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline"
59 80
60# Authentication method to use - possible values are "pserver" and "ext" 81
61# Currently, only method for 'ext' is ssh, please note that it doesn't 82# ECVS_MODULE -- the name of the CVS module to be fetched
62# work with passwords, only with keys. 83#
84# This must be set when cvs_src_unpack is called. This can include
85# several directory levels, i.e. "foo/bar/baz"
86
87#[ -z "$ECVS_MODULE" ] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue"
88
89
90# ECVS_BRANCH -- the name of the branch/tag to use
91
92# The default is "HEAD". The following default _will_ reset your
93# branch checkout to head if used.
94
95#[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"
96
97
98# ECVS_AUTH -- authentication method to use
99#
100# Possible values are "pserver" and "ext". If `ext' authentication is
101# used, the remote shell to use can be specified in CVS_RSH (SSH is
102# used by default). Currently, the only supported remote shell for
103# `ext' authentication is SSH.
104#
105# Armando Di Cianno <fafhrd@gentoo.org> 2004/09/27
106# - Added "no" as a server type, which uses no AUTH method, nor
107# does it login
108# e.g.
109# "cvs -danoncvs@savannah.gnu.org:/cvsroot/backbone co System"
110# ( from gnustep-apps/textedit )
63[ -z "$ECVS_AUTH" ] && ECVS_AUTH="pserver" 111[ -z "$ECVS_AUTH" ] && ECVS_AUTH="pserver"
64 112
65# Use su to run cvs as user 113# ECVS_USER -- Username to use for authentication on the remote server
114[ -z "$ECVS_USER" ] && ECVS_USER="anonymous"
115
116
117# ECVS_PASS -- Password to use for authentication on the remote server
118[ -z "$ECVS_PASS" ] && ECVS_PASS=""
119
120
121# ECVS_SSH_HOST_KEY
122#
123# If SSH is used for `ext' authentication, use this variable to
124# specify the host key of the remote server. The format of the value
125# should be the same format that is used for the SSH known hosts file.
126#
127# WARNING: If a SSH host key is not specified using this variable, the
128# remote host key will not be verified.
129
130
131# ECVS_CLEAN -- Set this to get a clean copy when updating (passes the
132# -C option to cvs update)
133
134
135# ECVS_RUNAS
136#
137# Specifies an alternate (non-root) user to use to run cvs. Currently
66# Currently b0rked and wouldn't work with portage userpriv anyway without special magic 138# b0rked and wouldn't work with portage userpriv anyway without
139# special magic.
140
67# [ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`" 141# [ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`"
68 142
69# Username to give to the server
70[ -z "$ECVS_USER" ] && ECVS_USER="anonymous"
71 143
72# Password to use 144# ECVS_SUBDIR -- deprecated, do not use
73[ -z "$ECVS_PASS" ] && ECVS_PASS=""
74
75# Module to be fetched, must be set when kde_src_unpack is called
76# can include several directory levels, ie foo/bar/baz
77#[ -z "$ECVS_MODULE" ] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue"
78
79# Branch/tag to use, default is HEAD
80# the following default _will_ reset your branch checkout to head if used
81#[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"
82
83# deprecated - do not use
84[ -n "$ECVS_SUBDIR" ] && die "ERROR: deprecated ECVS_SUBDIR defined. Please fix this ebuild." 145[ -n "$ECVS_SUBDIR" ] && die "ERROR: deprecated ECVS_SUBDIR defined. Please fix this ebuild."
85 146
86# ECVS_CLEAN: set this to something to get a clean copy when updating (passes the -C option to cvs update)
87 147
88# --- end ebuild-configurable settings --- 148# --- end ebuild-configurable settings ---
89 149
90# add cvs to deps 150# add cvs to deps
91# ssh is used for ext auth 151# ssh is used for ext auth
92# sudo is used to run as a specified user 152# sudo is used to run as a specified user
93DEPEND="$DEPEND dev-util/cvs app-admin/sudo" 153DEPEND="dev-util/cvs"
154
155[ -n "$ECVS_RUNAS" ] && DEPEND="$DEPEND app-admin/sudo"
94 156
95if [ "$ECVS_AUTH" == "ext" ]; then 157if [ "$ECVS_AUTH" == "ext" ]; then
96 #default to ssh 158 #default to ssh
97 [ -z "$CVS_RSH" ] && export SSH_RSH="ssh" 159 [ -z "$CVS_RSH" ] && export CVS_RSH="ssh"
98 if [ "$CVS_RSH" != "ssh" ]; then 160 if [ "$CVS_RSH" != "ssh" ]; then
99 die "Support for ext auth with clients other than ssh has not been implemented yet" 161 die "Support for ext auth with clients other than ssh has not been implemented yet"
100 fi 162 fi
101 DEPEND="$DEPEND net-misc/openssh" 163 DEPEND="${DEPEND} net-misc/openssh"
102fi 164fi
103 165
104# calls cvs_contorl, is called from cvs_src_unpack 166# called from cvs_src_unpack
105cvs_fetch() { 167cvs_fetch() {
106 168
169 # Make these options local variables so that the global values are
170 # not affected by modifications in this function.
171
172 local ECVS_COMMAND="${ECVS_COMMAND}"
173 local ECVS_UP_OPTS="${ECVS_UP_OPTS}"
174 local ECVS_CO_OPTS="${ECVS_CO_OPTS}"
175
107 # fix for sourceforge which doesnt want -z>3 anymore. 176 # Fix for sourceforge which doesnt want -z>3 anymore.
108 177
109 (echo $ECVS_SERVER | grep sourceforge) && [ "$ECVS_CVS_COMMAND" == "cvs -q -f -z4" ] && ECVS_CVS_COMMAND="cvs -q -f -z3" 178 (echo $ECVS_SERVER | grep -q sourceforge) \
179 && [ "$ECVS_CVS_COMMAND" == "cvs -q -f -z4" ] \
180 && ECVS_CVS_COMMAND="cvs -q -f -z3"
110 181
111 debug-print-function $FUNCNAME $* 182 debug-print-function $FUNCNAME $*
112 183
113 # parameters modifying other parameters that should be effective every time cvs_fetch is called, 184 # Update variables that are modified by ebuild parameters, which
185 # should be effective every time cvs_fetch is called, and not just
114 # and not just every time cvs.eclas is inherited 186 # every time cvs.eclass is inherited
187
115 # 1. parameter for local (non-recursive) fetching 188 # Handle parameter for local (non-recursive) fetching
189
116 if [ -n "$ECVS_LOCAL" ]; then 190 if [ -n "$ECVS_LOCAL" ]; then
117 ECVS_UP_OPTS="$ECVS_UP_OPTS -l" 191 ECVS_UP_OPTS="$ECVS_UP_OPTS -l"
118 ECVS_CO_OPTS="$ECVS_CO_OPTS -l" 192 ECVS_CO_OPTS="$ECVS_CO_OPTS -l"
119 fi 193 fi
120 # 2. cvs auto-switches branches, we just have to pass the correct -rBRANCH option to it when updating. 194
121 # doing it this way we get multiple -rX options - harmless afaik 195 # Handle ECVS_BRANCH option
196 #
197 # Because CVS auto-switches branches, we just have to pass the
198 # correct -rBRANCH option when updating.
199
122 if [ -n "$ECVS_BRANCH" ]; then 200 if [ -n "$ECVS_BRANCH" ]; then
123 ECVS_UP_OPTS="$ECVS_UP_OPTS -r$ECVS_BRANCH" 201 ECVS_UP_OPTS="$ECVS_UP_OPTS -r$ECVS_BRANCH"
124 ECVS_CO_OPTS="$ECVS_CO_OPTS -r$ECVS_BRANCH" 202 ECVS_CO_OPTS="$ECVS_CO_OPTS -r$ECVS_BRANCH"
125 fi 203 fi
126 204
205 # Handle ECVS_LOCALNAME, which specifies the local directory name
206 # to use. Note that the -d command option is not equivalent to
207 # the global -d option.
208
127 if [ "$ECVS_LOCALNAME" != "$ECVS_MODULE" ]; then 209 if [ "$ECVS_LOCALNAME" != "$ECVS_MODULE" ]; then
128 # the option to cvs on which this is based. note this isn't the same as the
129 # global -d option to cvs, which specifies the cvs server. ugh @ cvs syntax.
130 ECVS_CO_OPTS="$ECVS_CO_OPTS -d $ECVS_LOCALNAME" 210 ECVS_CO_OPTS="$ECVS_CO_OPTS -d $ECVS_LOCALNAME"
131 fi 211 fi
212
132 213
133 if [ -n "$ECVS_CLEAN" ]; then 214 if [ -n "$ECVS_CLEAN" ]; then
134 ECVS_UP_OPTS="$ECVS_UP_OPTS -C" 215 ECVS_UP_OPTS="$ECVS_UP_OPTS -C"
135 fi 216 fi
136 217
218
137 # it's easiest to always be in "run-as mode", logic-wise 219 # It would be easiest to always be in "run-as mode", logic-wise,
138 # or would be if sudo didn't ask for a password even when sudo'ing to `whoami` 220 # if sudo didn't ask for a password even when sudo'ing to `whoami`.
221
139 if [ -z "$ECVS_RUNAS" ]; then 222 if [ -z "$ECVS_RUNAS" ]; then
140 run="" 223 run=""
141 else 224 else
142 run="sudo -u $ECVS_RUNAS" 225 run="sudo -u $ECVS_RUNAS"
143 fi 226 fi
144 227
145 # create the top dir if needed 228 # Create the top dir if needed
229
146 if [ ! -d "$ECVS_TOP_DIR" ]; then 230 if [ ! -d "$ECVS_TOP_DIR" ]; then
147 # note that the addwrite statements in this block are only there to allow creating ECVS_TOP_DIR; 231
148 # we've already allowed writing inside it 232 # Note that the addwrite statements in this block are only
233 # there to allow creating ECVS_TOP_DIR; we allow writing
234 # inside it separately.
235
149 # this is because it's simpler than trying to find out the parent path of the directory, which 236 # This is because it's simpler than trying to find out the
237 # parent path of the directory, which would need to be the
150 # would need to be the real path and not a symlink for things to work (so we can't just remove 238 # real path and not a symlink for things to work (so we can't
151 # the last path element in the string) 239 # just remove the last path element in the string)
240
152 debug-print "$FUNCNAME: checkout mode. creating cvs directory" 241 debug-print "$FUNCNAME: checkout mode. creating cvs directory"
153 addwrite /foobar 242 addwrite /foobar
154 addwrite / 243 addwrite /
155 $run mkdir -p "/$ECVS_TOP_DIR" 244 $run mkdir -p "/$ECVS_TOP_DIR"
156 export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}" 245 export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}"
157 fi 246 fi
158 247
159 # in case ECVS_TOP_DIR is a symlink to a dir, get the real dir's path, 248 # In case ECVS_TOP_DIR is a symlink to a dir, get the real path,
160 # otherwise addwrite() doesn't work. 249 # otherwise addwrite() doesn't work.
250
161 cd -P "$ECVS_TOP_DIR" > /dev/null 251 cd -P "$ECVS_TOP_DIR" > /dev/null
162 ECVS_TOP_DIR="`/bin/pwd`" 252 ECVS_TOP_DIR="`/bin/pwd`"
163 253
164 # determine checkout or update mode 254 # Disable the sandbox for this dir
255 addwrite "$ECVS_TOP_DIR"
256
257 # Chown the directory and all of its contents
258 if [ -n "$ECVS_RUNAS" ]; then
259 $run chown -R "$ECVS_RUNAS" "/$ECVS_TOP_DIR"
260 fi
261
262 # Determine the CVS command mode (checkout or update)
165 if [ ! -d "$ECVS_TOP_DIR/$ECVS_LOCALNAME/CVS" ]; then 263 if [ ! -d "$ECVS_TOP_DIR/$ECVS_LOCALNAME/CVS" ]; then
166 mode=checkout 264 mode=checkout
167 else 265 else
168 mode=update 266 mode=update
169 fi 267 fi
170 268
171 # disable the sandbox for this dir
172 addwrite "$ECVS_TOP_DIR"
173 269
174 # chowning the directory and all contents
175 if [ -n "$ECVS_RUNAS" ]; then
176 $run chown -R "$ECVS_RUNAS" "/$ECVS_TOP_DIR"
177 fi
178
179 # our server string (aka CVSROOT), without the password so it can be put in Root 270 # Our server string (i.e. CVSROOT) without the password so it can
271 # be put in Root
272 if [ "$ECVS_AUTH" == "no" ]
273 then
274 local server="${ECVS_USER}@${ECVS_SERVER}"
275 else
180 server=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" 276 local server=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}"
277 fi
181 278
182 # switch servers automagically if needed 279 # Switch servers automagically if needed
183 if [ "$mode" == "update" ]; then 280 if [ "$mode" == "update" ]; then
184 cd /$ECVS_TOP_DIR/$ECVS_LOCALNAME 281 cd /$ECVS_TOP_DIR/$ECVS_LOCALNAME
185 oldserver="`$run cat CVS/Root`" 282 local oldserver="`$run cat CVS/Root`"
186 if [ "$server" != "$oldserver" ]; then 283 if [ "$server" != "$oldserver" ]; then
187 284
188 einfo "Changing CVS server from $oldserver to $server:" 285 einfo "Changing the CVS server from $oldserver to $server:"
189 debug-print "$FUNCNAME: Changing CVS server from $oldserver to $server:" 286 debug-print "$FUNCNAME: Changing the CVS server from $oldserver to $server:"
190 287
191 einfo "Searching for CVS dirs..." 288 einfo "Searching for CVS directories ..."
192 cvsdirs="`$run find . -iname CVS -print`" 289 local cvsdirs="`$run find . -iname CVS -print`"
193 debug-print "$FUNCNAME: CVS dirs found:" 290 debug-print "$FUNCNAME: CVS directories found:"
194 debug-print "$cvsdirs" 291 debug-print "$cvsdirs"
195 292
196 einfo "Modifying CVS dirs..." 293 einfo "Modifying CVS directories ..."
197 for x in $cvsdirs; do 294 for x in $cvsdirs; do
198 debug-print "In $x" 295 debug-print "In $x"
199 $run echo "$server" > "$x/Root" 296 $run echo "$server" > "$x/Root"
200 done 297 done
201 298
202 fi 299 fi
203 fi 300 fi
204 301
205 # prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass 302 # Prepare a cvspass file just for this session, we don't want to
303 # mess with ~/.cvspass
206 touch "${T}/cvspass" 304 touch "${T}/cvspass"
207 export CVS_PASSFILE="${T}/cvspass" 305 export CVS_PASSFILE="${T}/cvspass"
208 if [ -n "$ECVS_RUNAS" ]; then 306 if [ -n "$ECVS_RUNAS" ]; then
209 chown "$ECVS_RUNAS" "${T}/cvspass" 307 chown "$ECVS_RUNAS" "${T}/cvspass"
210 fi 308 fi
211 309
212 # the server string with the password in it, for login 310 # The server string with the password in it, for login
213 cvsroot_pass=":${ECVS_AUTH}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}" 311 cvsroot_pass=":${ECVS_AUTH}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}"
312
214 # ditto without the password, for checkout/update after login, so that 313 # Ditto without the password, for checkout/update after login, so
215 # the CVS/Root files don't contain the password in plaintext 314 # that the CVS/Root files don't contain the password in plaintext
315 if [ "$ECVS_AUTH" == "no" ]
316 then
317 cvsroot_nopass="${ECVS_USER}@${ECVS_SERVER}"
318 else
216 cvsroot_nopass=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" 319 cvsroot_nopass=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}"
320 fi
217 321
218 # commands to run 322 # Commands to run
219 cmdlogin="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_pass}\" login" 323 cmdlogin="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_pass}\" login"
220 cmdupdate="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" update ${ECVS_UP_OPTS} ${ECVS_LOCALNAME}" 324 cmdupdate="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" update ${ECVS_UP_OPTS} ${ECVS_LOCALNAME}"
221 cmdcheckout="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}" 325 cmdcheckout="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}"
326
327 # Execute commands
222 328
223 cd "${ECVS_TOP_DIR}" 329 cd "${ECVS_TOP_DIR}"
224 if [ "${ECVS_AUTH}" == "pserver" ]; then 330 if [ "${ECVS_AUTH}" == "pserver" ]; then
225 einfo "Running $cmdlogin" 331 einfo "Running $cmdlogin"
226 eval $cmdlogin || die "cvs login command failed" 332 eval $cmdlogin || die "cvs login command failed"
227 if [ "${mode}" == "update" ]; then 333 if [ "${mode}" == "update" ]; then
228 einfo "Running $cmdupdate" 334 einfo "Running $cmdupdate"
229 eval $cmdupdate || die "cvs update command failed" 335 eval $cmdupdate || die "cvs update command failed"
230 elif [ "${mode}" == "checkout" ]; then 336 elif [ "${mode}" == "checkout" ]; then
231 einfo "Running $cmdcheckout" 337 einfo "Running $cmdcheckout"
232 eval $cmdcheckout|| die "cvs checkout command failed" 338 eval $cmdcheckout|| die "cvs checkout command failed"
233 fi 339 fi
340 elif [ "${ECVS_AUTH}" == "ext" ] || [ "${ECVS_AUTH}" == "no" ]; then
341
342 # Hack to support SSH password authentication
343
344 # Backup environment variable values
345 local CVS_ECLASS_ORIG_CVS_RSH="${CVS_RSH}"
346
347 if [ "${SSH_ASKPASS+set}" == "set" ]; then
348 local CVS_ECLASS_ORIG_SSH_ASKPASS="${SSH_ASKPASS}"
349 else
350 unset CVS_ECLASS_ORIG_SSH_ASKPASS
351 fi
352
353 if [ "${DISPLAY+set}" == "set" ]; then
354 local CVS_ECLASS_ORIG_DISPLAY="${DISPLAY}"
355 else
356 unset CVS_ECLASS_ORIG_DISPLAY
357 fi
358
359 if [ "${CVS_RSH}" == "ssh" ]; then
360
361 # Force SSH to use SSH_ASKPASS by creating python wrapper
362
363 export CVS_RSH="${T}/cvs_sshwrapper"
364 cat > "${CVS_RSH}"<<EOF
365#!/usr/bin/python
366import fcntl
367import os
368import sys
369try:
370 fd = os.open('/dev/tty', 2)
371 TIOCNOTTY=0x5422
372 try:
373 fcntl.ioctl(fd, TIOCNOTTY)
374 except:
375 pass
376 os.close(fd)
377except:
378 pass
379newarglist = sys.argv[:]
380EOF
381
382 # disable X11 forwarding which causes .xauth access violations
383 # - 20041205 Armando Di Cianno <fafhrd@gentoo.org>
384 echo "newarglist.insert(1, '-oClearAllForwardings=yes')" \
385 >> "${CVS_RSH}"
386 echo "newarglist.insert(1, '-oForwardX11=no')" \
387 >> "${CVS_RSH}"
388
389 # Handle SSH host key checking
390
391 local CVS_ECLASS_KNOWN_HOSTS="${T}/cvs_ssh_known_hosts"
392 echo "newarglist.insert(1, '-oUserKnownHostsFile=${CVS_ECLASS_KNOWN_HOSTS}')" \
393 >> "${CVS_RSH}"
394
395 if [ -z "${ECVS_SSH_HOST_KEY}" ]; then
396 ewarn "Warning: The SSH host key of the remote server will not be verified."
397 einfo "A temporary known hosts list will be used."
398 local CVS_ECLASS_STRICT_HOST_CHECKING="no"
399 touch "${CVS_ECLASS_KNOWN_HOSTS}"
400 else
401 local CVS_ECLASS_STRICT_HOST_CHECKING="yes"
402 echo "${ECVS_SSH_HOST_KEY}" > "${CVS_ECLASS_KNOWN_HOSTS}"
403 fi
404
405 echo -n "newarglist.insert(1, '-oStrictHostKeyChecking=" \
406 >> "${CVS_RSH}"
407 echo "${CVS_ECLASS_STRICT_HOST_CHECKING}')" \
408 >> "${CVS_RSH}"
409 echo "os.execv('/usr/bin/ssh', newarglist)" \
410 >> "${CVS_RSH}"
411
412 chmod a+x "${CVS_RSH}"
413
414 # Make sure DISPLAY is set (SSH will not use SSH_ASKPASS
415 # if DISPLAY is not set)
416
417 [ -z "${DISPLAY}" ] && DISPLAY="DISPLAY"
418 export DISPLAY
419
420 # Create a dummy executable to echo $ECVS_PASS
421
422 export SSH_ASKPASS="${T}/cvs_sshechopass"
234 elif [ "${ECVS_AUTH}" == "ext" ]; then 423 if [ "${ECVS_AUTH}" != "no" ]; then
235 #no login needed for ext 424 echo -en "#!/bin/bash\necho \"$ECVS_PASS\"\n" \
425 > "${SSH_ASKPASS}"
426 else
427 echo -en "#!/bin/bash\nreturn\n" \
428 > "${SSH_ASKPASS}"
429
430 fi
431 chmod a+x "${SSH_ASKPASS}"
432 fi
433
236 if [ "${mode}" == "update" ]; then 434 if [ "${mode}" == "update" ]; then
237 einfo "Running $cmdupdate" 435 einfo "Running $cmdupdate"
238 eval $cmdupdate || die "cvs update command failed" 436 eval $cmdupdate || die "cvs update command failed"
239 elif [ "${mode}" == "checkout" ]; then 437 elif [ "${mode}" == "checkout" ]; then
240 einfo "Running $cmdcheckout" 438 einfo "Running $cmdcheckout"
241 eval $cmdcheckout|| die "cvs checkout command failed" 439 eval $cmdcheckout|| die "cvs checkout command failed"
242 fi 440 fi
441
442 # Restore environment variable values
443 export CVS_RSH="${CVS_ECLASS_ORIG_CVS_RSH}"
444 if [ "${CVS_ECLASS_ORIG_SSH_ASKPASS+set}" == "set" ]; then
445 export SSH_ASKPASS="${CVS_ECLASS_ORIG_SSH_ASKPASS}"
446 else
447 unset SSH_ASKPASS
243 fi 448 fi
244 449
245 # restore ownership. not sure why this is needed, but someone added it in the orig ECVS_RUNAS stuff. 450 if [ "${CVS_ECLASS_ORIG_DISPLAY+set}" == "set" ]; then
451 export DISPLAY="${CVS_ECLASS_ORIG_DISPLAY}"
452 else
453 unset DISPLAY
454 fi
455 fi
456
457 # Restore ownership. Not sure why this is needed, but someone
458 # added it in the orig ECVS_RUNAS stuff.
246 if [ -n "$ECVS_RUNAS" ]; then 459 if [ -n "$ECVS_RUNAS" ]; then
247 chown `whoami` "${T}/cvspass" 460 chown `whoami` "${T}/cvspass"
248 fi 461 fi
249 462
250} 463}
267 ECVS_RUNAS=$ECVS_RUNAS 480 ECVS_RUNAS=$ECVS_RUNAS
268 ECVS_LOCALNAME=$ECVS_LOCALNAME" 481 ECVS_LOCALNAME=$ECVS_LOCALNAME"
269 482
270 [ -z "$ECVS_MODULE" ] && die "ERROR: CVS module not set, cannot continue." 483 [ -z "$ECVS_MODULE" ] && die "ERROR: CVS module not set, cannot continue."
271 484
272 # merely setting this default value makes things fail when cvs_src_unpack is called 485 local ECVS_LOCALNAME="${ECVS_LOCALNAME}"
273 # more than once per ebuild (eg kdenonbeta submodules); so if we set a default value, 486
274 # we disable it again at the function's end.
275 # of course, we could instead always reference it with the bash syntax for 'take default
276 # value from this other variable if undefined', but i'm lazy.
277 if [ -z "$ECVS_LOCALNAME" ]; then 487 if [ -z "$ECVS_LOCALNAME" ]; then
278 ECVS_LOCALNAME="$ECVS_MODULE" 488 ECVS_LOCALNAME="$ECVS_MODULE"
279 ECVS_LOCALNAME_SETDEFAULT=true
280 fi 489 fi
281
282 490
283 if [ "$ECVS_SERVER" == "offline" ]; then 491 if [ "$ECVS_SERVER" == "offline" ]; then
284 # we're not required to fetch anything, the module already exists and shouldn't be updated 492 # We're not required to fetch anything; the module already
493 # exists and shouldn't be updated.
285 if [ -d "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" ]; then 494 if [ -d "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" ]; then
286 debug-print "$FUNCNAME: offline mode" 495 debug-print "$FUNCNAME: offline mode"
287 else 496 else
288 debug-print "$FUNCNAME: offline mode specified but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found, exiting with error" 497 debug-print "$FUNCNAME: Offline mode specified but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found, exiting with error"
289 die "ERROR: Offline mode specified, but dir ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found. Aborting." 498 die "ERROR: Offline mode specified, but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found. Aborting."
290 fi 499 fi
291 elif [ -n "$ECVS_SERVER" ]; then # ECVS_SERVER!=offline --> real fetching mode 500 elif [ -n "$ECVS_SERVER" ]; then # ECVS_SERVER!=offline --> real fetching mode
292 einfo "Fetching cvs module $ECVS_MODULE into $ECVS_TOP_DIR..." 501 einfo "Fetching CVS module $ECVS_MODULE into $ECVS_TOP_DIR ..."
293 cvs_fetch 502 cvs_fetch
294 else # ECVS_SERVER not set 503 else # ECVS_SERVER not set
295 die "ERROR: CVS server not set, cannot continue." 504 die "ERROR: CVS server not specified, cannot continue."
296 fi 505 fi
297 506
298 einfo "Copying $ECVS_MODULE from $ECVS_TOP_DIR..." 507 einfo "Copying $ECVS_MODULE from $ECVS_TOP_DIR ..."
299 debug-print "Copying module $ECVS_MODULE local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..." 508 debug-print "Copying module $ECVS_MODULE local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR ..."
300 509
301 # probably redundant, but best to make sure 510 # This is probably redundant, but best to make sure.
302 mkdir -p "$WORKDIR/$ECVS_LOCALNAME" 511 mkdir -p "$WORKDIR/$ECVS_LOCALNAME"
303 512
304 if [ -n "$ECVS_LOCAL" ]; then 513 if [ -n "$ECVS_LOCAL" ]; then
305 cp -f "$ECVS_TOP_DIR/$ECVS_LOCALNAME"/* "$WORKDIR/$ECVS_LOCALNAME" 514 cp -f "$ECVS_TOP_DIR/$ECVS_LOCALNAME"/* "$WORKDIR/$ECVS_LOCALNAME"
306 else 515 else
307 cp -Rf "$ECVS_TOP_DIR/$ECVS_LOCALNAME" "$WORKDIR/$ECVS_LOCALNAME/.." 516 cp -Rf "$ECVS_TOP_DIR/$ECVS_LOCALNAME" "$WORKDIR/$ECVS_LOCALNAME/.."
308 fi 517 fi
309 518
310 # if the directory is empty, remove it; empty directories cannot exist in cvs. 519 # If the directory is empty, remove it; empty directories cannot
311 # this happens when fex. kde-source requests module/doc/subdir which doesn't exist. 520 # exist in cvs. This happens when, for example, kde-source
521 # requests module/doc/subdir which doesn't exist. Still create
312 # still create the empty directory in workdir though. 522 # the empty directory in workdir though.
313 if [ "`ls -A \"${ECVS_TOP_DIR}/${ECVS_LOCALNAME}\"`" == "CVS" ]; then 523 if [ "`ls -A \"${ECVS_TOP_DIR}/${ECVS_LOCALNAME}\"`" == "CVS" ]; then
314 debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_LOCALNAME" 524 debug-print "$FUNCNAME: removing empty CVS directory $ECVS_LOCALNAME"
315 rm -rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" 525 rm -rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}"
316 fi 526 fi
317 527
318 # implement some of base_src_unpack's functionality; 528 # Implement some of base_src_unpack's functionality; note however
319 # note however that base.eclass may not have been inherited! 529 # that base.eclass may not have been inherited!
320 if [ -n "$PATCHES" ]; then 530 if [ -n "$PATCHES" ]; then
321 debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching" 531 debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching"
322 cd "$S" 532 cd "$S"
323 for x in $PATCHES; do 533 epatch ${PATCHES}
324 debug-print "patching from $x"
325 patch -p0 < "$x"
326 done
327 # make sure we don't try to apply patches more than once, since 534 # Make sure we don't try to apply patches more than once,
328 # cvs_src_unpack is usually called several times from e.g. kde-source_src_unpack 535 # since cvs_src_unpack is usually called several times from
536 # e.g. kde-source_src_unpack
329 export PATCHES="" 537 export PATCHES=""
330 fi 538 fi
331
332 if [ -n "$ECVS_LOCALNAME_SETDEFAULT" ]; then
333 unset ECVS_LOCALNAME
334 unset ECVS_LOCALNAME_SETDEFAULT
335 fi
336 539
337 einfo "Module ${ECVS_MODULE} is now in ${WORKDIR}" 540 einfo "CVS module ${ECVS_MODULE} is now in ${WORKDIR}"
338
339} 541}
340 542
341EXPORT_FUNCTIONS src_unpack 543EXPORT_FUNCTIONS src_unpack

Legend:
Removed from v.1.49  
changed lines
  Added in v.1.61

  ViewVC Help
Powered by ViewVC 1.1.20