ROOTPATH=${ROOTPATH%%:}
PREROOTPATH=${PREROOTPATH##:}
PREROOTPATH=${PREROOTPATH%%:}
-#PATH=$PORTAGE_BIN_PATH/ebuild-helpers:$PREROOTPATH${PREROOTPATH:+:}/usr/local/sbin:/sbin:/usr/sbin:/usr/local/bin:/bin:/usr/bin${ROOTPATH:+:}$ROOTPATH
+#PATH=$PORTAGE_BIN_PATH/ebuild-helpers:$PREROOTPATH${PREROOTPATH:+:}/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin${ROOTPATH:+:}$ROOTPATH
# PREFIX: we deviate in path order, should we split up DEFAULT_PATH?
PATH="$PORTAGE_BIN_PATH/ebuild-helpers:$PREROOTPATH${PREROOTPATH:+:}${DEFAULT_PATH}:${ROOTPATH:+:}$ROOTPATH"
export PATH
;;
esac
- #PATH=$ebuild_helpers_path:$PREROOTPATH${PREROOTPATH:+:}/usr/local/sbin:/sbin:/usr/sbin:/usr/local/bin:/bin:/usr/bin${ROOTPATH:+:}$ROOTPATH
+ #PATH=$ebuild_helpers_path:$PREROOTPATH${PREROOTPATH:+:}/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin${ROOTPATH:+:}$ROOTPATH
# PREFIX: same deviation as at the top of this file
PATH="$ebuild_helpers_path:$PREROOTPATH${PREROOTPATH:+:}${DEFAULT_PATH}${ROOTPATH:+:}$ROOTPATH"
unset ebuild_helpers_path
done
}
+nonfatal() {
+ if has "${EAPI:-0}" 0 1 2; then
+ die "$FUNCNAME() not supported in this EAPI"
+ fi
+ if [[ $# -lt 1 ]]; then
+ die "$FUNCNAME(): Missing argument"
+ fi
+
+ PORTAGE_NONFATAL=1 "$@"
+}
+
die() {
+ if [[ $PORTAGE_NONFATAL -eq 1 ]]; then
+ echo -e " $WARN*$NORMAL ${FUNCNAME[1]}: WARNING: $@" >&2
+ return 1
+ fi
+
set +e
if [ -n "${QA_INTERCEPTORS}" ] ; then
# die was called from inside inherit. We need to clean up
PORTAGE_COLORMAP PORTAGE_CONFIGROOT PORTAGE_DEBUG \
PORTAGE_DEPCACHEDIR PORTAGE_GID PORTAGE_INST_GID \
PORTAGE_INST_UID PORTAGE_LOG_FILE PORTAGE_MASTER_PID \
- PORTAGE_QUIET \
+ PORTAGE_NONFATAL PORTAGE_QUIET \
PORTAGE_REPO_NAME PORTAGE_RESTRICT PORTAGE_UPDATE_ENV \
PORTAGE_VERBOSE PORTAGE_WORKDIR_MODE PORTDIR \
PORTDIR_OVERLAY ${!PORTAGE_SANDBOX_*} PREROOTPATH \
PORTAGE_BINPKG_TMPFILE="${PKGDIR}/${CATEGORY}/${PF}.tbz2"
mkdir -p "${PORTAGE_BINPKG_TMPFILE%/*}" || die "mkdir failed"
tar $tar_options -cf - $PORTAGE_BINPKG_TAR_OPTS -C "${D}" . | \
- bzip2 -f > "$PORTAGE_BINPKG_TMPFILE"
+ bzip2 -cf > "$PORTAGE_BINPKG_TMPFILE"
assert "failed to pack binary package: '$PORTAGE_BINPKG_TMPFILE'"
PYTHONPATH=${PORTAGE_PYM_PATH}${PYTHONPATH:+:}${PYTHONPATH} \
python -c "from portage import xpak; t=xpak.tbz2('${PORTAGE_BINPKG_TMPFILE}'); t.recompose('${PORTAGE_BUILDDIR}/build-info')"
err.flush()
return 2
- import shlex
from portage.util import ConfigProtect
settings = portage.settings
- protect = shlex.split(settings.get("CONFIG_PROTECT", ""))
- protect_mask = shlex.split(settings.get("CONFIG_PROTECT_MASK", ""))
+ protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
+ protect_mask = portage.util.shlex_split(
+ settings.get("CONFIG_PROTECT_MASK", ""))
protect_obj = ConfigProtect(root, protect, protect_mask)
if protect_obj.isprotected(f):
except OSError:
pass
- import shlex
from portage.util import ConfigProtect
settings = portage.settings
- protect = shlex.split(settings.get("CONFIG_PROTECT", ""))
- protect_mask = shlex.split(settings.get("CONFIG_PROTECT_MASK", ""))
+ protect = portage.util.shlex_split(settings.get("CONFIG_PROTECT", ""))
+ protect_mask = portage.util.shlex_split(
+ settings.get("CONFIG_PROTECT_MASK", ""))
protect_obj = ConfigProtect(root, protect, protect_mask)
protected = 0
from _emerge.SpawnProcess import SpawnProcess
import urlparse
import sys
-import shlex
+
# for an explanation on this logic, see pym/_emerge/__init__.py
import os
import sys
fetch_env = dict(settings.iteritems())
fetch_args = [portage.util.varexpand(x, mydict=fcmd_vars) \
- for x in shlex.split(fcmd)]
+ for x in portage.util.shlex_split(fcmd)]
if self.fd_pipes is None:
self.fd_pipes = {}
temporarily overridden stdout."""
return sys.stdout
+ def _write(self, s):
+ if sys.hexversion < 0x3000000 and isinstance(s, unicode):
+ # avoid potential UnicodeEncodeError
+ s = s.encode('utf_8', 'replace')
+ self.out.write(s)
+ self.out.flush()
+
def _init_term(self):
"""
Initialize term control codes.
return ">>> %s" % msg
def _erase(self):
- self.out.write(
+ self._write(
self._term_codes['carriage_return'] + \
self._term_codes['clr_eol'])
- self.out.flush()
self._displayed = False
def _display(self, line):
- self.out.write(line)
- self.out.flush()
+ self._write(line)
self._displayed = True
def _update(self, msg):
- out = self.out
if not self._isatty:
- out.write(self._format_msg(msg) + self._term_codes['newline'])
- self.out.flush()
+ self._write(self._format_msg(msg) + self._term_codes['newline'])
self._displayed = True
return
if self._isatty and self._displayed:
self._erase()
- self.out.write(self._format_msg(msg) + self._term_codes['newline'])
- self.out.flush()
+ self._write(self._format_msg(msg) + self._term_codes['newline'])
self._displayed = False
if was_displayed:
object.__setattr__(self, name, 0)
if self._displayed:
- self.out.write(self._term_codes['newline'])
- self.out.flush()
+ self._write(self._term_codes['newline'])
self._displayed = False
def __setattr__(self, name, value):
return self._pkg(cpv, type_name, root_config, installed=installed)
def _append_to_log_path(self, log_path, msg):
+
+ if not isinstance(msg, unicode):
+ msg = unicode(msg, encoding='utf_8', errors='replace')
+
f = codecs.open(log_path, mode='a',
encoding='utf_8', errors='replace')
try:
import platform
import pwd
import re
-import shlex
import signal
import socket
import stat
# defaults.
portage.writemsg("Using PORTAGE_RSYNC_OPTS instead of hardcoded defaults\n", 1)
- rsync_opts.extend(
- shlex.split(settings.get("PORTAGE_RSYNC_OPTS","")))
+ rsync_opts.extend(portage.util.shlex_split(
+ settings.get("PORTAGE_RSYNC_OPTS", "")))
for opt in ("--recursive", "--times"):
if opt not in rsync_opts:
portage.writemsg(yellow("WARNING:") + " adding required option " + \
user_name=""
updatecache_flg=True
all_rsync_opts = set(rsync_opts)
- extra_rsync_opts = shlex.split(
+ extra_rsync_opts = portage.util.shlex_split(
settings.get("PORTAGE_RSYNC_EXTRA_OPTS",""))
all_rsync_opts.update(extra_rsync_opts)
family = socket.AF_INET
_emerge_log_dir = EPREFIX + '/var/log'
def emergelog(xterm_titles, mystr, short_msg=None):
+
+ if not isinstance(mystr, unicode):
+ mystr = unicode(mystr, encoding='utf_8', errors='replace')
+
+ if short_msg is not None and not isinstance(short_msg, unicode):
+ short_msg = unicode(short_msg, encoding='utf_8', errors='replace')
+
if xterm_titles and short_msg:
if "HOSTNAME" in os.environ:
short_msg = os.environ["HOSTNAME"]+": "+short_msg
# $Id$
import logging
-import shlex
import signal
import sys
import textwrap
ionice_cmd = settings.get("PORTAGE_IONICE_COMMAND")
if ionice_cmd:
- ionice_cmd = shlex.split(ionice_cmd)
+ ionice_cmd = portage.util.shlex_split(ionice_cmd)
if not ionice_cmd:
return
"A", "AA", "CATEGORY", "DEPEND", "DESCRIPTION", "EAPI",
"EBUILD_PHASE", "EMERGE_FROM", "HOMEPAGE", "INHERITED", "IUSE",
"KEYWORDS", "LICENSE", "PDEPEND", "PF", "PKGUSE",
- "PORTAGE_CONFIGROOT", "PORTAGE_IUSE", "PORTAGE_REPO_NAME",
+ "PORTAGE_CONFIGROOT", "PORTAGE_IUSE",
+ "PORTAGE_NONFATAL", "PORTAGE_REPO_NAME",
"PORTAGE_USE", "PROPERTIES", "PROVIDE", "RDEPEND", "RESTRICT",
"ROOT", "SLOT", "SRC_URI", "EPREFIX", "EROOT"
]
# no digests because fetch was not called for a specific package
mydigests = {}
- import shlex
ro_distdirs = [x for x in \
- shlex.split(mysettings.get("PORTAGE_RO_DISTDIRS", "")) \
+ util.shlex_split(mysettings.get("PORTAGE_RO_DISTDIRS", "")) \
if os.path.isdir(x)]
fsmirrors = []
"URI": loc,
"FILE": myfile
}
- import shlex
- myfetch = shlex.split(locfetch)
+
+ myfetch = util.shlex_split(locfetch)
myfetch = [varexpand(x, mydict=variables) for x in myfetch]
myret = -1
try:
# os.path.join when called by os.walk.
destdir = destdir.encode('utf_8', 'replace')
+ size = 0
+
for parent, dirs, files in os.walk(destdir):
for fname in chain(dirs, files):
fpath = os.path.join(parent, fname)
mystat = os.lstat(fpath)
+ if stat.S_ISREG(mystat.st_mode):
+ size += mystat.st_size
if mystat.st_uid != portage_uid and \
mystat.st_gid != portage_gid:
continue
mode=mystat.st_mode, stat_cached=mystat,
follow_links=False)
+ open(os.path.join(mysettings['PORTAGE_BUILDDIR'],
+ 'build-info', 'SIZE'), 'w').write(str(size) + '\n')
+
if bsd_chflags:
# Restore all of the flags saved above.
os.system("mtree -e -p %s -U -k flags < %s > /dev/null" % \
if destexists and not stat.S_ISDIR(dstat[stat.ST_MODE]):
os.unlink(dest)
if selinux_enabled:
- sid = selinux.get_lsid(src)
- selinux.secure_symlink(target,dest,sid)
+ selinux.symlink(target, dest, src)
else:
os.symlink(target,dest)
lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
if not hardlinked and (selinux_enabled or sstat.st_dev == dstat.st_dev):
try:
if selinux_enabled:
- ret=selinux.secure_rename(src,dest)
+ ret = selinux.rename(src, dest)
else:
ret=os.rename(src,dest)
renamefailed=0
if stat.S_ISREG(sstat[stat.ST_MODE]):
try: # For safety copy then move it over.
if selinux_enabled:
- selinux.secure_copy(src,dest+"#new")
- selinux.secure_rename(dest+"#new",dest)
+ selinux.copyfile(src, dest + "#new")
+ selinux.rename(dest + "#new", dest)
else:
shutil.copyfile(src,dest+"#new")
os.rename(dest+"#new",dest)
return None
else:
#we don't yet handle special, so we need to fall back to /bin/mv
- if selinux_enabled:
- a=commands.getstatusoutput(MOVE_BINARY+" -c -f "+"'"+src+"' '"+dest+"'")
- else:
- a=commands.getstatusoutput(MOVE_BINARY+" -f "+"'"+src+"' '"+dest+"'")
- if a[0]!=0:
- print "!!! Failed to move special file:"
- print "!!! '"+src+"' to '"+dest+"'"
- print "!!!",a
- return None # failure
+ a = commands.getstatusoutput("%s -f %s %s" % \
+ (MOVE_BINARY, _shell_quote(src), _shell_quote(dest)))
+ if a[0] != os.EX_OK:
+ writemsg("!!! Failed to move special file:\n", noiselevel=-1)
+ writemsg("!!! '%s' to '%s'\n" % (src, dest), noiselevel=-1)
+ writemsg("!!! %s\n" % a, noiselevel=-1)
+ return None # failure
try:
if didcopy:
if stat.S_ISLNK(sstat[stat.ST_MODE]):
# Distributed under the terms of the GNU General Public License v2
# $Id$
+import os
import selinux
-from selinux import is_selinux_enabled
-from selinux_aux import setexec, secure_symlink, secure_rename, \
- secure_copy, secure_mkdir, getcontext, get_sid, get_lsid
+import shutil
+from selinux import is_selinux_enabled, getfilecon, lgetfilecon
+
+def copyfile(src, dest):
+ if isinstance(src, unicode):
+ src = src.encode('utf_8', 'replace')
+ if isinstance(dest, unicode):
+ dest = dest.encode('utf_8', 'replace')
+ (rc, ctx) = selinux.lgetfilecon(src)
+ if rc < 0:
+ raise OSError("copyfile: Failed getting context of \"%s\"." % src)
+
+ setfscreate(ctx)
+ try:
+ shutil.copyfile(src, dest)
+ finally:
+ setfscreate()
+
+def getcontext():
+ (rc, ctx) = selinux.getcon()
+ if rc < 0:
+ raise OSError("getcontext: Failed getting current process context.")
+
+ return ctx
+
+def mkdir(target, refdir):
+ if isinstance(target, unicode):
+ target = target.encode('utf_8', 'replace')
+ if isinstance(refdir, unicode):
+ refdir = refdir.encode('utf_8', 'replace')
+ (rc, ctx) = selinux.getfilecon(refdir)
+ if rc < 0:
+ raise OSError(
+ "mkdir: Failed getting context of reference directory \"%s\"." \
+ % refdir)
+
+ setfscreatecon(ctx)
+ try:
+ os.mkdir(target)
+ finally:
+ setfscreatecon()
+
+def rename(src, dest):
+ if isinstance(src, unicode):
+ src = src.encode('utf_8', 'replace')
+ if isinstance(dest, unicode):
+ dest = dest.encode('utf_8', 'replace')
+ (rc, ctx) = selinux.lgetfilecon(src)
+ if rc < 0:
+ raise OSError("rename: Failed getting context of \"%s\"." % src)
+
+ setfscreate(ctx)
+ try:
+ os.rename(src,dest)
+ finally:
+ setfscreate()
+
+def setexec(ctx="\n"):
+ if selinux.setexeccon(ctx) < 0:
+ raise OSError("setexec: Failed setting exec() context \"%s\"." % ctx)
+
+def setfscreate(ctx="\n"):
+ if selinux.setfscreatecon(ctx) < 0:
+ raise OSError(
+ "setfscreate: Failed setting fs create context \"%s\"." % ctx)
+
+def spawn(selinux_type, spawn_func, mycommand, opt_name=None, **keywords):
+ con = getcontext().split(":")
+ con[2] = selinux_type
+ setexec(":".join(con))
+ try:
+ return spawn_func(mycommand, opt_name=opt_name, **keywords)
+ finally:
+ setexec()
+
+def symlink(target, link, reflnk):
+ if isinstance(target, unicode):
+ target = target.encode('utf_8', 'replace')
+ if isinstance(link, unicode):
+ link = link.encode('utf_8', 'replace')
+ if isinstance(reflnk, unicode):
+ reflnk = reflnk.encode('utf_8', 'replace')
+ (rc, ctx) = selinux.lgetfilecon(reflnk)
+ if rc < 0:
+ raise OSError(
+ "symlink: Failed getting context of reference symlink \"%s\"." \
+ % reflnk)
+
+ setfscreate(ctx)
+ try:
+ os.symlink(target, link)
+ finally:
+ setfscreate()
import codecs
import os, re, shutil, stat, errno, copy, subprocess
import logging
-import shlex
import sys
from itertools import izip
if not hasattr(pkg, "getcontents"):
pkg = self._dblink(pkg)
root = self.root
+ if not isinstance(root, unicode):
+ root = unicode(root, encoding='utf_8', errors='replace')
root_len = len(root) - 1
new_contents = pkg.getcontents().copy()
removed = 0
for filename in paths:
+ if not isinstance(filename, unicode):
+ filename = unicode(filename,
+ encoding='utf_8', errors='replace')
filename = normalize_path(filename)
if relative_paths:
relative_filename = filename
self.myroot=myroot
protect_obj = ConfigProtect(myroot,
- shlex.split(mysettings.get("CONFIG_PROTECT", "")),
- shlex.split(mysettings.get("CONFIG_PROTECT_MASK", "")))
+ portage.util.shlex_split(mysettings.get("CONFIG_PROTECT", "")),
+ portage.util.shlex_split(
+ mysettings.get("CONFIG_PROTECT_MASK", "")))
self.updateprotect = protect_obj.updateprotect
self.isprotected = protect_obj.isprotected
self._installed_instance = None
if the file is not owned by this package.
"""
+ if not isinstance(filename, unicode):
+ filename = unicode(filename,
+ encoding='utf_8', errors='replace')
+
+ if not isinstance(destroot, unicode):
+ destroot = unicode(destroot,
+ encoding='utf_8', errors='replace')
+
destfile = normalize_path(
os.path.join(destroot, filename.lstrip(os.path.sep)))
new_contents = self.getcontents().copy()
old_contents = self._installed_instance.getcontents()
for f in sorted(preserve_paths):
+ if not isinstance(f, unicode):
+ f = unicode(f, encoding='utf_8', errors='replace')
f_abs = os.path.join(root, f.lstrip(os.sep))
contents_entry = old_contents.get(f_abs)
if contents_entry is None:
def _collision_protect(self, srcroot, destroot, mypkglist, mycontents):
collision_ignore = set([normalize_path(myignore) for myignore in \
- shlex.split(self.settings.get("COLLISION_IGNORE", ""))])
+ portage.util.shlex_split(
+ self.settings.get("COLLISION_IGNORE", ""))])
# For collisions with preserved libraries, the current package
# will assume ownership and the libraries will be unregistered.
mydest = join(destroot, offset, x)
# myrealdest is mydest without the $ROOT prefix (makes a difference if ROOT!="/")
myrealdest = join(sep, offset, x)
+ if not isinstance(myrealdest, unicode):
+ myrealdest = unicode(myrealdest,
+ encoding='utf_8', errors='replace')
# stat file once, test using S_* macros many times (faster that way)
mystat = os.lstat(mysrc)
mymode = mystat[stat.ST_MODE]
global _msgbuffer
- if color == None:
+ if out is None:
+ out = sys.stdout
+
+ if color is None:
color = "GOOD"
+ if not isinstance(msg, unicode):
+ msg = unicode(msg, encoding='utf_8', errors='replace')
+
formatted_msg = colorize(color, " * ") + msg + "\n"
- if out is None:
- sys.stdout.write(formatted_msg)
- else:
- out.write(formatted_msg)
+ if sys.hexversion < 0x3000000 and \
+ out in (sys.stdout, sys.stderr) and isinstance(formatted_msg, unicode):
+ # avoid potential UnicodeEncodeError
+ formatted_msg = formatted_msg.encode('utf_8', 'replace')
+
+ out.write(formatted_msg)
if key not in _msgbuffer:
_msgbuffer[key] = {}
from portage.output import colorize
from portage.cache.mappings import slot_dict_class
-import portage.xpak
+import portage
import HTMLParser
import sys
import os
"URI": baseurl,
"FILE": os.path.basename(baseurl)
}
- import shlex
+
from portage.util import varexpand
from portage.process import spawn
- myfetch = shlex.split(fcmd)
+ myfetch = portage.util.shlex_split(fcmd)
myfetch = [varexpand(x, mydict=variables) for x in myfetch]
fd_pipes= {
0:sys.stdin.fileno(),
from portage.localization import _
from portage.sets.base import PackageSet
from portage.sets import SetConfigError, get_boolean
+import portage
__all__ = ["CategorySet", "DowngradeSet",
"EverythingSet", "OwnerSet", "VariableSet"]
if not "files" in options:
raise SetConfigError(_("no files given"))
- import shlex
return cls(vardb=trees["vartree"].dbapi,
- files=frozenset(shlex.split(options["files"])))
+ files=frozenset(portage.util.shlex_split(options["files"])))
singleBuilder = classmethod(singleBuilder)
from portage.sets.base import PackageSet
from portage.sets import get_boolean
from portage.versions import catpkgsplit
+import portage
class LibraryConsumerSet(PackageSet):
_operations = ["merge", "unmerge"]
self._setAtoms(self.mapPathsToAtoms(consumers))
def singleBuilder(cls, options, settings, trees):
- import shlex
- files = tuple(shlex.split(options.get("files", "")))
+ files = tuple(portage.util.shlex_split(options.get("files", "")))
if not files:
raise SetConfigError(_("no files given"))
debug = get_boolean(options, "debug", False)
return 0
return 1
+def shlex_split(s):
+ """
+ This is equivalent to shlex.split but it temporarily encodes unicode
+ strings to bytes since shlex.split() doesn't handle unicode strings.
+ """
+ is_unicode = isinstance(s, unicode)
+ if is_unicode:
+ s = s.encode('utf_8', 'replace')
+ rval = shlex.split(s)
+ if is_unicode:
+ rval = [unicode(x, encoding='utf_8', errors='replace') for x in rval]
+ return rval
+
class _tolerant_shlex(shlex.shlex):
def sourcehook(self, newfile):
try:
def editor_is_executable(editor):
"""
Given an EDITOR string, validate that it refers to
- an executable. This uses shlex.split() to split the
+ an executable. This uses shlex_split() to split the
first component and do a PATH lookup if necessary.
@param editor: An EDITOR value from the environment.
@rtype: bool
@returns: True if an executable is found, False otherwise.
"""
- import shlex
- editor_split = shlex.split(editor)
+ editor_split = util.shlex_split(editor)
if not editor_split:
return False
filename = editor_split[0]
projects / portage.git / commitdiff