def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
fetchonly=0, cleanup=0, dbkey=None, use_cache=1, fetchall=0, tree=None,
mydbapi=None, vartree=None, prev_mtimes=None,
fd_pipes=None, returnpid=False):
portage.doebuild(myebuild, mydo, _unused, settings, debug, listonly,
fetchonly, cleanup, dbkey, use_cache, fetchall, tree,
mydbapi, vartree, prev_mtimes,
fd_pipes, returnpid)
def _create_ebuild_manifests(self, ebuilds):
for cpv in ebuilds:
a = Atom("=" + cpv)
ebuild_dir = os.path.join(self.portdir, a.cp)
ebuild_path = os.path.join(ebuild_dir, a.cpv.split("/")[1] + ".ebuild")
portage.util.noiselimit = -1
tmpsettings = config(clone=self.settings)
portdb = self.trees[self.root]["porttree"].dbapi
portage.doebuild(ebuild_path, "digest", self.root, tmpsettings,
tree="porttree", mydbapi=portdb)
portage.util.noiselimit = 0
def execute(self):
settings = self.settings
pkg = self.pkg
portdb = pkg.root_config.trees["porttree"].dbapi
ebuild_path = portdb.findname(pkg.cpv)
if ebuild_path is None:
raise AssertionError("ebuild not found for '%s'" % pkg.cpv)
settings.setcpv(pkg)
debug = settings.get("PORTAGE_DEBUG") == "1"
if 'fetch' in pkg.metadata.restrict:
rval = self._execute_with_builddir()
else:
rval = portage.doebuild(ebuild_path,
"fetch",
settings["ROOT"],
settings,
debug=debug,
listonly=self.pretend,
fetchonly=1,
fetchall=self.fetch_all,
mydbapi=portdb,
tree="porttree")
if rval != os.EX_OK:
msg = "Fetch failed for '%s'" % (pkg.cpv, )
eerror(msg, phase="unpack", key=pkg.cpv)
return rval
def execute(self):
settings = self.settings
pkg = self.pkg
portdb = pkg.root_config.trees["porttree"].dbapi
ebuild_path = portdb.findname(pkg.cpv, myrepo=pkg.repo)
if ebuild_path is None:
raise AssertionError("ebuild not found for '%s'" % pkg.cpv)
settings.setcpv(pkg)
debug = settings.get("PORTAGE_DEBUG") == "1"
rval = portage.doebuild(
ebuild_path,
"fetch",
settings=settings,
debug=debug,
listonly=self.pretend,
fetchonly=1,
fetchall=self.fetch_all,
mydbapi=portdb,
tree="porttree",
)
# For pretend mode, this error message is suppressed,
# and the unsuccessful return value is used to trigger
# a call to the pkg_nofetch phase.
if rval != os.EX_OK and not self.pretend:
msg = "Fetch failed for '%s'" % (pkg.cpv,)
eerror(msg, phase="unpack", key=pkg.cpv)
return rval
def _execute(self):
settings = self.settings
pkg = self.pkg
root_config = pkg.root_config
portdb = root_config.trees["porttree"].dbapi
ebuild_path = portdb.findname(pkg.cpv)
if ebuild_path is None:
raise AssertionError("ebuild not found for '%s'" % pkg.cpv)
debug = settings.get("PORTAGE_DEBUG") == "1"
retval = portage.doebuild(ebuild_path,
"fetch",
self.settings["ROOT"],
self.settings,
debug=debug,
listonly=self.pretend,
fetchonly=1,
fetchall=self.fetch_all,
mydbapi=portdb,
tree="porttree")
if retval != os.EX_OK:
msg = "Fetch failed for '%s'" % (pkg.cpv, )
eerror(msg, phase="unpack", key=pkg.cpv)
portage.elog.elog_process(self.pkg.cpv, self.settings)
return retval
def _create_ebuild_manifests(self, ebuilds):
for cpv in ebuilds:
a = Atom("=" + cpv)
ebuild_dir = os.path.join(self.portdir, a.cp)
ebuild_path = os.path.join(ebuild_dir,
a.cpv.split("/")[1] + ".ebuild")
portage.util.noiselimit = -1
tmpsettings = config(clone=self.settings)
portdb = self.trees[self.root]["porttree"].dbapi
portage.doebuild(ebuild_path,
"digest",
self.root,
tmpsettings,
tree="porttree",
mydbapi=portdb)
portage.util.noiselimit = 0
def doebuild(myebuild,
mydo,
_unused=None,
settings=None,
debug=0,
listonly=0,
fetchonly=0,
cleanup=0,
dbkey=None,
use_cache=1,
fetchall=0,
tree=None,
mydbapi=None,
vartree=None,
prev_mtimes=None,
fd_pipes=None,
returnpid=False):
portage.doebuild(myebuild, mydo, _unused, settings, debug, listonly,
fetchonly, cleanup, dbkey, use_cache, fetchall, tree,
mydbapi, vartree, prev_mtimes, fd_pipes, returnpid)
def execute(self):
settings = self.settings
pkg = self.pkg
portdb = pkg.root_config.trees["porttree"].dbapi
ebuild_path = portdb.findname(pkg.cpv, myrepo=pkg.repo)
if ebuild_path is None:
raise AssertionError("ebuild not found for '%s'" % pkg.cpv)
settings.setcpv(pkg)
debug = settings.get("PORTAGE_DEBUG") == "1"
rval = portage.doebuild(ebuild_path, "fetch",
settings=settings, debug=debug,
listonly=self.pretend, fetchonly=1, fetchall=self.fetch_all,
mydbapi=portdb, tree="porttree")
if rval != os.EX_OK:
msg = "Fetch failed for '%s'" % (pkg.cpv,)
eerror(msg, phase="unpack", key=pkg.cpv)
return rval
def execute(self):
settings = self.settings
pkg = self.pkg
portdb = pkg.root_config.trees["porttree"].dbapi
ebuild_path = portdb.findname(pkg.cpv, myrepo=pkg.repo)
if ebuild_path is None:
raise AssertionError("ebuild not found for '%s'" % pkg.cpv)
settings.setcpv(pkg)
debug = settings.get("PORTAGE_DEBUG") == "1"
rval = portage.doebuild(ebuild_path, "fetch",
settings=settings, debug=debug,
listonly=self.pretend, fetchonly=1, fetchall=self.fetch_all,
mydbapi=portdb, tree="porttree")
# For pretend mode, this error message is suppressed,
# and the unsuccessful return value is used to trigger
# a call to the pkg_nofetch phase.
if rval != os.EX_OK and not self.pretend:
msg = "Fetch failed for '%s'" % (pkg.cpv,)
eerror(msg, phase="unpack", key=pkg.cpv)
return rval
def pkgmerge(mytbz2, myroot, mysettings, mydbapi=None, vartree=None, prev_mtimes=None, blockers=None):
"""will merge a .tbz2 file, returning a list of runtime dependencies
that must be satisfied, or None if there was a merge error. This
code assumes the package exists."""
warnings.warn("portage.pkgmerge() is deprecated", DeprecationWarning, stacklevel=2)
if mydbapi is None:
mydbapi = portage.db[myroot]["bintree"].dbapi
if vartree is None:
vartree = portage.db[myroot]["vartree"]
if mytbz2[-5:] != ".tbz2":
print(_("!!! Not a .tbz2 file"))
return 1
tbz2_lock = None
mycat = None
mypkg = None
did_merge_phase = False
success = False
try:
""" Don't lock the tbz2 file because the filesytem could be readonly or
shared by a cluster."""
# tbz2_lock = portage.locks.lockfile(mytbz2, wantnewlockfile=1)
mypkg = os.path.basename(mytbz2)[:-5]
xptbz2 = portage.xpak.tbz2(mytbz2)
mycat = xptbz2.getfile(_unicode_encode("CATEGORY", encoding=_encodings["repo.content"]))
if not mycat:
writemsg(_("!!! CATEGORY info missing from info chunk, aborting...\n"), noiselevel=-1)
return 1
mycat = _unicode_decode(mycat, encoding=_encodings["repo.content"], errors="replace")
mycat = mycat.strip()
# These are the same directories that would be used at build time.
builddir = os.path.join(mysettings["PORTAGE_TMPDIR"], "portage", mycat, mypkg)
catdir = os.path.dirname(builddir)
pkgloc = os.path.join(builddir, "image")
infloc = os.path.join(builddir, "build-info")
myebuild = os.path.join(infloc, os.path.basename(mytbz2)[:-4] + "ebuild")
portage.util.ensure_dirs(os.path.dirname(catdir), uid=portage_uid, gid=portage_gid, mode=0o70, mask=0)
portage.util.ensure_dirs(catdir, uid=portage_uid, gid=portage_gid, mode=0o70, mask=0)
try:
shutil.rmtree(builddir)
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise
del e
for mydir in (builddir, pkgloc, infloc):
portage.util.ensure_dirs(mydir, uid=portage_uid, gid=portage_gid, mode=0o755)
writemsg_stdout(_(">>> Extracting info\n"))
xptbz2.unpackinfo(infloc)
mysettings.setcpv(mycat + "/" + mypkg, mydb=mydbapi)
# Store the md5sum in the vdb.
fp = open(_unicode_encode(os.path.join(infloc, "BINPKGMD5")), "w")
fp.write(str(portage.checksum.perform_md5(mytbz2)) + "\n")
fp.close()
# This gives bashrc users an opportunity to do various things
# such as remove binary packages after they're installed.
mysettings["PORTAGE_BINPKG_FILE"] = mytbz2
mysettings.backup_changes("PORTAGE_BINPKG_FILE")
debug = mysettings.get("PORTAGE_DEBUG", "") == "1"
# Eventually we'd like to pass in the saved ebuild env here.
retval = portage.doebuild(
myebuild, "setup", myroot, mysettings, debug=debug, tree="bintree", mydbapi=mydbapi, vartree=vartree
)
if retval != os.EX_OK:
writemsg(_("!!! Setup failed: %s\n") % retval, noiselevel=-1)
return retval
writemsg_stdout(_(">>> Extracting %s\n") % mypkg)
retval = portage.process.spawn_bash(
"bzip2 -dqc -- '%s' | tar -xp -C '%s' -f -" % (mytbz2, pkgloc), env=mysettings.environ()
)
if retval != os.EX_OK:
writemsg(_("!!! Error Extracting '%s'\n") % mytbz2, noiselevel=-1)
return retval
# portage.locks.unlockfile(tbz2_lock)
# tbz2_lock = None
mylink = portage.dblink(
mycat, mypkg, myroot, mysettings, vartree=vartree, treetype="bintree", blockers=blockers
)
retval = mylink.merge(pkgloc, infloc, myroot, myebuild, cleanup=0, mydbapi=mydbapi, prev_mtimes=prev_mtimes)
did_merge_phase = True
success = retval == os.EX_OK
return retval
finally:
mysettings.pop("PORTAGE_BINPKG_FILE", None)
if tbz2_lock:
portage.locks.unlockfile(tbz2_lock)
if True:
if not did_merge_phase:
# The merge phase handles this already. Callers don't know how
# far this function got, so we have to call elog_process() here
# so that it's only called once.
from portage.elog import elog_process
elog_process(mycat + "/" + mypkg, mysettings)
try:
if success:
shutil.rmtree(builddir)
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise
del e
#!/usr/bin/env python
# Checking installed packages using linux-info.eclass
# for necessary kernel options
import portage
vartree = portage.db[portage.root]['vartree']
all_cpvs = vartree.dbapi.cpv_all()
settings = portage.config()
for cpv in all_cpvs:
inherit = vartree.dbapi.aux_get(cpv, ['INHERITED'])[0]
if 'linux-info' in inherit:
pv = portage.catsplit(cpv)[1]
cpvpath = vartree.dbapi.getpath(cpv) + '/' + pv + '.ebuild'
print('Checking: ' + cpv)
portage.doebuild(cpvpath,
'clean',
settings=settings,
tree='vartree',
vartree=vartree)
portage.doebuild(cpvpath,
'setup',
settings=settings,
tree='vartree',
vartree=vartree)
def _start(self):
settings = self.settings
settings.setcpv(self.cpv)
ebuild_path = self.ebuild_path
eapi = None
if 'parse-eapi-glep-55' in settings.features:
pf, eapi = portage._split_ebuild_name_glep55(
os.path.basename(ebuild_path))
if eapi is None and \
'parse-eapi-ebuild-head' in settings.features:
eapi = portage._parse_eapi_ebuild_head(
codecs.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'],
errors='strict'),
mode='r',
encoding=_encodings['repo.content'],
errors='replace'))
if eapi is not None:
if not portage.eapi_is_supported(eapi):
self.metadata_callback(self.cpv, self.ebuild_path,
self.repo_path, {'EAPI': eapi},
self.ebuild_mtime)
self.returncode = os.EX_OK
self.wait()
return
settings.configdict['pkg']['EAPI'] = eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
fd_pipes.setdefault(0, sys.stdin.fileno())
fd_pipes.setdefault(1, sys.stdout.fileno())
fd_pipes.setdefault(2, sys.stderr.fileno())
# flush any pending output
for fd in fd_pipes.values():
if fd == sys.stdout.fileno():
sys.stdout.flush()
if fd == sys.stderr.fileno():
sys.stderr.flush()
fd_pipes_orig = fd_pipes.copy()
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
fd_pipes[self._metadata_fd] = slave_fd
self._raw_metadata = []
files.ebuild = os.fdopen(master_fd, 'rb')
self._reg_id = self.scheduler.register(files.ebuild.fileno(),
self._registered_events,
self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path,
"depend",
settings["ROOT"],
settings,
debug,
mydbapi=self.portdb,
tree="porttree",
fd_pipes=fd_pipes,
returnpid=True)
os.close(slave_fd)
if isinstance(retval, int):
# doebuild failed before spawning
self._unregister()
self.returncode = retval
self.wait()
return
self.pid = retval[0]
portage.process.spawned_pids.remove(self.pid)
def pkgmerge(mytbz2,
myroot,
mysettings,
mydbapi=None,
vartree=None,
prev_mtimes=None,
blockers=None):
"""will merge a .tbz2 file, returning a list of runtime dependencies
that must be satisfied, or None if there was a merge error. This
code assumes the package exists."""
warnings.warn("portage.pkgmerge() is deprecated",
DeprecationWarning,
stacklevel=2)
if mydbapi is None:
mydbapi = portage.db[myroot]["bintree"].dbapi
if vartree is None:
vartree = portage.db[myroot]["vartree"]
if mytbz2[-5:] != ".tbz2":
print(_("!!! Not a .tbz2 file"))
return 1
tbz2_lock = None
mycat = None
mypkg = None
did_merge_phase = False
success = False
try:
""" Don't lock the tbz2 file because the filesytem could be readonly or
shared by a cluster."""
#tbz2_lock = portage.locks.lockfile(mytbz2, wantnewlockfile=1)
mypkg = os.path.basename(mytbz2)[:-5]
xptbz2 = portage.xpak.tbz2(mytbz2)
mycat = xptbz2.getfile(
_unicode_encode("CATEGORY", encoding=_encodings['repo.content']))
if not mycat:
writemsg(
_("!!! CATEGORY info missing from info chunk, aborting...\n"),
noiselevel=-1)
return 1
mycat = _unicode_decode(mycat,
encoding=_encodings['repo.content'],
errors='replace')
mycat = mycat.strip()
# These are the same directories that would be used at build time.
builddir = os.path.join(mysettings["PORTAGE_TMPDIR"], "portage", mycat,
mypkg)
catdir = os.path.dirname(builddir)
pkgloc = os.path.join(builddir, "image")
infloc = os.path.join(builddir, "build-info")
myebuild = os.path.join(infloc,
os.path.basename(mytbz2)[:-4] + "ebuild")
portage.util.ensure_dirs(os.path.dirname(catdir),
uid=portage_uid,
gid=portage_gid,
mode=0o70,
mask=0)
portage.util.ensure_dirs(catdir,
uid=portage_uid,
gid=portage_gid,
mode=0o70,
mask=0)
try:
shutil.rmtree(builddir)
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise
del e
for mydir in (builddir, pkgloc, infloc):
portage.util.ensure_dirs(mydir,
uid=portage_uid,
gid=portage_gid,
mode=0o755)
writemsg_stdout(_(">>> Extracting info\n"))
xptbz2.unpackinfo(infloc)
mysettings.setcpv(mycat + "/" + mypkg, mydb=mydbapi)
# Store the md5sum in the vdb.
fp = open(_unicode_encode(os.path.join(infloc, 'BINPKGMD5')), 'w')
fp.write(str(portage.checksum.perform_md5(mytbz2)) + "\n")
fp.close()
# This gives bashrc users an opportunity to do various things
# such as remove binary packages after they're installed.
mysettings["PORTAGE_BINPKG_FILE"] = mytbz2
mysettings.backup_changes("PORTAGE_BINPKG_FILE")
debug = mysettings.get("PORTAGE_DEBUG", "") == "1"
# Eventually we'd like to pass in the saved ebuild env here.
retval = portage.doebuild(myebuild,
"setup",
myroot,
mysettings,
debug=debug,
tree="bintree",
mydbapi=mydbapi,
vartree=vartree)
if retval != os.EX_OK:
writemsg(_("!!! Setup failed: %s\n") % retval, noiselevel=-1)
return retval
writemsg_stdout(_(">>> Extracting %s\n") % mypkg)
retval = portage.process.spawn_bash(
"bzip2 -dqc -- '%s' | tar -xp -C '%s' -f -" % (mytbz2, pkgloc),
env=mysettings.environ())
if retval != os.EX_OK:
writemsg(_("!!! Error Extracting '%s'\n") % mytbz2, noiselevel=-1)
return retval
#portage.locks.unlockfile(tbz2_lock)
#tbz2_lock = None
mylink = portage.dblink(mycat,
mypkg,
myroot,
mysettings,
vartree=vartree,
treetype="bintree",
blockers=blockers)
retval = mylink.merge(pkgloc,
infloc,
myroot,
myebuild,
cleanup=0,
mydbapi=mydbapi,
prev_mtimes=prev_mtimes)
did_merge_phase = True
success = retval == os.EX_OK
return retval
finally:
mysettings.pop("PORTAGE_BINPKG_FILE", None)
if tbz2_lock:
portage.locks.unlockfile(tbz2_lock)
if True:
if not did_merge_phase:
# The merge phase handles this already. Callers don't know how
# far this function got, so we have to call elog_process() here
# so that it's only called once.
from portage.elog import elog_process
elog_process(mycat + "/" + mypkg, mysettings)
try:
if success:
shutil.rmtree(builddir)
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise
del e
def _start(self):
settings = self.settings
settings.setcpv(self.cpv)
ebuild_path = self.ebuild_path
eapi = None
if 'parse-eapi-glep-55' in settings.features:
pf, eapi = portage._split_ebuild_name_glep55(
os.path.basename(ebuild_path))
if eapi is None and \
'parse-eapi-ebuild-head' in settings.features:
eapi = portage._parse_eapi_ebuild_head(
codecs.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'],
errors='replace'))
if eapi is not None:
if not portage.eapi_is_supported(eapi):
self.metadata_callback(self.cpv, self.ebuild_path,
self.repo_path, {'EAPI' : eapi}, self.ebuild_mtime)
self.returncode = os.EX_OK
self.wait()
return
settings.configdict['pkg']['EAPI'] = eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
fd_pipes.setdefault(0, sys.stdin.fileno())
fd_pipes.setdefault(1, sys.stdout.fileno())
fd_pipes.setdefault(2, sys.stderr.fileno())
# flush any pending output
for fd in fd_pipes.values():
if fd == sys.stdout.fileno():
sys.stdout.flush()
if fd == sys.stderr.fileno():
sys.stderr.flush()
fd_pipes_orig = fd_pipes.copy()
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
fd_pipes[self._metadata_fd] = slave_fd
self._raw_metadata = []
files.ebuild = os.fdopen(master_fd, 'rb')
self._reg_id = self.scheduler.register(files.ebuild.fileno(),
self._registered_events, self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path, "depend",
settings["ROOT"], settings, debug,
mydbapi=self.portdb, tree="porttree",
fd_pipes=fd_pipes, returnpid=True)
os.close(slave_fd)
if isinstance(retval, int):
# doebuild failed before spawning
self._unregister()
self.returncode = retval
self.wait()
return
self.pid = retval[0]
portage.process.spawned_pids.remove(self.pid)
def doebuild(self, ebuild, arg):
settings = portage.config(clone=self.settings)
settings.unlock()
portage.doebuild(ebuild, arg, portage.root, settings, tree="porttree")
def _start(self):
ebuild_path = self.ebuild_hash.location
with io.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'],
errors='strict'),
mode='r',
encoding=_encodings['repo.content'],
errors='replace') as f:
self._eapi, self._eapi_lineno = portage._parse_eapi_ebuild_head(f)
parsed_eapi = self._eapi
if parsed_eapi is None:
parsed_eapi = "0"
if not parsed_eapi:
# An empty EAPI setting is invalid.
self._eapi_invalid(None)
self.returncode = 1
self._async_wait()
return
self.eapi_supported = portage.eapi_is_supported(parsed_eapi)
if not self.eapi_supported:
self.metadata = {"EAPI": parsed_eapi}
self.returncode = os.EX_OK
self._async_wait()
return
settings = self.settings
settings.setcpv(self.cpv)
settings.configdict['pkg']['EAPI'] = parsed_eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
null_input = open('/dev/null', 'rb')
fd_pipes.setdefault(0, null_input.fileno())
fd_pipes.setdefault(1, sys.__stdout__.fileno())
fd_pipes.setdefault(2, sys.__stderr__.fileno())
# flush any pending output
stdout_filenos = (sys.__stdout__.fileno(), sys.__stderr__.fileno())
for fd in fd_pipes.values():
if fd in stdout_filenos:
sys.__stdout__.flush()
sys.__stderr__.flush()
break
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
# FD_CLOEXEC is enabled by default in Python >=3.4.
if sys.hexversion < 0x3040000:
try:
fcntl.FD_CLOEXEC
except AttributeError:
pass
else:
fcntl.fcntl(
master_fd, fcntl.F_SETFD,
fcntl.fcntl(master_fd, fcntl.F_GETFD) | fcntl.FD_CLOEXEC)
fd_pipes[slave_fd] = slave_fd
settings["PORTAGE_PIPE_FD"] = str(slave_fd)
self._raw_metadata = []
files.ebuild = master_fd
self.scheduler.add_reader(files.ebuild, self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path,
"depend",
settings=settings,
debug=debug,
mydbapi=self.portdb,
tree="porttree",
fd_pipes=fd_pipes,
returnpid=True)
settings.pop("PORTAGE_PIPE_FD", None)
os.close(slave_fd)
null_input.close()
if isinstance(retval, int):
# doebuild failed before spawning
self.returncode = retval
self._async_wait()
return
self.pid = retval[0]
def _start(self):
ebuild_path = self.ebuild_hash.location
with io.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'],
errors='replace') as f:
self._eapi, self._eapi_lineno = portage._parse_eapi_ebuild_head(f)
parsed_eapi = self._eapi
if parsed_eapi is None:
parsed_eapi = "0"
if not parsed_eapi:
# An empty EAPI setting is invalid.
self._eapi_invalid(None)
self._set_returncode((self.pid, 1 << 8))
self.wait()
return
self.eapi_supported = portage.eapi_is_supported(parsed_eapi)
if not self.eapi_supported:
self.metadata = {"EAPI": parsed_eapi}
self._set_returncode((self.pid, os.EX_OK << 8))
self.wait()
return
settings = self.settings
settings.setcpv(self.cpv)
settings.configdict['pkg']['EAPI'] = parsed_eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
null_input = open('/dev/null', 'rb')
fd_pipes.setdefault(0, null_input.fileno())
fd_pipes.setdefault(1, sys.__stdout__.fileno())
fd_pipes.setdefault(2, sys.__stderr__.fileno())
# flush any pending output
stdout_filenos = (sys.__stdout__.fileno(), sys.__stderr__.fileno())
for fd in fd_pipes.values():
if fd in stdout_filenos:
sys.__stdout__.flush()
sys.__stderr__.flush()
break
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
fd_pipes[self._metadata_fd] = slave_fd
self._raw_metadata = []
files.ebuild = master_fd
self._reg_id = self.scheduler.register(files.ebuild,
self._registered_events, self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path, "depend",
settings=settings, debug=debug,
mydbapi=self.portdb, tree="porttree",
fd_pipes=fd_pipes, returnpid=True)
os.close(slave_fd)
null_input.close()
if isinstance(retval, int):
# doebuild failed before spawning
self._unregister()
self._set_returncode((self.pid, retval << 8))
self.wait()
return
self.pid = retval[0]
portage.process.spawned_pids.remove(self.pid)
def _run(self): return portage.doebuild(*self.doebuild_pargs, **self.doebuild_kwargs)
def _run(self):
return portage.doebuild(*self.doebuild_pargs, **self.doebuild_kwargs)
def _start(self):
settings = self.settings
settings.setcpv(self.cpv)
ebuild_path = self.ebuild_hash.location
# the caller can pass in eapi in order to avoid
# redundant _parse_eapi_ebuild_head calls
eapi = self.eapi
if eapi is None and \
'parse-eapi-ebuild-head' in settings.features:
with io.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'],
errors='replace') as f:
eapi = portage._parse_eapi_ebuild_head(f)
if eapi is not None:
if not portage.eapi_is_supported(eapi):
self.metadata = self.metadata_callback(self.cpv,
self.repo_path, {'EAPI' : eapi}, self.ebuild_hash)
self._set_returncode((self.pid, os.EX_OK << 8))
self.wait()
return
settings.configdict['pkg']['EAPI'] = eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
null_input = open('/dev/null', 'rb')
fd_pipes.setdefault(0, null_input.fileno())
fd_pipes.setdefault(1, sys.stdout.fileno())
fd_pipes.setdefault(2, sys.stderr.fileno())
# flush any pending output
for fd in fd_pipes.values():
if fd == sys.stdout.fileno():
sys.stdout.flush()
if fd == sys.stderr.fileno():
sys.stderr.flush()
fd_pipes_orig = fd_pipes.copy()
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
fd_pipes[self._metadata_fd] = slave_fd
self._raw_metadata = []
files.ebuild = os.fdopen(master_fd, 'rb', 0)
self._reg_id = self.scheduler.register(files.ebuild.fileno(),
self._registered_events, self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path, "depend",
settings=settings, debug=debug,
mydbapi=self.portdb, tree="porttree",
fd_pipes=fd_pipes, returnpid=True)
os.close(slave_fd)
null_input.close()
if isinstance(retval, int):
# doebuild failed before spawning
self._unregister()
self._set_returncode((self.pid, retval << 8))
self.wait()
return
self.pid = retval[0]
portage.process.spawned_pids.remove(self.pid)
def _start(self):
ebuild_path = self.ebuild_hash.location
with io.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'], errors='strict'),
mode='r', encoding=_encodings['repo.content'],
errors='replace') as f:
self._eapi, self._eapi_lineno = portage._parse_eapi_ebuild_head(f)
parsed_eapi = self._eapi
if parsed_eapi is None:
parsed_eapi = "0"
if not parsed_eapi:
# An empty EAPI setting is invalid.
self._eapi_invalid(None)
self.returncode = 1
self._async_wait()
return
self.eapi_supported = portage.eapi_is_supported(parsed_eapi)
if not self.eapi_supported:
self.metadata = {"EAPI": parsed_eapi}
self.returncode = os.EX_OK
self._async_wait()
return
settings = self.settings
settings.setcpv(self.cpv)
settings.configdict['pkg']['EAPI'] = parsed_eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
null_input = open('/dev/null', 'rb')
fd_pipes.setdefault(0, null_input.fileno())
fd_pipes.setdefault(1, sys.__stdout__.fileno())
fd_pipes.setdefault(2, sys.__stderr__.fileno())
# flush any pending output
stdout_filenos = (sys.__stdout__.fileno(), sys.__stderr__.fileno())
for fd in fd_pipes.values():
if fd in stdout_filenos:
sys.__stdout__.flush()
sys.__stderr__.flush()
break
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
# FD_CLOEXEC is enabled by default in Python >=3.4.
if sys.hexversion < 0x3040000:
try:
fcntl.FD_CLOEXEC
except AttributeError:
pass
else:
fcntl.fcntl(master_fd, fcntl.F_SETFD,
fcntl.fcntl(master_fd, fcntl.F_GETFD) | fcntl.FD_CLOEXEC)
fd_pipes[slave_fd] = slave_fd
settings["PORTAGE_PIPE_FD"] = str(slave_fd)
self._raw_metadata = []
files.ebuild = master_fd
self.scheduler.add_reader(files.ebuild, self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path, "depend",
settings=settings, debug=debug,
mydbapi=self.portdb, tree="porttree",
fd_pipes=fd_pipes, returnpid=True)
settings.pop("PORTAGE_PIPE_FD", None)
os.close(slave_fd)
null_input.close()
if isinstance(retval, int):
# doebuild failed before spawning
self.returncode = retval
self._async_wait()
return
self.pid = retval[0]
upstream_line = 'SRC_URI="https://github.com/lxc/lxd/archive/lxd-{}.tar.gz"\n'.format(
upstream_version)
foundline = False
with open(ebuildpath, "rt") as ebuildfile:
for line in ebuildfile.readlines():
if line == upstream_line:
foundline = True
break
if not foundline:
with open(ebuildpath, "a") as ebuildfile:
ebuildfile.write(upstream_line)
# Run through the unpack stage and stop
conf = portage.config()
portage.doebuild(ebuildpath, "clean", settings=conf, tree="porttree")
portage.doebuild(ebuildpath, "manifest", settings=conf, tree="porttree")
print('completed manifest')
portage.doebuild(ebuildpath, "unpack", settings=conf, tree="porttree")
print('completed unpack')
# unpack is racy on the first download
time.sleep(2)
# Shuffle workdir so it looks like a go hierarchy
# EGO_PN_PARENT="github.com/lxc"
# EGO_PN="${EGO_PN_PARENT}/lxd"
workdir = "/var/tmp/portage/app-emulation/lxd-{}/work".format(version)
port_s = path.join(workdir, "lxd-{}".format(upstream_version))
tmpsrctop = path.join(workdir, "lxdtmp")
def _start(self):
settings = self.settings
settings.setcpv(self.cpv)
ebuild_path = self.ebuild_hash.location
# the caller can pass in eapi in order to avoid
# redundant _parse_eapi_ebuild_head calls
eapi = self.eapi
if eapi is None and \
'parse-eapi-ebuild-head' in settings.features:
with io.open(_unicode_encode(ebuild_path,
encoding=_encodings['fs'],
errors='strict'),
mode='r',
encoding=_encodings['repo.content'],
errors='replace') as f:
eapi = portage._parse_eapi_ebuild_head(f)
if eapi is not None:
if not portage.eapi_is_supported(eapi):
self.metadata = self.metadata_callback(self.cpv,
self.repo_path,
{'EAPI': eapi},
self.ebuild_hash)
self._set_returncode((self.pid, os.EX_OK << 8))
self.wait()
return
settings.configdict['pkg']['EAPI'] = eapi
debug = settings.get("PORTAGE_DEBUG") == "1"
master_fd = None
slave_fd = None
fd_pipes = None
if self.fd_pipes is not None:
fd_pipes = self.fd_pipes.copy()
else:
fd_pipes = {}
null_input = open('/dev/null', 'rb')
fd_pipes.setdefault(0, null_input.fileno())
fd_pipes.setdefault(1, sys.stdout.fileno())
fd_pipes.setdefault(2, sys.stderr.fileno())
# flush any pending output
for fd in fd_pipes.values():
if fd == sys.stdout.fileno():
sys.stdout.flush()
if fd == sys.stderr.fileno():
sys.stderr.flush()
self._files = self._files_dict()
files = self._files
master_fd, slave_fd = os.pipe()
fcntl.fcntl(master_fd, fcntl.F_SETFL,
fcntl.fcntl(master_fd, fcntl.F_GETFL) | os.O_NONBLOCK)
fd_pipes[self._metadata_fd] = slave_fd
self._raw_metadata = []
files.ebuild = master_fd
self._reg_id = self.scheduler.register(files.ebuild,
self._registered_events,
self._output_handler)
self._registered = True
retval = portage.doebuild(ebuild_path,
"depend",
settings=settings,
debug=debug,
mydbapi=self.portdb,
tree="porttree",
fd_pipes=fd_pipes,
returnpid=True)
os.close(slave_fd)
null_input.close()
if isinstance(retval, int):
# doebuild failed before spawning
self._unregister()
self._set_returncode((self.pid, retval << 8))
self.wait()
return
self.pid = retval[0]
portage.process.spawned_pids.remove(self.pid)
# replace the custom SRC_URI with the proper upstream one
upstream_line = 'SRC_URI="https://github.com/lxc/lxd/archive/lxd-{}.tar.gz"\n'.format(upstream_version)
foundline = False
with open(ebuildpath,"rt") as ebuildfile:
for line in ebuildfile.readlines():
if line == upstream_line:
foundline = True
break
if not foundline:
with open(ebuildpath,"a") as ebuildfile:
ebuildfile.write(upstream_line)
# Run through the unpack stage and stop
conf = portage.config()
portage.doebuild(ebuildpath,"clean",settings=conf,tree="porttree")
portage.doebuild(ebuildpath,"manifest",settings=conf,tree="porttree")
print('completed manifest')
portage.doebuild(ebuildpath,"unpack",settings=conf,tree="porttree")
print('completed unpack')
# unpack is racy on the first download
time.sleep(2)
# Shuffle workdir so it looks like a go hierarchy
# EGO_PN_PARENT="github.com/lxc"
# EGO_PN="${EGO_PN_PARENT}/lxd"
workdir="/var/tmp/portage/app-emulation/lxd-{}/work".format(version)
port_s=path.join(workdir,"lxd-{}".format(upstream_version))
tmpsrctop=path.join(workdir,"lxdtmp")
