diff options
Diffstat (limited to 'eclass/cvs.eclass')
| -rw-r--r-- | eclass/cvs.eclass | 583 |
1 files changed, 583 insertions, 0 deletions
diff --git a/eclass/cvs.eclass b/eclass/cvs.eclass new file mode 100644 index 000000000000..b9c8a818b6ca --- /dev/null +++ b/eclass/cvs.eclass @@ -0,0 +1,583 @@ +# Copyright 1999-2014 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Id$ + +# @ECLASS: cvs.eclass +# @MAINTAINER: +# vapier@gentoo.org (and anyone who wants to help) +# @BLURB: This eclass provides generic cvs fetching functions +# @DESCRIPTION: +# This eclass provides the generic cvs fetching functions. To use this from an +# ebuild, set the ECLASS VARIABLES as specified below in your ebuild before +# inheriting. Then either leave the default src_unpack or extend over +# cvs_src_unpack. If you find that you need to call the cvs_* functions +# directly, I'd be interested to hear about it. + +if [[ -z ${_CVS_ECLASS} ]]; then +_CVS_ECLASS=1 + +inherit eutils + +# TODO: + +# Implement more auth types (gserver?, kserver?) + +# Support additional remote shells with `ext' authentication (does +# anyone actually need to use it with anything other than SSH?) + + +# Users shouldn't change these settings! 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. + +# @ECLASS-VARIABLE: ECVS_CVS_COMPRESS +# @DESCRIPTION: +# Set the default compression level. Has no effect when ECVS_CVS_COMMAND +# is defined by ebuild/user. +: ${ECVS_CVS_COMPRESS:=-z1} + +# @ECLASS-VARIABLE: ECVS_CVS_OPTIONS +# @DESCRIPTION: +# Additional options to the cvs commands. Has no effect when ECVS_CVS_COMMAND +# is defined by ebuild/user. +: ${ECVS_CVS_OPTIONS:=-q -f} + +# @ECLASS-VARIABLE: ECVS_CVS_COMMAND +# @DESCRIPTION: +# CVS command to run +# +# You can set, for example, "cvs -t" for extensive debug information +# on the cvs connection. The default of "cvs -q -f -z4" means to be +# quiet, to disregard the ~/.cvsrc config file and to use maximum +# compression. +: ${ECVS_CVS_COMMAND:=cvs ${ECVS_CVS_OPTIONS} ${ECVS_CVS_COMPRESS}} + +# @ECLASS-VARIABLE: ECVS_UP_OPTS +# @DESCRIPTION: +# CVS options given after the cvs update command. Don't remove "-dP" or things +# won't work. +: ${ECVS_UP_OPTS:=-dP} + +# @ECLASS-VARIABLE: ECVS_CO_OPTS +# @DEFAULT_UNSET +# @DESCRIPTION: +# CVS options given after the cvs checkout command. + +# @ECLASS-VARIABLE: ECVS_OFFLINE +# @DESCRIPTION: +# Set this variable to a non-empty value to disable the automatic updating of +# a CVS source tree. This is intended to be set outside the cvs source +# tree by users. +: ${ECVS_OFFLINE:=${EVCS_OFFLINE}} + +# @ECLASS-VARIABLE: ECVS_LOCAL +# @DEFAULT_UNSET +# @DESCRIPTION: +# If this is set, the CVS module will be fetched non-recursively. +# Refer to the information in the CVS man page regarding the -l +# command option (not the -l global option). + +# @ECLASS-VARIABLE: ECVS_LOCALNAME +# @DEFAULT_UNSET +# @DESCRIPTION: +# Local name of checkout directory +# +# This is useful if the module on the server is called something +# common like 'driver' or is nested deep in a tree, and you don't like +# useless empty directories. +# +# WARNING: Set this only from within ebuilds! If set in your shell or +# some such, things will break because the ebuild won't expect it and +# have e.g. a wrong $S setting. + +# @ECLASS-VARIABLE: ECVS_TOP_DIR +# @DESCRIPTION: +# The directory under which CVS modules are checked out. +: ${ECVS_TOP_DIR:="${PORTAGE_ACTUAL_DISTDIR-${DISTDIR}}/cvs-src"} + +# @ECLASS-VARIABLE: ECVS_SERVER +# @DESCRIPTION: +# CVS path +# +# The format is "server:/dir", e.g. "anoncvs.kde.org:/home/kde". +# Remove the other parts of the full CVSROOT, which might look like +# ":pserver:anonymous@anoncvs.kde.org:/home/kde"; this is generated +# using other settings also. +# +# Set this to "offline" to disable fetching (i.e. to assume the module +# is already checked out in ECVS_TOP_DIR). +: ${ECVS_SERVER:="offline"} + +# @ECLASS-VARIABLE: ECVS_MODULE +# @REQUIRED +# @DESCRIPTION: +# The name of the CVS module to be fetched +# +# This must be set when cvs_src_unpack is called. This can include +# several directory levels, i.e. "foo/bar/baz" +#[[ -z ${ECVS_MODULE} ]] && die "$ECLASS: error: ECVS_MODULE not set, cannot continue" + +# @ECLASS-VARIABLE: ECVS_DATE +# @DEFAULT_UNSET +# @DESCRIPTION: +# The date of the checkout. See the -D date_spec option in the cvs +# man page for more details. + +# @ECLASS-VARIABLE: ECVS_BRANCH +# @DEFAULT_UNSET +# @DESCRIPTION: +# The name of the branch/tag to use +# +# The default is "HEAD". The following default _will_ reset your +# branch checkout to head if used. +#: ${ECVS_BRANCH:="HEAD"} + +# @ECLASS-VARIABLE: ECVS_AUTH +# @DESCRIPTION: +# Authentication method to use +# +# Possible values are "pserver" and "ext". If `ext' authentication is +# used, the remote shell to use can be specified in CVS_RSH (SSH is +# used by default). Currently, the only supported remote shell for +# `ext' authentication is SSH. +# +# Armando Di Cianno <fafhrd@gentoo.org> 2004/09/27 +# - Added "no" as a server type, which uses no AUTH method, nor +# does it login +# e.g. +# "cvs -danoncvs@savannah.gnu.org:/cvsroot/backbone co System" +# ( from gnustep-apps/textedit ) +: ${ECVS_AUTH:="pserver"} + +# @ECLASS-VARIABLE: ECVS_USER +# @DESCRIPTION: +# Username to use for authentication on the remote server. +: ${ECVS_USER:="anonymous"} + +# @ECLASS-VARIABLE: ECVS_PASS +# @DEFAULT_UNSET +# @DESCRIPTION: +# Password to use for authentication on the remote server + +# @ECLASS-VARIABLE: ECVS_SSH_HOST_KEY +# @DEFAULT_UNSET +# @DESCRIPTION: +# If SSH is used for `ext' authentication, use this variable to +# specify the host key of the remote server. The format of the value +# should be the same format that is used for the SSH known hosts file. +# +# WARNING: If a SSH host key is not specified using this variable, the +# remote host key will not be verified. + +# @ECLASS-VARIABLE: ECVS_CLEAN +# @DEFAULT_UNSET +# @DESCRIPTION: +# Set this to get a clean copy when updating (passes the +# -C option to cvs update) + +# @ECLASS-VARIABLE: ECVS_RUNAS +# @DEFAULT_UNSET +# @DESCRIPTION: +# Specifies an alternate (non-root) user to use to run cvs. Currently +# b0rked and wouldn't work with portage userpriv anyway without +# special magic. + +# : ${ECVS_RUNAS:=$(whoami)} + +# add cvs to deps +# ssh is used for ext auth +# sudo is used to run as a specified user +DEPEND="dev-vcs/cvs" + +[[ -n ${ECVS_RUNAS} ]] && DEPEND+=" app-admin/sudo" + +if [[ ${ECVS_AUTH} == "ext" ]] ; then + #default to ssh + [[ -z ${CVS_RSH} ]] && export CVS_RSH="ssh" + if [[ ${CVS_RSH} != "ssh" ]] ; then + die "Support for ext auth with clients other than ssh has not been implemented yet" + fi + DEPEND+=" net-misc/openssh" +fi + +# called from cvs_src_unpack +cvs_fetch() { + has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX= + + # Make these options local variables so that the global values are + # not affected by modifications in this function. + + local ECVS_COMMAND=${ECVS_COMMAND} + local ECVS_UP_OPTS=${ECVS_UP_OPTS} + local ECVS_CO_OPTS=${ECVS_CO_OPTS} + + debug-print-function ${FUNCNAME} "$@" + + # Update variables that are modified by ebuild parameters, which + # should be effective every time cvs_fetch is called, and not just + # every time cvs.eclass is inherited + + # Handle parameter for local (non-recursive) fetching + + if [[ -n ${ECVS_LOCAL} ]] ; then + ECVS_UP_OPTS+=" -l" + ECVS_CO_OPTS+=" -l" + fi + + # Handle ECVS_BRANCH option + # + # Because CVS auto-switches branches, we just have to pass the + # correct -rBRANCH option when updating. + + if [[ -n ${ECVS_BRANCH} ]] ; then + ECVS_UP_OPTS+=" -r${ECVS_BRANCH}" + ECVS_CO_OPTS+=" -r${ECVS_BRANCH}" + fi + + # Handle ECVS_LOCALNAME, which specifies the local directory name + # to use. Note that the -d command option is not equivalent to + # the global -d option. + + if [[ ${ECVS_LOCALNAME} != "${ECVS_MODULE}" ]] ; then + ECVS_CO_OPTS+=" -d ${ECVS_LOCALNAME}" + fi + + if [[ -n ${ECVS_CLEAN} ]] ; then + ECVS_UP_OPTS+=" -C" + fi + + if [[ -n ${ECVS_DATE} ]] ; then + ECVS_CO_OPTS+=" -D ${ECVS_DATE}" + ECVS_UP_OPTS+=" -D ${ECVS_DATE}" + fi + + # It would be easiest to always be in "run-as mode", logic-wise, + # if sudo didn't ask for a password even when sudo'ing to `whoami`. + + if [[ -z ${ECVS_RUNAS} ]] ; then + run="" + else + run="sudo -u ${ECVS_RUNAS}" + fi + + # Create the top dir if needed + + if [[ ! -d ${ECVS_TOP_DIR} ]] ; then + # Note that the addwrite statements in this block are only + # there to allow creating ECVS_TOP_DIR; we allow writing + # inside it separately. + + # This is because it's simpler than trying to find out the + # parent path of the directory, which would need to be the + # real path and not a symlink for things to work (so we can't + # just remove the last path element in the string) + + debug-print "${FUNCNAME}: checkout mode. creating cvs directory" + addwrite /foobar + addwrite / + ${run} mkdir -p "/${ECVS_TOP_DIR}" + export SANDBOX_WRITE="${SANDBOX_WRITE//:\/foobar:\/}" + fi + + # In case ECVS_TOP_DIR is a symlink to a dir, get the real path, + # otherwise addwrite() doesn't work. + + cd -P "${ECVS_TOP_DIR}" >/dev/null + ECVS_TOP_DIR=$(pwd) + + # Disable the sandbox for this dir + addwrite "${ECVS_TOP_DIR}" + + # Chown the directory and all of its contents + if [[ -n ${ECVS_RUNAS} ]] ; then + ${run} chown -R "${ECVS_RUNAS}" "/${ECVS_TOP_DIR}" + fi + + # Determine the CVS command mode (checkout or update) + if [[ ! -d ${ECVS_TOP_DIR}/${ECVS_LOCALNAME}/CVS ]] ; then + mode=checkout + else + mode=update + fi + + # Our server string (i.e. CVSROOT) without the password so it can + # be put in Root + local connection="${ECVS_AUTH}" + if [[ ${ECVS_AUTH} == "no" ]] ; then + local server="${ECVS_USER}@${ECVS_SERVER}" + else + [[ -n ${ECVS_PROXY} ]] && connection+=";proxy=${ECVS_PROXY}" + [[ -n ${ECVS_PROXY_PORT} ]] && connection+=";proxyport=${ECVS_PROXY_PORT}" + local server=":${connection}:${ECVS_USER}@${ECVS_SERVER}" + fi + + # Switch servers automagically if needed + if [[ ${mode} == "update" ]] ; then + cd "/${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" + local oldserver=$(${run} cat CVS/Root) + if [[ ${server} != "${oldserver}" ]] ; then + einfo "Changing the CVS server from ${oldserver} to ${server}:" + debug-print "${FUNCNAME}: Changing the CVS server from ${oldserver} to ${server}:" + + einfo "Searching for CVS directories ..." + local cvsdirs=$(${run} find . -iname CVS -print) + debug-print "${FUNCNAME}: CVS directories found:" + debug-print "${cvsdirs}" + + einfo "Modifying CVS directories ..." + local x + for x in ${cvsdirs} ; do + debug-print "In ${x}" + ${run} echo "${server}" > "${x}/Root" + done + fi + fi + + # Prepare a cvspass file just for this session, we don't want to + # mess with ~/.cvspass + touch "${T}/cvspass" + export CVS_PASSFILE="${T}/cvspass" + if [[ -n ${ECVS_RUNAS} ]] ; then + chown "${ECVS_RUNAS}" "${T}/cvspass" + fi + + # The server string with the password in it, for login (only used for pserver) + cvsroot_pass=":${connection}:${ECVS_USER}:${ECVS_PASS}@${ECVS_SERVER}" + + # Ditto without the password, for checkout/update after login, so + # that the CVS/Root files don't contain the password in plaintext + if [[ ${ECVS_AUTH} == "no" ]] ; then + cvsroot_nopass="${ECVS_USER}@${ECVS_SERVER}" + else + cvsroot_nopass=":${connection}:${ECVS_USER}@${ECVS_SERVER}" + fi + + # Commands to run + cmdlogin="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_pass}\" login" + cmdupdate="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" update ${ECVS_UP_OPTS} ${ECVS_LOCALNAME}" + cmdcheckout="${run} ${ECVS_CVS_COMMAND} -d \"${cvsroot_nopass}\" checkout ${ECVS_CO_OPTS} ${ECVS_MODULE}" + + # Execute commands + + cd "${ECVS_TOP_DIR}" + if [[ ${ECVS_AUTH} == "pserver" ]] ; then + einfo "Running ${cmdlogin}" + eval ${cmdlogin} || die "cvs login command failed" + if [[ ${mode} == "update" ]] ; then + einfo "Running ${cmdupdate}" + eval ${cmdupdate} || die "cvs update command failed" + elif [[ ${mode} == "checkout" ]] ; then + einfo "Running ${cmdcheckout}" + eval ${cmdcheckout} || die "cvs checkout command failed" + fi + elif [[ ${ECVS_AUTH} == "ext" || ${ECVS_AUTH} == "no" ]] ; then + # Hack to support SSH password authentication + + # Backup environment variable values + local CVS_ECLASS_ORIG_CVS_RSH="${CVS_RSH}" + + if [[ ${SSH_ASKPASS+set} == "set" ]] ; then + local CVS_ECLASS_ORIG_SSH_ASKPASS="${SSH_ASKPASS}" + else + unset CVS_ECLASS_ORIG_SSH_ASKPASS + fi + + if [[ ${DISPLAY+set} == "set" ]] ; then + local CVS_ECLASS_ORIG_DISPLAY="${DISPLAY}" + else + unset CVS_ECLASS_ORIG_DISPLAY + fi + + if [[ ${CVS_RSH} == "ssh" ]] ; then + # Force SSH to use SSH_ASKPASS by creating python wrapper + + export CVS_RSH="${T}/cvs_sshwrapper" + cat > "${CVS_RSH}"<<EOF +#!${EPREFIX}/usr/bin/python +import fcntl +import os +import sys +try: + fd = os.open('/dev/tty', 2) + TIOCNOTTY=0x5422 + try: + fcntl.ioctl(fd, TIOCNOTTY) + except: + pass + os.close(fd) +except: + pass +newarglist = sys.argv[:] +EOF + + # disable X11 forwarding which causes .xauth access violations + # - 20041205 Armando Di Cianno <fafhrd@gentoo.org> + echo "newarglist.insert(1, '-oClearAllForwardings=yes')" \ + >> "${CVS_RSH}" + echo "newarglist.insert(1, '-oForwardX11=no')" \ + >> "${CVS_RSH}" + + # Handle SSH host key checking + + local CVS_ECLASS_KNOWN_HOSTS="${T}/cvs_ssh_known_hosts" + echo "newarglist.insert(1, '-oUserKnownHostsFile=${CVS_ECLASS_KNOWN_HOSTS}')" \ + >> "${CVS_RSH}" + + if [[ -z ${ECVS_SSH_HOST_KEY} ]] ; then + ewarn "Warning: The SSH host key of the remote server will not be verified." + einfo "A temporary known hosts list will be used." + local CVS_ECLASS_STRICT_HOST_CHECKING="no" + touch "${CVS_ECLASS_KNOWN_HOSTS}" + else + local CVS_ECLASS_STRICT_HOST_CHECKING="yes" + echo "${ECVS_SSH_HOST_KEY}" > "${CVS_ECLASS_KNOWN_HOSTS}" + fi + + echo -n "newarglist.insert(1, '-oStrictHostKeyChecking=" \ + >> "${CVS_RSH}" + echo "${CVS_ECLASS_STRICT_HOST_CHECKING}')" \ + >> "${CVS_RSH}" + echo "os.execv('${EPREFIX}/usr/bin/ssh', newarglist)" \ + >> "${CVS_RSH}" + + chmod a+x "${CVS_RSH}" + + # Make sure DISPLAY is set (SSH will not use SSH_ASKPASS + # if DISPLAY is not set) + + : ${DISPLAY:="DISPLAY"} + export DISPLAY + + # Create a dummy executable to echo ${ECVS_PASS} + + export SSH_ASKPASS="${T}/cvs_sshechopass" + if [[ ${ECVS_AUTH} != "no" ]] ; then + echo -en "#!/bin/bash\necho \"${ECVS_PASS}\"\n" \ + > "${SSH_ASKPASS}" + else + echo -en "#!/bin/bash\nreturn\n" \ + > "${SSH_ASKPASS}" + fi + chmod a+x "${SSH_ASKPASS}" + fi + + if [[ ${mode} == "update" ]] ; then + einfo "Running ${cmdupdate}" + eval ${cmdupdate} || die "cvs update command failed" + elif [[ ${mode} == "checkout" ]] ; then + einfo "Running ${cmdcheckout}" + eval ${cmdcheckout} || die "cvs checkout command failed" + fi + + # Restore environment variable values + export CVS_RSH="${CVS_ECLASS_ORIG_CVS_RSH}" + if [[ ${CVS_ECLASS_ORIG_SSH_ASKPASS+set} == "set" ]] ; then + export SSH_ASKPASS="${CVS_ECLASS_ORIG_SSH_ASKPASS}" + else + unset SSH_ASKPASS + fi + + if [[ ${CVS_ECLASS_ORIG_DISPLAY+set} == "set" ]] ; then + export DISPLAY="${CVS_ECLASS_ORIG_DISPLAY}" + else + unset DISPLAY + fi + fi + + # Restore ownership. Not sure why this is needed, but someone + # added it in the orig ECVS_RUNAS stuff. + if [[ -n ${ECVS_RUNAS} ]] ; then + chown $(whoami) "${T}/cvspass" + fi + +} + +# @FUNCTION: cvs_src_unpack +# @DESCRIPTION: +# The cvs src_unpack function, which will be exported +cvs_src_unpack() { + + debug-print-function ${FUNCNAME} "$@" + + debug-print "${FUNCNAME}: init: + ECVS_CVS_COMMAND=${ECVS_CVS_COMMAND} + ECVS_UP_OPTS=${ECVS_UP_OPTS} + ECVS_CO_OPTS=${ECVS_CO_OPTS} + ECVS_TOP_DIR=${ECVS_TOP_DIR} + ECVS_SERVER=${ECVS_SERVER} + ECVS_USER=${ECVS_USER} + ECVS_PASS=${ECVS_PASS} + ECVS_MODULE=${ECVS_MODULE} + ECVS_LOCAL=${ECVS_LOCAL} + ECVS_RUNAS=${ECVS_RUNAS} + ECVS_LOCALNAME=${ECVS_LOCALNAME}" + + [[ -z ${ECVS_MODULE} ]] && die "ERROR: CVS module not set, cannot continue." + + local ECVS_LOCALNAME=${ECVS_LOCALNAME:-${ECVS_MODULE}} + + local sanitized_pn=$(echo "${PN}" | LC_ALL=C sed -e 's:[^A-Za-z0-9_]:_:g') + local offline_pkg_var="ECVS_OFFLINE_${sanitized_pn}" + if [[ -n ${!offline_pkg_var}${ECVS_OFFLINE} ]] || [[ ${ECVS_SERVER} == "offline" ]] ; then + # We're not required to fetch anything; the module already + # exists and shouldn't be updated. + if [[ -d ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} ]] ; then + debug-print "${FUNCNAME}: offline mode" + else + debug-print "${FUNCNAME}: Offline mode specified but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found, exiting with error" + die "ERROR: Offline mode specified, but directory ${ECVS_TOP_DIR}/${ECVS_LOCALNAME} not found. Aborting." + fi + elif [[ -n ${ECVS_SERVER} ]] ; then # ECVS_SERVER!=offline --> real fetching mode + einfo "Fetching CVS module ${ECVS_MODULE} into ${ECVS_TOP_DIR} ..." + cvs_fetch + else # ECVS_SERVER not set + die "ERROR: CVS server not specified, cannot continue." + fi + + einfo "Copying ${ECVS_MODULE} from ${ECVS_TOP_DIR} ..." + debug-print "Copying module ${ECVS_MODULE} local_mode=${ECVS_LOCAL} from ${ECVS_TOP_DIR} ..." + + # This is probably redundant, but best to make sure. + mkdir -p "${WORKDIR}/${ECVS_LOCALNAME}" + + if [[ -n ${ECVS_LOCAL} ]] ; then + cp -f "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}"/* "${WORKDIR}/${ECVS_LOCALNAME}" + else + cp -Rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" "${WORKDIR}/${ECVS_LOCALNAME}/.." + fi + + # Not exactly perfect, but should be pretty close #333773 + export ECVS_VERSION=$( + find "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}/" -ipath '*/CVS/Entries' -exec cat {} + | \ + LC_ALL=C sort | \ + sha1sum | \ + awk '{print $1}' + ) + + # If the directory is empty, remove it; empty directories cannot + # exist in cvs. This happens when, for example, kde-source + # requests module/doc/subdir which doesn't exist. Still create + # the empty directory in workdir though. + if [[ $(ls -A "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}") == "CVS" ]] ; then + debug-print "${FUNCNAME}: removing empty CVS directory ${ECVS_LOCALNAME}" + rm -rf "${ECVS_TOP_DIR}/${ECVS_LOCALNAME}" + 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}" + epatch ${PATCHES} + # 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 + + einfo "CVS module ${ECVS_MODULE} is now in ${WORKDIR}" +} + +EXPORT_FUNCTIONS src_unpack + +fi |