gentoo-x86/eclass/cvs.eclass

# Copyright 1999-2003 Gentoo Technologies, Inc.
# Distributed under the terms of the GNU General Public License v2
# $Header: /home/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.32 2003/02/21 14:07:46 phoenix Exp $
#
# Author Dan Armak <danarmak@gentoo.org>
#
# This eclass provides the generic cvs fetching functions.

ECLASS=cvs
INHERITED="$INHERITED $ECLASS"

# You shouldn't change these settings yourself! The ebuild/eclass inheriting this eclass
# will take care of that. If you want to set the global KDE cvs ebuilds' settings,
# see the comments in kde-source.eclass.

# --- begin ebuild-configurable settings

# cvs command to run. you can set fex. "cvs -t" for extensive debug information
# on the cvs onnection. the default of "cvs -q -f -z4" means to be quiet, to disregard
# the ~/.cvsrc config file and to use maximum compression.
[ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4"

# cvs options given after the command (i.e. cvs update foo)
# don't remove -dP or things won't work
[ -z "$ECVS_CVS_OPTIONS" ] && ECVS_CVS_OPTIONS="-dP"

# set this for the module/subdir to be fetched non-recursively
#[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"

# Where the cvs modules are stored/accessed
[ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src"

# Name of cvs server, set to "offline" to disable fetching
# (i.e. to assume module is checked out already and don't update it).
# Format is server:/dir e.g. "anoncvs.kde.org:/home/kde". remove the other
# parts of the full CVSROOT (which looks like
# ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from
# other settings
[ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline"

# Anonymous cvs login?
# if 'yes' uses :pserver: with empty password, if 'no' uses :ext: with $ECVS_PASS, other values not allowed
[ -z "$ECVS_ANON" ] && ECVS_ANON="yes"

# Authentication method to use on ECVS_ANON="no" - possible values are "pserver" and "ext"
[ -z "$ECVS_AUTH" ] && ECVS_AUTH="ext"

# Use su to run cvs as user
[ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`"

# Username to use
[ -z "$ECVS_USER" ] && ECVS_USER="anonymous"

# Password to use if anonymous login is off, or if 'anonymous' pserver access
# uses a password and ECVS_ANON = yes
[ -z "$ECVS_PASS" ] && ECVS_PASS=""

# Module to be fetched, must be set explicitly -
# I don't like the former ="$PN" default setting
[ -z "$ECVS_MODULE" ] && debug-print "$ECLASS: error: ECVS_MODULE not set, cannot continue"

# Branch/tag to use, default is HEAD
# uncomment the following line to enable the reset-branch-to-HEAD behaviour
[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"

# Subdirectory in module to be fetched, default is not defined = whole module
# DO NOT set default to "", if it's defined at all code will break!
# don't uncomment following line!
#[ -z "$ECVS_SUBDIR" ] && ECVS_SUBDIR=""

# --- end ebuild-configurable settings ---

# add cvs to deps
DEPEND="$DEPEND dev-util/cvs dev-python/pexpect"

# since we now longer have src_fetch as a redefinable ebuild function,
# we are forced to call this function from cvs_src_unpack
cvs_fetch() {

        debug-print-function $FUNCNAME $*

        debug-print "$FUNCNAME: init:
9ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND
ECVS_CVS_OPTIONS=$ECVS_CVS_OPTIONS
ECVS_TOP_DIR=$ECVS_TOP_DIR
ECVS_SERVER=$ECVS_SERVER
ECVS_ANON=$ECVS_ANON
ECVS_USER=$ECVS_USER
ECVS_PASS=$ECVS_PASS
ECS_MODULE=$ECVS_MODULE
ECVS_SUBDIR=$ECVS_SUBDIR
ECVS_LOCAL=$ECVS_LOCAL
DIR=$DIR"

        # a shorthand
        DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
        debug-print "$FUNCNAME: now DIR=$DIR"

        if [ "$ECVS_SERVER" == "offline" ]; then
                # we're not required to fetch anything, the module already exists and shouldn't be updated
                if [ -d "$DIR" ]; then
                        debug-print "$FUNCNAME: offline mode, exiting"
                        return 0
                else
                        einfo "ERROR: Offline mode specified, but module/subdir not found. Aborting."
                        debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error"
                        return 1
                fi
        fi

        # create target directory as needed
        if [ ! -d "$DIR" ]; then
                debug-print "$FUNCNAME: creating cvs directory $DIR"
                #export SANDBOX_WRITE="$SANDBOX_WRITE:/foobar:/"
                addwrite /foobar
                addwrite /
                mkdir -p "/$DIR"
                export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}"
        fi

        # in case ECVS_TOP_DIR is a symlink to a dir, get the real dir's path,
        # otherwise addwrite() doesn't work.
        cd -P "$ECVS_TOP_DIR" > /dev/null
        ECVS_TOP_DIR="`/bin/pwd`"
        DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
        cd "$OLDPWD"
        
        debug-print "$FUNCNAME: now DIR=$DIR"
        
        # disable the sandbox for this dir
        # not just $DIR because we want to create moduletopdir/CVS too
        addwrite "$ECVS_TOP_DIR/$ECVS_MODULE"

        # add option for local (non-recursive) fetching
        [ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"
        
        # prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass
        touch "${T}/cvspass"
        export CVS_PASSFILE="${T}/cvspass"
        chown $ECVS_RUNAS "${T}/cvspass"

        # Note: cvs update and checkout commands are unified.
        # we make sure a CVS/ dir exists in our module subdir with the right
        # Root and Repository entries in it and cvs update.
        
        [ "${ECVS_ANON}" == "yes" ] && \
                newserver=":pserver:${ECVS_USER}@${ECVS_SERVER}" || \
                newserver=":${ECVS_AUTH}:${ECVS_USER}@${ECVS_SERVER}" 
                
        
        # CVS/Repository files can't (I think) contain two concatenated slashes
        if [ -n "$ECVS_SUBDIR" ]; then
                repository="${ECVS_MODULE}/${ECVS_SUBDIR}"
        else
                repository="${ECVS_MODULE}"
        fi
        
        debug-print "$FUNCNAME: Root<-$newserver, Repository<-$repository"
        debug-print "$FUNCNAME: entering directory $DIR"
        cd "/$DIR"
        
        if [ ! -d "CVS" ]; then
                # create a new CVS/ directory (checkout)
                debug-print "$FUNCNAME: creating new cvs directory"
                
                mkdir CVS
                echo $newserver > CVS/Root
                echo $repository > CVS/Repository
                touch CVS/Entries
                
                # if we're checking out a subdirectory only, create a CVS/ dir
                # in the module's top dir so that the user (and we) can cvs update
                # from there to get the full module.
                if [ ! -d "$ECVS_TOP_DIR/$ECVS_MODULE/CVS" ]; then
                        debug-print "$FUNCNAME: Copying CVS/ directory to module top-level dir"
                        cp -r CVS "$ECVS_TOP_DIR/$ECVS_MODULE/"
                        echo $ECVS_MODULE > "$ECVS_TOP_DIR/$ECVS_MODULE/CVS/Repository"
                fi
                
        else
                #update existing module
                debug-print "$FUNCNAME: updating existing module/subdir"
                
                # Switch servers if needed
                # cvs keeps the server info in the CVS/Root file in every checked-out dir;
                # we can fix those files to point to the new server
                oldserver="`cat CVS/Root`"
                if [ "$newserver" != "$oldserver" ]; then

                        einfo "Changing CVS server from $oldserver to $newserver:"
                        debug-print "$FUNCNAME: Changing CVS server from $oldserver to $newserver:"

                        einfo "Searching for CVS dirs..."
                        cvsdirs="`find . -iname CVS -print`"
                        debug-print "$FUNCNAME: CVS dirs found:"
                        debug-print "$cvsdirs"

                        einfo "Modifying CVS dirs..."
                        for x in $cvsdirs; do
                                debug-print "In $x"
                                echo $newserver > "$x/Root"
                        done

                fi

        fi

        # cvs auto-switches branches, how nice
        # warning: if we do it this way we get multiple -rX options - harmless i think
        [ -n "$ECVS_BRANCH" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -r$ECVS_BRANCH"

        # Chowning the directory
        if [ "${ECVS_RUNAS}" != "`whoami`" ]; then
                chown -R "$ECVS_RUNAS" "/$DIR"
        fi

        # finally run the cvs update command
        debug-print "$FUNCNAME: is in dir `/bin/pwd`"
        debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for module $ECVS_MODULE subdir $ECVS_SUBDIR"
        einfo "Running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS with $ECVS_SERVER for $ECVS_MODULE/$ECVS_SUBDIR..."

        if [ "${ECVS_ANON}" == "no" ]; then
        
                debug-print "$FUNCNAME: starting non-anonymous cvs login..."
                # CVS Login - written in python :: the right way ;)
                # Tilman Klar, <phoenix@gentoo.org>

                export CVS_RSH="/usr/bin/ssh"

############################## inline-python #####################################
/usr/bin/env python << EndOfFile

import pexpect,os

mypasswd  = "${ECVS_PASS}"
myauth    = "${ECVS_AUTH}"
mytimeout = 10

if "${ECVS_RUNAS}" == "`whoami`":
    mycommand = "${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}"
else:
    mycommand = "su ${ECVS_RUNAS} -c \"${ECVS_CVS_COMMAND} update ${ECVS_CVS_OPTIONS}\""

if myauth == "ext":
        child = pexpect.spawn(mycommand)

        index = child.expect(['continue connecting','word:'], mytimeout)
        if index == 0:
                child.sendline('yes')
                ## Added server to ~/.ssh/known_hosts
                child.expect('word:', mytimeout)
        else:
                ## Server already is in ~/.ssh/known_hosts
                pass

        child.sendline(mypasswd)
        child.expect(pexpect.EOF)       

elif myauth == "pserver":
        if "${ECVS_RUNAS}" == "`whoami`":
                mycommand2 = "cvs login"
        else:
                mycommand2 = "su ${ECVS_RUNAS} -c \"cvs login\""
        child = pexpect.spawn(mycommand2)
        child.expect("CVS password:",mytimeout)
        child.sendline(mypasswd)
        child.expect(pexpect.EOF)

        # Logged in - checking out
        os.system(mycommand)
        
EndOfFile
########################### End of inline-python ##################################
        else
                # is anonymous cvs.
                # is there a password to use for login with this "anonymous" login
                if [ -n "$ECVS_PASS" ]; then
                        debug-print "$FUNCNAME: using anonymous cvs login with password"

# inline-python #
/usr/bin/env python << EndOfFile

import pexpect,os

myuser    = "${ECVS_USER}"
mypasswd  = "${ECVS_PASS}"

mytimeout = 10

# implicitly myauth == "pserver" here.
mycommand = "cvs login"
child = pexpect.spawn(mycommand)
child.expect("CVS password:",mytimeout)
child.sendline(mypasswd)
child.expect(pexpect.EOF)
EndOfFile
# End of inline-python #

                else
                    debug-print "$FUNCNAME: using anonymous cvs login (without password)"
                    # passwordless, truly anonymous login; or login with empty (but existing)
                    # password.
                    # make cvs think we're logged in at the cvs server,
                    # because i don't trust myself to write the right code for the case
                    # where the password is empty but still required (what's the bash test
                    # to see if a variable is defined? -n returns false if it is defined
                    # but empty...)
                    echo ":pserver:${ECVS_SERVER} A" > "${T}/cvspass"
                    # remember we did this so we don't try to run cvs logout later
                    DONT_LOGOUT=yes
                fi

                debug-print "$FUNCNAME: running $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS"
                $ECVS_CVS_COMMAND update $ECVS_CVS_OPTIONS || die "died running cvs update"

        fi

        # log out and restore ownership as needed
        if [ -z "$DONT_LOGOUT" ]; then
            debug-print "$FUNCNAME: cvs logout stuff"
            if [ "$ECVS_RUNAS" == "`whoami`" ]; then
                cvs logout &> /dev/null
            else
                su $ECVS_RUNAS -c "cvs logout" &> /dev/null
            fi
        fi
        chown `whoami` "${T}/cvspass"
}

cvs_src_unpack() {

        debug-print-function $FUNCNAME $*
        cvs_fetch || die "died running cvs_fetch"

        einfo "Copying $ECVS_MODULE/$ECVS_SUBDIR from $ECVS_TOP_DIR..."
        debug-print "Copying module $ECVS_MODULE subdir $ECVS_SUBDIR local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..."
        
        # probably redundant, but best to make sure
        mkdir -p "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
        
        if [ -n "$ECVS_SUBDIR" ]; then
                if [ -n "$ECVS_LOCAL" ]; then
                        cp -f "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR"/* "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
                else
                        cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR" "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR/.."
                fi    
        else
                if [ -n "$ECVS_LOCAL" ]; then
                        cp -f "$ECVS_TOP_DIR/$ECVS_MODULE"/* $WORKDIR/$ECVS_MODULE
                else
                        cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR"
                fi
        fi
        
        # if the directory is empty, remove it; empty directories cannot exist in cvs.
        # this happens when fex. kde-source requests module/doc/subdir which doesn't exist.
        # still create the empty directory in workdir though.
        if [ "`ls -A \"$DIR\"`" == "CVS" ]; then
                debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE/$ECVS_SUBDIR"
                rm -rf "$DIR"
        fi
            
        # implement some of base_src_unpack's functionality;
        # note however that base.eclass may not have been inherited!
        if [ -n "$PATCHES" ]; then
                debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching"
                cd "$S"
                for x in $PATCHES; do
                        debug-print "patching from $x"
                        patch -p0 < "$x"
                done
                # make sure we don't try to apply patches more than once, since
                # cvs_src_unpack is usually called several times from e.g. kde-source_src_unpack
                export PATCHES=""
        fi

}

EXPORT_FUNCTIONS src_unpack
1	# Copyright 1999-2003 Gentoo Technologies, Inc.
2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /home/cvsroot/gentoo-x86/eclass/cvs.eclass,v 1.32 2003/02/21 14:07:46 phoenix Exp $
4	#
5	# Author Dan Armak <danarmak@gentoo.org>
6	#
7	# This eclass provides the generic cvs fetching functions.
8
9	ECLASS=cvs
10	INHERITED="$INHERITED $ECLASS"
11
12	# You shouldn't change these settings yourself! The ebuild/eclass inheriting this eclass
13	# will take care of that. If you want to set the global KDE cvs ebuilds' settings,
14	# see the comments in kde-source.eclass.
15
16	# --- begin ebuild-configurable settings
17
18	# 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
20	# the ~/.cvsrc config file and to use maximum compression.
21	[ -z "$ECVS_CVS_COMMAND" ] && ECVS_CVS_COMMAND="cvs -q -f -z4"
22
23	# cvs options given after the command (i.e. cvs update foo)
24	# don't remove -dP or things won't work
25	[ -z "$ECVS_CVS_OPTIONS" ] && ECVS_CVS_OPTIONS="-dP"
26
27	# set this for the module/subdir to be fetched non-recursively
28	#[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"
29
30	# Where the cvs modules are stored/accessed
31	[ -z "$ECVS_TOP_DIR" ] && ECVS_TOP_DIR="${DISTDIR}/cvs-src"
32
33	# 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).
35	# Format is server:/dir e.g. "anoncvs.kde.org:/home/kde". remove the other
36	# parts of the full CVSROOT (which looks like
37	# ":pserver:anonymous@anoncvs.kde.org:/home/kde"); these are added from
38	# other settings
39	[ -z "$ECVS_SERVER" ] && ECVS_SERVER="offline"
40
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"
46	[ -z "$ECVS_AUTH" ] && ECVS_AUTH="ext"
47
48	# Use su to run cvs as user
49	[ -z "$ECVS_RUNAS" ] && ECVS_RUNAS="`whoami`"
50
51	# Username to use
52	[ -z "$ECVS_USER" ] && ECVS_USER="anonymous"
53
54	# Password to use if anonymous login is off, or if 'anonymous' pserver access
55	# uses a password and ECVS_ANON = yes
56	[ -z "$ECVS_PASS" ] && ECVS_PASS=""
57
58	# Module to be fetched, must be set explicitly -
59	# I don't like the former ="$PN" default setting
60	[ -z "$ECVS_MODULE" ] && debug-print "$ECLASS: error: ECVS_MODULE not set, cannot continue"
61
62	# Branch/tag to use, default is HEAD
63	# uncomment the following line to enable the reset-branch-to-HEAD behaviour
64	[ -z "$ECVS_BRANCH" ] && ECVS_BRANCH="HEAD"
65
66	# Subdirectory in module to be fetched, default is not defined = whole module
67	# DO NOT set default to "", if it's defined at all code will break!
68	# don't uncomment following line!
69	#[ -z "$ECVS_SUBDIR" ] && ECVS_SUBDIR=""
70
71	# --- end ebuild-configurable settings ---
72
73	# add cvs to deps
74	DEPEND="$DEPEND dev-util/cvs dev-python/pexpect"
75
76	# since we now longer have src_fetch as a redefinable ebuild function,
77	# we are forced to call this function from cvs_src_unpack
78	cvs_fetch() {
79
80	debug-print-function $FUNCNAME $*
81
82	debug-print "$FUNCNAME: init:
83	9ECVS_CVS_COMMAND=$ECVS_CVS_COMMAND
84	ECVS_CVS_OPTIONS=$ECVS_CVS_OPTIONS
85	ECVS_TOP_DIR=$ECVS_TOP_DIR
86	ECVS_SERVER=$ECVS_SERVER
87	ECVS_ANON=$ECVS_ANON
88	ECVS_USER=$ECVS_USER
89	ECVS_PASS=$ECVS_PASS
90	ECS_MODULE=$ECVS_MODULE
91	ECVS_SUBDIR=$ECVS_SUBDIR
92	ECVS_LOCAL=$ECVS_LOCAL
93	DIR=$DIR"
94
95	# a shorthand
96	DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
97	debug-print "$FUNCNAME: now DIR=$DIR"
98
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
105	einfo "ERROR: Offline mode specified, but module/subdir not found. Aborting."
106	debug-print "$FUNCNAME: offline mode specified but module/subdir not found, exiting with error"
107	return 1
108	fi
109	fi
110
111	# create target directory as needed
112	if [ ! -d "$DIR" ]; then
113	debug-print "$FUNCNAME: creating cvs directory $DIR"
114	#export SANDBOX_WRITE="$SANDBOX_WRITE:/foobar:/"
115	addwrite /foobar
116	addwrite /
117	mkdir -p "/$DIR"
118	export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}"
119	fi
120
121	# in case ECVS_TOP_DIR is a symlink to a dir, get the real dir's path,
122	# otherwise addwrite() doesn't work.
123	cd -P "$ECVS_TOP_DIR" > /dev/null
124	ECVS_TOP_DIR="`/bin/pwd`"
125	DIR="${ECVS_TOP_DIR}/${ECVS_MODULE}/${ECVS_SUBDIR}"
126	cd "$OLDPWD"
127
128	debug-print "$FUNCNAME: now DIR=$DIR"
129
130	# disable the sandbox for this dir
131	# not just $DIR because we want to create moduletopdir/CVS too
132	addwrite "$ECVS_TOP_DIR/$ECVS_MODULE"
133
134	# add option for local (non-recursive) fetching
135	[ -n "$ECVS_LOCAL" ] && ECVS_CVS_OPTIONS="$ECVS_CVS_OPTIONS -l"
136
137	# prepare a cvspass file just for this session, we don't want to mess with ~/.cvspass
138	touch "${T}/cvspass"
139	export CVS_PASSFILE="${T}/cvspass"
140	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
157
158	debug-print "$FUNCNAME: Root<-$newserver, Repository<-$repository"
159	debug-print "$FUNCNAME: entering directory $DIR"
160	cd "/$DIR"
161
162	if [ ! -d "CVS" ]; then
163	# create a new CVS/ directory (checkout)
164	debug-print "$FUNCNAME: creating new cvs directory"
165
166	mkdir CVS
167	echo $newserver > CVS/Root
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
179
180	else
181	#update existing module
182	debug-print "$FUNCNAME: updating existing module/subdir"
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
205
206	fi
207
208	# cvs auto-switches branches, how nice
209	# warning: if we do it this way we get multiple -rX options - harmless i think
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
312
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..."
336	debug-print "Copying module $ECVS_MODULE subdir $ECVS_SUBDIR local_mode=$ECVS_LOCAL from $ECVS_TOP_DIR..."
337
338	# probably redundant, but best to make sure
339	mkdir -p "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
340
341	if [ -n "$ECVS_SUBDIR" ]; then
342	if [ -n "$ECVS_LOCAL" ]; then
343	cp -f "$ECVS_TOP_DIR/$ECVS_MODULE/$ECVS_SUBDIR"/* "$WORKDIR/$ECVS_MODULE/$ECVS_SUBDIR"
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
350	else
351	cp -Rf "$ECVS_TOP_DIR/$ECVS_MODULE" "$WORKDIR"
352	fi
353	fi
354
355	# 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.
357	# still create the empty directory in workdir though.
358	if [ "`ls -A \"$DIR\"`" == "CVS" ]; then
359	debug-print "$FUNCNAME: removing cvs-empty directory $ECVS_MODULE/$ECVS_SUBDIR"
360	rm -rf "$DIR"
361	fi
362
363	# implement some of base_src_unpack's functionality;
364	# note however that base.eclass may not have been inherited!
365	if [ -n "$PATCHES" ]; then
366	debug-print "$FUNCNAME: PATCHES=$PATCHES, S=$S, autopatching"
367	cd "$S"
368	for x in $PATCHES; do
369	debug-print "patching from $x"
370	patch -p0 < "$x"
371	done
372	# make sure we don't try to apply patches more than once, since
373	# cvs_src_unpack is usually called several times from e.g. kde-source_src_unpack
374	export PATCHES=""
375	fi
376
377	}
378
379	EXPORT_FUNCTIONS src_unpack