def handle(config, options, args):
"""@type config: L{zeroinstall.injector.config.Config}
@type args: [str]"""
if len(args) < 1:
raise UsageError()
prog_args = args[1:]
def test_callback(sels):
from zeroinstall.injector import run
return run.test_selections(sels, prog_args,
False, # dry-run
options.main)
app = config.app_mgr.lookup_app(args[0], missing_ok = True)
if app is not None:
sels = app.get_selections(may_update = True, use_gui = options.gui)
r = app.get_requirements()
do_select = r.parse_update_options(options)
iface_uri = sels.interface
else:
iface_uri = model.canonical_iface_uri(args[0])
do_select = True
if do_select or options.gui:
sels = select.get_selections(config, options, iface_uri,
select_only = False, download_only = False,
test_callback = test_callback)
if not sels:
sys.exit(1) # Aborted by user
from zeroinstall.injector import run
run.execute_selections(sels, prog_args, dry_run = options.dry_run, main = options.main, wrapper = options.wrapper, stores = config.stores)
def testAbsMain(self):
with tempfile.NamedTemporaryFile(prefix='test-', delete=False) as tmp:
tmp.write(("""<?xml version="1.0" ?>
<interface last-modified="1110752708"
uri="%s"
xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
<name>Foo</name>
<summary>Foo</summary>
<description>Foo</description>
<group main='/bin/sh'>
<implementation id='.' version='1'/>
</group>
</interface>""" % foo_iface_uri).encode('utf-8'))
driver = Driver(requirements=Requirements(tmp.name),
config=self.config)
try:
downloaded = driver.solve_and_download_impls()
if downloaded:
tasks.wait_for_blocker(downloaded)
run.execute_selections(driver.solver.selections, [],
stores=self.config.stores)
assert False
except SafeException as ex:
assert 'Command path must be relative' in str(ex), ex
def handle(config, options, args):
"""@type config: L{zeroinstall.injector.config.Config}
@type args: [str]"""
if len(args) < 1:
raise UsageError()
prog_args = args[1:]
def test_callback(sels):
from zeroinstall.injector import run
return run.test_selections(sels, prog_args,
False, # dry-run
options.main)
app = config.app_mgr.lookup_app(args[0], missing_ok = True)
if app is not None:
sels = app.get_selections(may_update = True, use_gui = options.gui)
r = app.get_requirements()
do_select = r.parse_update_options(options) or options.refresh
iface_uri = sels.interface
else:
iface_uri = model.canonical_iface_uri(args[0])
r = None
do_select = True
if do_select or options.gui:
sels = select.get_selections(config, options, iface_uri,
select_only = False, download_only = False,
test_callback = test_callback,
requirements = r)
if not sels:
sys.exit(1) # Aborted by user
from zeroinstall.injector import run
run.execute_selections(sels, prog_args, dry_run = options.dry_run, main = options.main, wrapper = options.wrapper, stores = config.stores)
def testAbsMain(self):
p = Driver(requirements=Requirements(command_feed), config=self.config)
self.config.handler.wait_for_blocker(p.solve_with_downloads())
old_stdout = sys.stdout
try:
sys.stdout = StringIO()
run.execute_selections(p.solver.selections, [],
main='/runnable/runner',
dry_run=True,
stores=self.config.stores)
finally:
sys.stdout = old_stdout
try:
old_stdout = sys.stdout
try:
sys.stdout = StringIO()
run.execute_selections(p.solver.selections, [],
main='/runnable/not-there',
dry_run=True,
stores=self.config.stores)
finally:
sys.stdout = old_stdout
except SafeException as ex:
assert 'not-there' in unicode(ex)
def download_and_execute(driver, prog_args, main=None, dry_run=False):
driver_download(driver)
run.execute_selections(driver.solver.selections,
prog_args,
stores=driver.config.stores,
main=main,
dry_run=dry_run)
def download_and_execute(policy, prog_args, main=None):
downloaded = policy.solve_and_download_impls()
if downloaded:
policy.config.handler.wait_for_blocker(downloaded)
run.execute_selections(policy.solver.selections,
prog_args,
stores=policy.config.stores,
main=main)
def download_and_execute(driver, prog_args, main=None, dry_run=True):
downloaded = driver.solve_and_download_impls()
if downloaded:
tasks.wait_for_blocker(downloaded)
run.execute_selections(driver.solver.selections,
prog_args,
stores=driver.config.stores,
main=main,
dry_run=dry_run)
def testCommandBindings(self): p = policy.Policy(command_feed, config = self.config) self.config.handler.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], main = 'runner', dry_run = True, stores = self.config.stores) finally: sys.stdout = old_stdout assert 'local' in os.environ['LOCAL'], os.environ['LOCAL']
def testArgs(self): p = policy.Policy(runnable, config = self.config) self.config.handler.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], dry_run = True, stores = self.config.stores) out = sys.stdout.getvalue() finally: sys.stdout = old_stdout assert 'runner-arg' in out, out
def testArgs(self): p = Driver(requirements = Requirements(runnable), config = self.config) self.config.handler.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], dry_run = True, stores = self.config.stores) out = sys.stdout.getvalue() finally: sys.stdout = old_stdout assert 'runner-arg' in out, out
def testArgList(self): d = Driver(requirements = Requirements(arglist), config = self.config) self.config.handler.wait_for_blocker(d.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(d.solver.selections, [], dry_run = True, stores = self.config.stores) out = sys.stdout.getvalue() finally: sys.stdout = old_stdout assert 'arg-for-runner -X ra1 -X ra2' in out, out assert 'command-arg ca1 ca2' in out, out
def testWrapper(self): p = policy.Policy(runnable, config = self.config) self.config.handler.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], wrapper = 'echo', dry_run = True, stores = self.config.stores) out = sys.stdout.getvalue() finally: sys.stdout = old_stdout assert '/bin/sh -c echo "$@"' in out, out assert 'runner-arg' in out, out assert 'script' in out, out
def testCommandBindings(self): if 'SELF_COMMAND' in os.environ: del os.environ['SELF_COMMAND'] p = Driver(requirements = Requirements(command_feed), config = self.config) tasks.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], main = 'runnable/go.sh', dry_run = True, stores = self.config.stores) finally: sys.stdout = old_stdout assert 'local' in os.environ['LOCAL'], os.environ['LOCAL'] assert 'SELF_COMMAND' in os.environ
def testArgList(self):
d = Driver(requirements=Requirements(arglist), config=self.config)
self.config.handler.wait_for_blocker(d.solve_with_downloads())
old_stdout = sys.stdout
try:
sys.stdout = StringIO()
run.execute_selections(d.solver.selections, [],
dry_run=True,
stores=self.config.stores)
out = sys.stdout.getvalue()
finally:
sys.stdout = old_stdout
assert 'arg-for-runner -X ra1 -X ra2' in out, out
assert 'command-arg ca1 ca2' in out, out
def testWrapper(self):
p = Driver(requirements=Requirements(runnable), config=self.config)
self.config.handler.wait_for_blocker(p.solve_with_downloads())
old_stdout = sys.stdout
try:
sys.stdout = StringIO()
run.execute_selections(p.solver.selections, [],
wrapper='echo',
dry_run=True,
stores=self.config.stores)
out = sys.stdout.getvalue()
finally:
sys.stdout = old_stdout
assert '/bin/sh -c echo "$@"' in out, out
assert 'runner-arg' in out, out
assert 'script' in out, out
def testCommandBindings(self):
if 'SELF_COMMAND' in os.environ:
del os.environ['SELF_COMMAND']
p = Driver(requirements=Requirements(command_feed), config=self.config)
tasks.wait_for_blocker(p.solve_with_downloads())
old_stdout = sys.stdout
try:
sys.stdout = StringIO()
run.execute_selections(p.solver.selections, [],
main='runnable/go.sh',
dry_run=True,
stores=self.config.stores)
finally:
sys.stdout = old_stdout
assert 'local' in os.environ['LOCAL'], os.environ['LOCAL']
assert 'SELF_COMMAND' in os.environ
def handle(config, options, args):
if len(args) < 1:
raise UsageError()
prog_args = args[1:]
def test_callback(sels):
from zeroinstall.injector import run
return run.test_selections(
sels,
prog_args,
False, # dry-run
options.main)
app = config.app_mgr.lookup_app(args[0], missing_ok=True)
if app is not None:
sels = app.get_selections(may_update=True)
r = app.get_requirements()
do_select = r.parse_update_options(options)
iface_uri = sels.interface
else:
iface_uri = model.canonical_iface_uri(args[0])
do_select = True
if do_select or options.gui:
sels = select.get_selections(config,
options,
iface_uri,
select_only=False,
download_only=False,
test_callback=test_callback)
if not sels:
sys.exit(1) # Aborted by user
else:
dl = app.download_selections(sels)
if dl:
tasks.wait_for_blocker(dl)
tasks.check(dl)
from zeroinstall.injector import run
run.execute_selections(sels,
prog_args,
dry_run=options.dry_run,
main=options.main,
wrapper=options.wrapper,
stores=config.stores)
def testBadMain(self):
r = Requirements(command_feed)
r.command = None
d = Driver(requirements = r, config = self.config)
self.config.handler.wait_for_blocker(d.solve_with_downloads())
try:
run.execute_selections(d.solver.selections, [], dry_run = True, stores = self.config.stores)
assert 0
except SafeException as ex:
self.assertEqual("Can't run: no command specified!", unicode(ex))
try:
run.execute_selections(d.solver.selections, [], main = 'relpath', dry_run = True, stores = self.config.stores)
assert 0
except SafeException as ex:
self.assertEqual("Can't use a relative replacement main when there is no original one!", unicode(ex))
def testAbsMain(self): p = Driver(requirements = Requirements(command_feed), config = self.config) self.config.handler.wait_for_blocker(p.solve_with_downloads()) old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], main = '/runnable/runner', dry_run = True, stores = self.config.stores) finally: sys.stdout = old_stdout try: old_stdout = sys.stdout try: sys.stdout = StringIO() run.execute_selections(p.solver.selections, [], main = '/runnable/not-there', dry_run = True, stores = self.config.stores) finally: sys.stdout = old_stdout except SafeException as ex: assert 'not-there' in unicode(ex)
def handle(config, options, args): if len(args) < 1: raise UsageError() iface_uri = model.canonical_iface_uri(args[0]) prog_args = args[1:] def test_callback(sels): from zeroinstall.injector import run return run.test_selections(sels, prog_args, False, # dry-run options.main) sels = select.get_selections(config, options, iface_uri, select_only = False, download_only = False, test_callback = test_callback) if not sels: sys.exit(1) # Aborted by user from zeroinstall.injector import run run.execute_selections(sels, prog_args, dry_run = options.dry_run, main = options.main, wrapper = options.wrapper, stores = config.stores)
def testAbsMain(self):
with tempfile.NamedTemporaryFile(prefix = 'test-', delete = False) as tmp:
tmp.write((
"""<?xml version="1.0" ?>
<interface last-modified="1110752708"
uri="%s"
xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
<name>Foo</name>
<summary>Foo</summary>
<description>Foo</description>
<group main='/bin/sh'>
<implementation id='.' version='1'/>
</group>
</interface>""" % foo_iface_uri).encode('utf-8'))
driver = Driver(requirements = Requirements(tmp.name), config = self.config)
try:
downloaded = driver.solve_and_download_impls()
if downloaded:
tasks.wait_for_blocker(downloaded)
run.execute_selections(driver.solver.selections, [], stores = self.config.stores)
assert False
except SafeException as ex:
assert 'Command path must be relative' in str(ex), ex
def testAbsMain(self):
tmp = tempfile.NamedTemporaryFile(prefix='test-')
tmp.write("""<?xml version="1.0" ?>
<interface last-modified="1110752708"
uri="%s"
xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
<name>Foo</name>
<summary>Foo</summary>
<description>Foo</description>
<group main='/bin/sh'>
<implementation id='.' version='1'/>
</group>
</interface>""" % foo_iface_uri)
tmp.flush()
policy = Policy(tmp.name, config=self.config)
try:
downloaded = policy.solve_and_download_impls()
if downloaded:
policy.handler.wait_for_blocker(downloaded)
run.execute_selections(policy.solver.selections, [],
stores=policy.config.stores)
assert False
except SafeException as ex:
assert 'Command path must be relative' in str(ex), ex
def testAbsMain(self): tmp = tempfile.NamedTemporaryFile(prefix = 'test-') tmp.write( """<?xml version="1.0" ?> <interface last-modified="1110752708" uri="%s" xmlns="http://zero-install.sourceforge.net/2004/injector/interface"> <name>Foo</name> <summary>Foo</summary> <description>Foo</description> <group main='/bin/sh'> <implementation id='.' version='1'/> </group> </interface>""" % foo_iface_uri) tmp.flush() policy = Policy(tmp.name, config = self.config) try: downloaded = policy.solve_and_download_impls() if downloaded: policy.handler.wait_for_blocker(downloaded) run.execute_selections(policy.solver.selections, [], stores = policy.config.stores) assert False except SafeException, ex: assert 'Command path must be relative' in str(ex), ex
def testBadMain(self):
r = Requirements(command_feed)
r.command = None
d = Driver(requirements=r, config=self.config)
self.config.handler.wait_for_blocker(d.solve_with_downloads())
try:
run.execute_selections(d.solver.selections, [],
dry_run=True,
stores=self.config.stores)
assert 0
except SafeException as ex:
self.assertEqual("Can't run: no command specified!", unicode(ex))
try:
run.execute_selections(d.solver.selections, [],
main='relpath',
dry_run=True,
stores=self.config.stores)
assert 0
except SafeException as ex:
self.assertEqual(
"Can't use a relative replacement main when there is no original one!",
unicode(ex))
def _normal_mode(options, args):
from zeroinstall.injector import handler
if len(args) < 1:
if options.gui:
from zeroinstall import helpers
return helpers.get_selections_gui(None, [])
else:
raise UsageError()
iface_uri = model.canonical_iface_uri(args[0])
root_iface = iface_cache.get_interface(iface_uri)
if os.isatty(1):
h = handler.ConsoleHandler()
else:
h = handler.Handler()
h.dry_run = bool(options.dry_run)
policy = autopolicy.AutoPolicy(iface_uri,
handler = h,
download_only = bool(options.download_only),
src = options.source)
if options.before or options.not_before:
policy.solver.extra_restrictions[root_iface] = [model.VersionRangeRestriction(model.parse_version(options.before),
model.parse_version(options.not_before))]
if options.os or options.cpu:
from zeroinstall.injector import arch
policy.target_arch = arch.get_architecture(options.os, options.cpu)
if options.offline:
policy.network_use = model.network_offline
if options.get_selections:
if len(args) > 1:
raise SafeException(_("Can't use arguments with --get-selections"))
if options.main:
raise SafeException(_("Can't use --main with --get-selections"))
# Note that need_download() triggers a solve
if options.refresh or options.gui:
# We could run immediately, but the user asked us not to
can_run_immediately = False
else:
can_run_immediately = (not policy.need_download()) and policy.ready
stale_feeds = [feed for feed in policy.solver.feeds_used if policy.is_stale(iface_cache.get_feed(feed))]
if options.download_only and stale_feeds:
can_run_immediately = False
if can_run_immediately:
if stale_feeds:
if policy.network_use == model.network_offline:
logging.debug(_("No doing background update because we are in off-line mode."))
else:
# There are feeds we should update, but we can run without them.
# Do the update in the background while the program is running.
import background
background.spawn_background_update(policy, options.verbose > 0)
if options.get_selections:
_get_selections(policy)
else:
if not options.download_only:
from zeroinstall.injector import run
run.execute(policy, args[1:], dry_run = options.dry_run, main = options.main, wrapper = options.wrapper)
else:
logging.info(_("Downloads done (download-only mode)"))
assert options.dry_run or options.download_only
return
# If the user didn't say whether to use the GUI, choose for them.
if options.gui is None and os.environ.get('DISPLAY', None):
options.gui = True
# If we need to download anything, we might as well
# refresh all the interfaces first. Also, this triggers
# the 'checking for updates' box, which is non-interactive
# when there are no changes to the selection.
options.refresh = True
logging.info(_("Switching to GUI mode... (use --console to disable)"))
prog_args = args[1:]
try:
from zeroinstall.injector import run
if options.gui:
gui_args = []
if options.download_only:
# Just changes the button's label
gui_args.append('--download-only')
if options.refresh:
gui_args.append('--refresh')
if options.systray:
gui_args.append('--systray')
if options.not_before:
gui_args.insert(0, options.not_before)
gui_args.insert(0, '--not-before')
if options.before:
gui_args.insert(0, options.before)
gui_args.insert(0, '--before')
if options.source:
gui_args.insert(0, '--source')
if options.message:
gui_args.insert(0, options.message)
gui_args.insert(0, '--message')
if options.verbose:
gui_args.insert(0, '--verbose')
if options.verbose > 1:
gui_args.insert(0, '--verbose')
if options.cpu:
gui_args.insert(0, options.cpu)
gui_args.insert(0, '--cpu')
if options.os:
gui_args.insert(0, options.os)
gui_args.insert(0, '--os')
if options.with_store:
for x in options.with_store:
gui_args += ['--with-store', x]
sels = _fork_gui(iface_uri, gui_args, prog_args, options)
if not sels:
sys.exit(1) # Aborted
else:
#program_log('download_and_execute ' + iface_uri)
downloaded = policy.solve_and_download_impls(refresh = bool(options.refresh))
if downloaded:
policy.handler.wait_for_blocker(downloaded)
sels = selections.Selections(policy)
if options.get_selections:
doc = sels.toDOM()
doc.writexml(sys.stdout)
sys.stdout.write('\n')
elif not options.download_only:
run.execute_selections(sels, prog_args, options.dry_run, options.main, options.wrapper)
except NeedDownload, ex:
# This only happens for dry runs
print ex
def download_and_execute(driver, prog_args, main = None): driver_download(driver) run.execute_selections(driver.solver.selections, prog_args, stores = driver.config.stores, main = main)
def download_and_execute(driver, prog_args, main = None, dry_run = True): downloaded = driver.solve_and_download_impls() if downloaded: tasks.wait_for_blocker(downloaded) run.execute_selections(driver.solver.selections, prog_args, stores = driver.config.stores, main = main, dry_run = dry_run)
def download_and_execute(policy, prog_args, main = None, dry_run = True): downloaded = policy.solve_and_download_impls() if downloaded: policy.config.handler.wait_for_blocker(downloaded) run.execute_selections(policy.solver.selections, prog_args, stores = policy.config.stores, main = main, dry_run = dry_run)
def main(command_args):
"""Act as if 0launch was run with the given arguments.
@arg command_args: array of arguments (e.g. C{sys.argv[1:]})
@type command_args: [str]
"""
# Ensure stdin, stdout and stderr FDs exist, to avoid confusion
for std in (0, 1, 2):
try:
os.fstat(std)
except OSError:
fd = os.open('/dev/null', os.O_RDONLY)
if fd != std:
os.dup2(fd, std)
os.close(fd)
parser = OptionParser(usage=_("usage: %prog [options] interface [args]\n"
" %prog --list [search-term]\n"
" %prog --import [signed-interface-files]\n"
" %prog --feed [interface]"))
parser.add_option("", "--before", help=_("choose a version before this"), metavar='VERSION')
parser.add_option("-c", "--console", help=_("never use GUI"), action='store_false', dest='gui')
parser.add_option("", "--cpu", help=_("target CPU type"), metavar='CPU')
parser.add_option("-d", "--download-only", help=_("fetch but don't run"), action='store_true')
parser.add_option("-D", "--dry-run", help=_("just print actions"), action='store_true')
parser.add_option("-f", "--feed", help=_("add or remove a feed"), action='store_true')
parser.add_option("", "--get-selections", help=_("write selected versions as XML"), action='store_true')
parser.add_option("-g", "--gui", help=_("show graphical policy editor"), action='store_true')
parser.add_option("-i", "--import", help=_("import from files, not from the network"), action='store_true')
parser.add_option("-l", "--list", help=_("list all known interfaces"), action='store_true')
parser.add_option("-m", "--main", help=_("name of the file to execute"))
parser.add_option("", "--message", help=_("message to display when interacting with user"))
parser.add_option("", "--not-before", help=_("minimum version to choose"), metavar='VERSION')
parser.add_option("", "--os", help=_("target operation system type"), metavar='OS')
parser.add_option("-o", "--offline", help=_("try to avoid using the network"), action='store_true')
parser.add_option("-r", "--refresh", help=_("refresh all used interfaces"), action='store_true')
parser.add_option("", "--set-selections", help=_("run versions specified in XML file"), metavar='FILE')
parser.add_option("-s", "--source", help=_("select source code"), action='store_true')
parser.add_option("", "--systray", help=_("download in the background"), action='store_true')
parser.add_option("-v", "--verbose", help=_("more verbose output"), action='count')
parser.add_option("-V", "--version", help=_("display version information"), action='store_true')
parser.add_option("", "--with-store", help=_("add an implementation cache"), action='append', metavar='DIR')
parser.add_option("-w", "--wrapper", help=_("execute program using a debugger, etc"), metavar='COMMAND')
parser.disable_interspersed_args()
(options, args) = parser.parse_args(command_args)
if options.verbose:
logger = logging.getLogger()
if options.verbose == 1:
logger.setLevel(logging.INFO)
else:
logger.setLevel(logging.DEBUG)
import zeroinstall
logging.info(_("Running 0launch %(version)s %(args)s; Python %(python_version)s"), {'version': zeroinstall.version, 'args': repr(args), 'python_version': sys.version})
if options.with_store:
from zeroinstall import zerostore
for x in options.with_store:
iface_cache.stores.stores.append(zerostore.Store(os.path.abspath(x)))
logging.info(_("Stores search path is now %s"), iface_cache.stores.stores)
try:
if options.list:
_list_interfaces(args)
elif options.version:
import zeroinstall
print "0launch (zero-install) " + zeroinstall.version
print "Copyright (C) 2009 Thomas Leonard"
print _("This program comes with ABSOLUTELY NO WARRANTY,"
"\nto the extent permitted by law."
"\nYou may redistribute copies of this program"
"\nunder the terms of the GNU Lesser General Public License."
"\nFor more information about these matters, see the file named COPYING.")
elif options.set_selections:
from zeroinstall.injector import qdom, run
sels = selections.Selections(qdom.parse(file(options.set_selections)))
_download_missing_selections(options, sels)
if not options.download_only:
run.execute_selections(sels, args, options.dry_run, options.main, options.wrapper)
elif getattr(options, 'import'):
_import_feed(args)
elif options.feed:
_manage_feeds(options, args)
else:
_normal_mode(options, args)
except UsageError:
parser.print_help()
sys.exit(1)
except SafeException, ex:
if options.verbose: raise
print >>sys.stderr, ex
sys.exit(1)
def run_tests(config, tested_iface, sels, spec):
def _get_implementation_path(impl):
return impl.local_path or config.iface_cache.stores.lookup_any(
impl.digests)
main_command = sels.commands[0] if sels.commands else None
root_impl = sels.selections[tested_iface.uri]
assert root_impl
if spec.test_wrapper:
tests_dir = None
# $1 is the main executable, or the root of the package if there isn't one
# We have to add the slash because otherwise 0launch interprets the path
# relative to itself...
if main_command and main_command.path:
test_main = "/" + main_command.path
else:
test_main = "/"
else:
if main_command is None:
print >> sys.stderr, "No <command> requested and no test command either!"
return "skipped"
test_main = None
if main_command.path is None:
tests_dir = _get_implementation_path(root_impl)
else:
main_abs = os.path.join(_get_implementation_path(root_impl),
main_command.path)
if not os.path.exists(main_abs):
print >> sys.stderr, "Test executable does not exist:", main_abs
return "skipped"
tests_dir = os.path.dirname(main_abs)
child = os.fork()
if child:
# We are the parent
pid, status = os.waitpid(child, 0)
assert pid == child
print "Status:", hex(status)
if status == 0:
return "passed"
else:
return "failed"
else:
# We are the child
try:
try:
if spec.test_wrapper is None:
os.chdir(tests_dir)
run.execute_selections(sels,
spec.test_args,
main=test_main,
wrapper=spec.test_wrapper)
os._exit(0)
except model.SafeException, ex:
try:
print >> sys.stderr, unicode(ex)
except:
print >> sys.stderr, repr(ex)
except:
import traceback
traceback.print_exc()
finally:
