def sandbox_summary(self, move_log=False):
"""if the instance is sandboxed, print the sandbox access summary"""
if not os.path.exists(self.__sandbox_log):
self.write("end_sandbox_summary")
return 0
violations = portage_util.grabfile(self.__sandbox_log)
if len(violations) == 0:
self.write("end_sandbox_summary")
return 0
if not move_log:
move_log = self.__sandbox_log
elif move_log != self.__sandbox_log:
myf = open(move_log)
for x in violations:
myf.write(x + "\n")
myf.close()
from output import red
self.ebd_write.write(
red("--------------------------- ACCESS VIOLATION SUMMARY ---------------------------"
) + "\n")
self.ebd_write.write(red("LOG FILE = \"%s\"" % move_log) + "\n\n")
for x in violations:
self.ebd_write.write(x + "\n")
self.write(
red("--------------------------------------------------------------------------------"
) + "\n")
self.write("end_sandbox_summary")
try:
os.remove(self.__sandbox_log)
except (IOError, OSError), e:
print "exception caught when cleansing sandbox_log=%s" % str(e)
def git_merge_all(self,
from_branch,
to_branch,
working_path='/var/release'):
"""
Merge all Git Repositories from one branch into another.
:param from_branch: What branch to merge from
:param to_branch: What branch to merge into
:param working_path:
:return:
"""
if not os.path.exists(working_path):
# if path doesn't exist, create it:
os.mkdir(working_path)
os.chdir(working_path)
for repo in self.config.repositories:
os.chdir(working_path)
out(1, blue("\n------- REPO: " + repo + " -------"))
# see if the repo exists
path = working_path + '/' + repo
output = ''
try:
if not os.path.exists(path):
output += self.exec_shell('git clone ' + self.git_server +
'/' + repo + '.git ' + path)
if 'Access denied.' in output:
out(2, yellow('skipped'))
continue
os.chdir(path)
output += self.exec_shell('git reset --hard HEAD')
output += self.exec_shell(
'git checkout --force {}'.format(from_branch))
output += self.exec_shell('git pull')
output += self.exec_shell(
'git checkout --force {}'.format(to_branch))
output += self.exec_shell('git pull')
output += self.exec_shell('git merge {}'.format(from_branch))
output += self.exec_shell(
'git push origin {}'.format(to_branch))
for line in output.splitlines(True):
if line.startswith('error') or line.startswith('CONFLICT'):
out(2, red(line))
else:
out(2, green(line))
except Exception as e:
out(2, red('Error: '))
out(2, red(output))
out(2, red(e))
return False
return output
def check_cmd_exists(self, cmd):
"return the path of the specified command if it exists"
print blue("Checking for %s..." % cmd),
for path in os.environ['PATH'].split(os.path.pathsep):
if os.path.exists(os.path.join(path, cmd)):
print blue("'%s'" % os.path.join(path, cmd))
return 1
print red("not found.")
return 0
def git_merge_all(self, from_branch, to_branch, working_path='/var/release'):
"""
Merge all Git Repositories from one branch into another.
:param from_branch: What branch to merge from
:param to_branch: What branch to merge into
:param working_path:
:return:
"""
if not os.path.exists(working_path):
# if path doesn't exist, create it:
os.mkdir(working_path)
os.chdir(working_path)
for repo in self.config.repositories:
os.chdir(working_path)
out(1, blue("\n------- REPO: " + repo + " -------"))
# see if the repo exists
path = working_path+'/'+repo
output = ''
try:
if not os.path.exists(path):
output += self.exec_shell('git clone '+self.git_server+'/'+repo+'.git ' + path)
if 'Access denied.' in output:
out(2, yellow('skipped'))
continue
os.chdir(path)
output += self.exec_shell('git reset --hard HEAD')
output += self.exec_shell('git checkout --force {}'.format(from_branch))
output += self.exec_shell('git pull')
output += self.exec_shell('git checkout --force {}'.format(to_branch))
output += self.exec_shell('git pull')
output += self.exec_shell('git merge {}'.format(from_branch))
output += self.exec_shell('git push origin {}'.format(to_branch))
for line in output.splitlines(True):
if line.startswith('error') or line.startswith('CONFLICT'):
out(2, red(line))
else:
out(2, green(line))
except Exception as e:
out(2, red('Error: '))
out(2, red(output))
out(2, red(e))
return False
return output
def start_ssh(self, url):
"""
start an ssh connection
:param url:
:return:
"""
# use current user if none was passed in.
if self.ssh_user is None:
self.ssh_user = getpass.getuser()
# if we haven't already started this connection, start it
if url not in self.connections:
try:
# paramiko.util.log_to_file("paramiko.log")
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.allow_agent = False
ssh.connect(url, username=self.ssh_user, password=self.pw)
except Exception as e:
out(0, red("SSH connection to {} failed: ".format(url)))
print(e)
return False
# add this connection to the list of open connections
self.connections[url] = ssh
# set ssh_alias as the current connection key to be used in exec_shell
self.current_conn_key = url
return True
def start_ssh(self, url):
"""
start an ssh connection
:param url:
:return:
"""
# use current user if none was passed in.
if self.ssh_user is None:
self.ssh_user = getpass.getuser()
# if we haven't already started this connection, start it
if url not in self.connections:
try:
# paramiko.util.log_to_file("paramiko.log")
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.allow_agent = False
ssh.connect(url, username=self.ssh_user, password=self.pw)
except Exception as e:
out(0, red("SSH connection to {} failed: ".format(url)))
print(e)
return False
# add this connection to the list of open connections
self.connections[url] = ssh
# set ssh_alias as the current connection key to be used in exec_shell
self.current_conn_key = url
return True
def copy_and_swigify_headers(self, includedir, dirname, files):
"""Copy the header files to the local include directories. Add an
#include line at the beginning for the SWIG interface files..."""
for file in files:
if not os.path.isfile(os.path.join(dirname, file)):
continue
if file[-2:] == ".i":
file_i = os.path.join(dirname, file)
file_h = os.path.join(dirname, file)[:-2] + ".h"
if (not os.path.exists(file_h)
and os.path.exists(os.path.join(includedir, file_h))):
shutil.copyfile(os.path.join(includedir, file_h), file_h)
sys.stdout.write(' ' + turquoise(file_h))
fd = open(file_h, 'r+')
contents = fd.readlines()
ins_line_nr = -1
for line in contents:
ins_line_nr += 1
if line.find("#include ") != -1:
break
if ins_line_nr != -1:
contents.insert(ins_line_nr,
self.pivy_header_include % (file_i))
fd.seek(0)
fd.writelines(contents)
else:
print blue("[") + red("failed") + blue("]")
sys.exit(1)
fd.close
# fixes for SWIG 1.3.21 and upwards
# (mostly workarounding swig's preprocessor "function like macros"
# preprocessor bug when no parameters are provided which then results
# in no constructors being created in the wrapper)
elif file[-4:] == ".fix":
sys.stdout.write(' ' + red(os.path.join(dirname, file)[:-4]))
shutil.copyfile(os.path.join(dirname, file),
os.path.join(dirname, file)[:-4])
# had to introduce this because windows is a piece of crap
elif sys.platform == "win32" and file[-6:] == ".win32":
sys.stdout.write(' ' + red(os.path.join(dirname, file)[:-6]))
shutil.copyfile(os.path.join(dirname, file),
os.path.join(dirname, file)[:-6])
def printFlags(self):
print output.white("\nFlags set:")
keys = self.initflags.keys()
keys.sort()
for key in keys:
if self.initflags[key]:
print key + " "*(self.flag_width-len(str(key))) + output.green("On")
else:
print key + " "*(self.flag_width-len(str(key))) + output.red("Off")
def swig_generate(self):
"build all available modules"
for module in self.MODULES:
module_name = self.MODULES[module][0]
config_cmd = self.MODULES[module][1]
module_pkg_name = self.MODULES[module][2]
mod_out_prefix = module_pkg_name.replace('.', os.sep) + module
if sys.platform == "win32":
INCLUDE_DIR = os.getenv("COIN3DDIR") + "\\include"
CPP_FLAGS = "-I" + INCLUDE_DIR + " " + \
"-I" + os.getenv("COIN3DDIR") + "\\include\\Inventor\\annex" + \
" /DSOWIN_DLL /DCOIN_DLL /wd4244 /wd4049"
LDFLAGS_LIBS = os.getenv("COIN3DDIR") + "\\lib\\coin2.lib " + \
os.getenv("COIN3DDIR") + "\\lib\\sowin1.lib"
else:
INCLUDE_DIR = self.do_os_popen("coin-config --includedir")
CPP_FLAGS = self.do_os_popen("%s --cppflags" % config_cmd)
LDFLAGS_LIBS = self.do_os_popen("%s --ldflags --libs" %
config_cmd)
self.CXX_INCS = self.CXX_INCS + ' ' + CPP_FLAGS #G.Barrand
if not os.path.isfile(mod_out_prefix + "_wrap.cpp"):
print red("\n=== Generating %s_wrap.cpp for %s ===\n" %
(mod_out_prefix, module))
print blue(
self.SWIG + " " + self.SWIG_SUPPRESS_WARNINGS + " " +
self.SWIG_PARAMS %
(INCLUDE_DIR, self.CXX_INCS, mod_out_prefix, module))
if os.system(
self.SWIG + " " + self.SWIG_SUPPRESS_WARNINGS + " " +
self.SWIG_PARAMS %
(INCLUDE_DIR, self.CXX_INCS, mod_out_prefix, module)):
print red(
"SWIG did not generate wrappers successfully! ** Aborting **"
)
sys.exit(1)
else:
print red("=== %s_wrap.cpp for %s already exists! ===" %
(mod_out_prefix, module_pkg_name + module))
self.ext_modules.append(
Extension(
module_name, [mod_out_prefix + "_wrap.cpp"],
extra_compile_args=(self.CXX_INCS + CPP_FLAGS).split(),
extra_link_args=(self.CXX_LIBS + LDFLAGS_LIBS).split()))
self.py_modules.append(module_pkg_name + module)
print "!!! Cannot create log... No write access / Does not exist"
print "!!! PORT_LOGDIR:",mysettings["PORT_LOGDIR"]
mysettings["PORT_LOGDIR"]=""
# if any of these are being called, handle them -- running them out of the sandbox -- and stop now.
if mydo in ["help","setup"]:
return 0
# return spawn(EBUILD_SH_BINARY+" "+mydo,mysettings,debug=debug,free=1,logfile=logfile)
elif mydo in ["prerm","postrm","preinst","postinst","config"]:
mysettings.load_infodir(pkg_dir)
if not use_info_env:
print "overloading port_env_file setting to %s" % mysettings["T"]+"/environment"
mysettings["PORT_ENV_FILE"] = mysettings["T"] + "/environment"
if not os.path.exists(mysettings["PORT_ENV_FILE"]):
from output import red
print red("!!!")+" err.. it doesn't exist. that's bad."
sys.exit(1)
return 0
# return spawn(EBUILD_SH_BINARY+" "+mydo,mysettings,debug=debug,free=1,logfile=logfile)
try:
mysettings["SLOT"], mysettings["RESTRICT"] = db["/"]["porttree"].dbapi.aux_get(mycpv,["SLOT","RESTRICT"])
except (IOError,KeyError):
print red("doebuild():")+" aux_get() error reading "+mycpv+"; aborting."
sys.exit(1)
#initial dep checks complete; time to process main commands
nosandbox=(("userpriv" in features) and ("usersandbox" not in features))
actionmap={
"depend": { "args":(0,1)}, # sandbox / portage
Inter-Organisational Intrusion Detection System (IOIDS) Check README in the IOIDS folder for more information. @author: Michael Pilgermann @contact: mailto:[email protected] @license: GPL (General Public License) """ import output from sys import stdout oneindent = ' ' * 3 SUCESS_POS = output.green(' OK ') SUCESS_NEG = output.red('FAILED') SUCESS_SKIP = output.yellow(' SKIP ') SUCESS_WARN = output.yellow(' !! ') COLUMN_SUCESS = 80 COLUMN_INPUT = 70 LENGTH_LINE = 89 def printAction(indent, text, linebreak = 0, out = stdout): """ Prints a line for an action and puts the cursor on a predefined column. Usually, no line break is written, the line should be finished after performing an action using the function L{finishActionLine}. """
# Setup file for the Pivy distribution.
#
import os, shutil, sys
from distutils.command.build import build
from distutils.command.clean import clean
from distutils.command.install import install
from distutils.core import setup
from distutils.extension import Extension
from distutils import sysconfig
# if we are on a Gentoo box salute the chap and output stuff in nice colors
# Gentoo is Python friendly, so be especially friendly to them! ;)
try:
from output import green, blue, turquoise, red, yellow
print red("Oooh, it's a Gentoo! Nice nice! tuhtah salutes you! :)")
except:
def red(text):
return text
def green(text):
return text
def blue(text):
return text
def turquoise(text):
return text
def yellow(text):
def check_python_version(self):
"check the Python version"
print blue("Python version...%s" % sys.version.split(" ")[0])
if int(sys.version[0]) < 2:
print red("Pivy only works with Python versions >= 2.0.")
sys.exit(1)
def svnerr(message):
sys.stderr.write(output.red(" SVN: ") + message + "\n")
def eerror(message):
sys.stderr.write(output.red(" * ") + message + "\n")
def process_phase(self,phase,mysettings,myebuild,myroot,allstages=False,**keywords):
"""the public 'doebuild' interface- all phases are called here, along w/ a valid config
allstages is the equivalent of 'do merge, and all needed phases to get to it'
**keywords is options passed on to __adjust_env. It will be removed as __adjust_env is digested"""
from portage import merge,unmerge,features
validcommands = ["help","clean","prerm","postrm","preinst","postinst",
"config","setup","depend","fetch","digest",
"unpack","compile","test","install","rpm","qmerge","merge",
"package","unmerge", "manifest"]
if phase not in validcommands:
validcommands.sort()
writemsg("!!! doebuild: '%s' is not one of the following valid commands:" % phase)
for vcount in range(len(validcommands)):
if vcount%6 == 0:
writemsg("\n!!! ")
writemsg(string.ljust(validcommands[vcount], 11))
writemsg("\n")
return 1
retval=self.__adjust_env(phase,mysettings,myebuild,myroot,**keywords)
if retval:
return retval
if "userpriv" in features:
sandbox = ("usersandbox" in features)
else:
sandbox = ("sandbox" in features)
droppriv=(("userpriv" in features) and \
("nouserpriv" not in string.split(mysettings["PORTAGE_RESTRICT"])) and portage_exec.userpriv_capable)
use_fakeroot=(("userpriv_fakeroot" in features) and droppriv and portage_exec.fakeroot_capable)
# basically a nasty graph of 'w/ this phase, have it userprived/sandboxed/fakeroot', and run
# these phases prior
actionmap={
"depend": { "sandbox":False, "userpriv":True, "fakeroot":False},
"setup": { "sandbox":True, "userpriv":False, "fakeroot":False},
"unpack": {"dep":"setup", "sandbox":sandbox, "userpriv":True, "fakeroot":False},
"compile": {"dep":"unpack", "sandbox":sandbox,"userpriv":True, "fakeroot":False},
"test": {"dep":"compile","sandbox":sandbox,"userpriv":True, "fakeroot":False},
"install": {"dep":"test", "sandbox":(not use_fakeroot or (not use_fakeroot and sandbox)),
"userpriv":use_fakeroot,"fakeroot":use_fakeroot},
"rpm": {"dep":"install","sandbox":False, "userpriv":use_fakeroot, "fakeroot":use_fakeroot},
"package": {"dep":"install", "sandbox":False, "userpriv":use_fakeroot, "fakeroot":use_fakeroot},
"merge" : {"dep":"install", "sandbox":True, "userpriv":False, "fakeroot":False}
}
merging=False
# this shouldn't technically ever be called, get_keys exists for this.
# left in for compatability while portage.doebuild still exists
if phase=="depend":
return retval
elif phase=="unmerge":
return unmerge(mysettings["CATEGORY"],mysettings["PF"],myroot,mysettings)
elif phase in ["fetch","digest","manifest","clean"]:
return retval
elif phase=="merge":
merging=True
elif phase=="qmerge":
#no phases ran.
phase="merge"
merging=True
# return merge(mysettings["CATEGORY"],mysettings["PF"],mysettings["D"],mysettings["PORTAGE_BUILDDIR"]+"/build-info",myroot,\
# mysettings)
elif phase in ["help","clean","prerm","postrm","preinst","postinst","config"]:
self.__ebp = request_ebuild_processor(userpriv=False)
self.__ebp.write("process_ebuild %s" % phase)
self.__ebp.send_env(mysettings)
self.__ebp.set_sandbox_state(phase in ["help","clean"])
self.__ebp.write("start_processing")
retval = self.__generic_phase([],mysettings)
release_ebuild_processor(self.__ebp)
self.__ebp = None
return not retval
k=phase
# represent the phases to run, grouping each phase based upon if it's sandboxed, fakerooted, and userpriv'd
# ugly at a glance, but remember a processor can run multiple phases now.
# best to not be wasteful in terms of env saving/restoring, and just run all applicable phases in one shot
phases=[[[phase]]]
sandboxed=[[actionmap[phase]["sandbox"]]]
privs=[(actionmap[phase]["userpriv"],actionmap[phase]["fakeroot"])]
if allstages:
while actionmap[k].has_key("dep"):
k=actionmap[k]["dep"]
if actionmap[k]["userpriv"] != privs[-1][0] or actionmap[k]["fakeroot"] != privs[-1][1]:
phases.append([[k]])
sandboxed.append([actionmap[k]["sandbox"]])
privs.append((actionmap[k]["userpriv"],actionmap[k]["fakeroot"]))
elif actionmap[k]["sandbox"] != sandboxed[-1][-1]:
phases[-1].append([k])
sandboxed[-1].extend([actionmap[k]["sandbox"]])
else:
phases[-1][-1].append(k)
privs.reverse()
phases.reverse()
sandboxed.reverse()
for x in phases:
for y in x:
y.reverse()
x.reverse()
# and now we have our phases grouped in parallel to the sandbox/userpriv/fakeroot state.
all_phases = portage_util.flatten(phases)
# print "all_phases=",all_phases
# print "phases=",phases
# print "sandbox=",sandboxed
# print "privs=",privs
# sys.exit(1)
# print "\n\ndroppriv=",droppriv,"use_fakeroot=",use_fakeroot,"\n\n"
#temporary hack until sandbox + fakeroot (if ever) play nice.
while privs:
if self.__ebp == None or (droppriv and self.__ebp.userprived() != privs[0][0]) or \
(use_fakeroot and self.__ebp.fakerooted() != privs[0][1]):
if self.__ebp != None:
print "swapping processors for",phases[0][0]
release_ebuild_processor(self.__ebp)
self.__ebp = None
opts={}
#only engage fakeroot when userpriv'd
if use_fakeroot and privs[0][1]:
opts["save_file"] = mysettings["T"]+"/fakeroot_db"
self.__ebp = request_ebuild_processor(userpriv=(privs[0][0] and droppriv), \
fakeroot=(privs[0][1] and use_fakeroot), \
sandbox=(not (privs[0][1] and use_fakeroot) and portage_exec.sandbox_capable),**opts)
#loop through the instances where the processor must have the same sandboxed state-
#note a sandbox'd process can have it's sandbox disabled.
#this seperation is needed since you can't mix sandbox and fakeroot atm.
for sandbox in sandboxed[0]:
if "merge" in phases[0][0]:
if len(phases[0][0]) == 1:
print "skipping this phase, it's just merge"
continue
phases[0][0].remove("merge")
self.__ebp.write("process_ebuild %s" % string.join(phases[0][0]," "))
self.__ebp.send_env(mysettings)
self.__ebp.set_sandbox_state(sandbox)
self.__ebp.write("start_processing")
phases[0].pop(0)
retval = not self.__generic_phase([],mysettings)
if retval:
release_ebuild_processor(self.__ebp)
self.__ebp = None
return retval
sandboxed.pop(0)
privs.pop(0)
phases.pop(0)
# hey hey. we're done. Now give it back.
release_ebuild_processor(self.__ebp)
self.__ebp = None
# packaging moved out of ebuild.sh, and into this code.
# makes it so ebuild.sh no longer must run as root for the package phase.
if "package" in all_phases:
print "processing package"
#mv "${PF}.tbz2" "${PKGDIR}/All"
if not os.path.exists(mysettings["PKGDIR"]+"/All"):
os.makedirs(mysettings["PKGDIR"]+"/All")
if not os.path.exists(mysettings["PKGDIR"]+"/"+mysettings["CATEGORY"]):
os.makedirs(mysettings["PKGDIR"]+"/"+mysettings["CATEGORY"])
if os.path.exists("%s/All/%s.tbz2" % (mysettings["PKGDIR"],mysettings["PF"])):
os.remove("%s/All/%s.tbz2" % (mysettings["PKGDIR"],mysettings["PF"]))
retval = not portage_util.movefile("%s/%s.tbz2" % (mysettings["PORTAGE_BUILDDIR"],mysettings["PF"]),
mysettings["PKGDIR"]+"/All/"+mysettings["PF"]+".tbz2") > 0
if retval: return False
if os.path.exists("%s/%s/%s.tbz2" % (mysettings["PKGDIR"],mysettings["CATEGORY"],mysettings["PF"])):
os.remove("%s/%s/%s.tbz2" % (mysettings["PKGDIR"],mysettings["CATEGORY"],mysettings["PF"]))
os.symlink("%s/All/%s.tbz2" % (mysettings["PKGDIR"],mysettings["PF"]),
"%s/%s/%s.tbz2" % (mysettings["PKGDIR"],mysettings["CATEGORY"],mysettings["PF"]))
#same as the package phase above, removes the root requirement for the rpm phase.
if "rpm" in all_phases:
rpm_name="%s-%s-%s" % (mysettings["PN"],mysettings["PV"],mysettings["PR"])
retval = not portage_util.movefile("%s/%s.tar.gz" % (mysettings["T"],mysettings["PF"]),
"/usr/src/redhat/SOURCES/%s.tar.gz" % mysettings["PF"]) > 0
if retval:
print "moving src for rpm failed, retval=",retval
return False
retval=portage_exec.spawn(("rpmbuild","-bb","%s/%s.spec" % \
(mysettings["PORTAGE_BUILDDIR"],mysettings["PF"])))
if retval:
print "Failed to integrate rpm spec file"
return retval
if not os.path.exists(mysettings["RPMDIR"]+"/"+mysettings["CATEGORY"]):
os.makedirs(mysettings["RPMDIR"]+"/"+mysettings["CATEGORY"])
retval = not portage_util.movefile("/usr/src/redhat/RPMS/i386/%s.i386.rpm" % rpm_name,
"%s/%s/%s.rpm" % (mysettings["RPMDIR"],mysettings["CATEGORY"],rpm_name)) > 0
if retval:
print "rpm failed"
return retval
# not great check, but it works.
# basically, if FEATURES="-buildpkg" emerge package was called, the files in the current
# image directory don't have their actual perms. so we use an ugly bit of bash
# to make the fakeroot (claimed) permissions/owners a reality.
if use_fakeroot and os.path.exists(mysettings["T"]+"/fakeroot_db") and merging:
print "correcting fakeroot privs"
retval=portage_exec.spawn(("/usr/lib/portage/bin/affect-fakeroot-perms.sh", \
mysettings["T"]+"/fakeroot_db", \
mysettings["D"]),env={"BASHRC":portage_const.INVALID_ENV_FILE})
if retval or retval == None:
print red("!!!")+"affecting fakeroot perms after the fact failed"
return retval
if merging:
print "processing merge"
retval = merge(mysettings["CATEGORY"],mysettings["PF"],mysettings["D"],mysettings["PORTAGE_BUILDDIR"]+"/build-info",myroot,\
mysettings,myebuild=mysettings["EBUILD"])
return retval
def logfe(s): m = "Fatal error: " + output.red(s) p(m)
def printStatus(self, success):
if (success):
print " "*70 + output.white("[") + output.green("done") + output.white("]")
else:
print " "*70 + output.white("[") + output.red("failed") + output.white("]")
from output import green, red
ostype = os.uname()[0]
lchown = None
if ostype == "Linux":
userland = "GNU"
os.environ["XARGS"] = "xargs -r"
elif ostype in ["Darwin", "FreeBSD", "OpenBSD"]:
if ostype == "Darwin":
lchown = os.chown
userland = "BSD"
os.environ["XARGS"] = "xargs"
else:
writemsg(
red("Operating system") + " \"" + ostype + "\" " +
red("currently unsupported. Exiting.") + "\n")
sys.exit(1)
if not lchown:
if "lchown" in dir(os):
# Included in python-2.3
lchown = os.lchown
else:
import missingos
lchown = missingos.lchown
os.environ["USERLAND"] = userland
#Secpass will be set to 1 if the user is root or in the portage group.
secpass = 0
def load_confcache(self,transfer_to,confcache=portage_const.CONFCACHE_FILE,
confcache_list=portage_const.CONFCACHE_LIST):
"""verifys a requested conf cache, removing the global cache if it's stale.
The handler should be the only one to call this"""
from portage_checksum import perform_md5
from output import red
if not self.__ebp:
import traceback
traceback.print_stack()
print "err... no ebp, yet load_confcache called. invalid"
raise Exception,"load_confcache called yet no running processor. bug?"
valid=True
lock=None
if not os.path.exists(confcache_list):
print "confcache file listing doesn't exist"
valid=False
elif not os.path.exists(confcache):
print "confcache doesn't exist"
valid=False
else:
lock=portage_locks.lockfile(confcache_list,wantnewlockfile=1)
try:
myf=anydbm.open(confcache_list, "r", 0664)
for l in myf.keys():
# file, md5
if perform_md5(l,calc_prelink=1) != myf[l]:
print red("***")+" confcache is stale: %s: recorded md5: %s: actual: %s:" % (l,myf[l],perform_md5(l,calc_prelink=1))
raise Exception("md5 didn't match")
myf.close()
# verify env now.
new_cache=[]
env_vars=[]
# guessing on THOST. I'm sure it's wrong...
env_translate={"build_alias":"CBUILD","host_alias":"CHOST","target_alias":"THOST"}
cache=portage_util.grabfile(confcache)
x=0
while x < len(cache):
#ac_cv_env
if cache[x][0:10] == "ac_cv_env_":
f=cache[x][10:].find("_set")
if f == -1 or f==11:
cache.pop(x)
continue
env_vars.append(cache[x][10:10 + cache[x][10:].find("_set")])
x += 1
else:
new_cache.append(cache[x])
x += 1
for x in env_vars:
self.__ebp.write("request %s" % env_translate.get(x,x))
line=self.__ebp.read()
if line[-1] == "\n":
line=line[:-1]
new_cache.append("ac_cv_env_%s_set=%s" % (x, line))
if line == "unset":
new_cache.append("ac_cv_env_%s_value=" % x)
else:
line=self.__ebp.read()
if line[-1] == "\n":
line=line[:-1]
if line.split()[0] != line:
#quoting... XXX
new_cache.append("ac_cv_env_%s_value='%s'" % (x,line))
else:
new_cache.append("ac_cv_env_%s_value=%s" % (x,line))
myf=open(confcache,"w")
for x in new_cache:
myf.write(x+"\n")
myf.close()
except SystemExit, e:
raise
except Exception,e:
print "caught exception: %s" % str(e)
try: myf.close()
except (IOError, OSError): pass
valid=False
