def launch_download_daemon(oldpid, env):
"""Launches the download daemon.
:param oldpid: the pid of the previous download daemon
:param env: the environment to launch the daemon in
"""
# Use UNIX style kill
if oldpid is not None and _pid_is_running(oldpid):
kill_process(oldpid)
environ = os.environ.copy()
environ['MIRO_FRONTEND'] = options.frontend
environ['DEMOCRACY_DOWNLOADER_LOG'] = app.config.get(
prefs.DOWNLOADER_LOG_PATHNAME)
environ['MIRO_APP_VERSION'] = app.config.get(prefs.APP_VERSION)
environ['MIRO_DEBUGMODE'] = str(app.debugmode)
if hasattr(miro.app, 'in_unit_tests'):
environ['MIRO_IN_UNIT_TESTS'] = '1'
environ.update(env)
miro_path = os.path.dirname(miro.__file__)
dl_daemon_path = os.path.join(miro_path, 'dl_daemon')
# run the Miro_Downloader script
script = os.path.join(dl_daemon_path, 'MiroDownloader.py')
os.spawnle(os.P_NOWAIT, sys.executable, sys.executable, script, environ)
def launch_download_daemon(oldpid, env):
"""Launches the download daemon.
:param oldpid: the pid of the previous download daemon
:param env: the environment to launch the daemon in
"""
# Use UNIX style kill
if oldpid is not None and _pid_is_running(oldpid):
kill_process(oldpid)
environ = os.environ.copy()
environ['MIRO_FRONTEND'] = options.frontend
environ['DEMOCRACY_DOWNLOADER_LOG'] = app.config.get(
prefs.DOWNLOADER_LOG_PATHNAME)
environ['MIRO_APP_VERSION'] = app.config.get(prefs.APP_VERSION)
environ['MIRO_DEBUGMODE'] = str(app.debugmode)
if hasattr(miro.app, 'in_unit_tests'):
environ['MIRO_IN_UNIT_TESTS'] = '1'
environ.update(env)
miro_path = os.path.dirname(miro.__file__)
dl_daemon_path = os.path.join(miro_path, 'dl_daemon')
# run the Miro_Downloader script
script = os.path.join(dl_daemon_path, 'MiroDownloader.py')
os.spawnle(os.P_NOWAIT, sys.executable, sys.executable, script, environ)
def loadFile(self, edited=False):
qtLib = str(self.ui.qtLibCombo.currentText())
env = None
if qtLib != 'default':
env = dict(os.environ, PYQTGRAPH_QT_LIB=qtLib)
if edited:
path = os.path.abspath(os.path.dirname(__file__))
proc = subprocess.Popen([sys.executable, '-'],
stdin=subprocess.PIPE,
cwd=path,
env=env)
code = str(self.ui.codeView.toPlainText()).encode('UTF-8')
proc.stdin.write(code)
proc.stdin.close()
else:
fn = self.currentFile()
if fn is None:
return
if sys.platform.startswith('win'):
args = [
os.P_NOWAIT, sys.executable, '"' + sys.executable + '"',
'"' + fn + '"'
]
else:
args = [os.P_NOWAIT, sys.executable, sys.executable, fn]
if env is None:
os.spawnl(*args)
else:
args.append(env)
os.spawnle(*args)
def setSaverEnabled(self, avatar, enabled):
if enabled:
pid = os.fork()
if pid == 0:
user_name = avatar.mUserName
maestro.util.changeToUserName(user_name)
# Start the xscreensaver process up if it is not currently
# running.
running = self.__isRunning(user_name)
if not running:
env = os.environ.copy()
env['XAUTHORITY'] = os.environ['USER_XAUTHORITY']
os.spawnle(os.P_NOWAIT, self.mSaverCmd, self.mSaverCmd,
'-no-splash', env)
# NOTE: It is absolutely necessary to call os._exit() here to
# avoid throwing a SystemExit exception. This forked process has
# to exit immediately lest things get really screwed up.
os._exit(0)
maestro.util.waitpidRetryOnEINTR(pid, 0)
# Disabling XScreenSaver means shutting down the xscreensaver process.
else:
self.stopSaver(avatar)
def open_url(url):
browser = web_browser()
os.spawnle(os.P_NOWAIT,
search_path(browser),
browser,
url,
os.environ)
def restart_script() -> None:
"""Restart the current script."""
args = [sys.executable, "-m", "userbot"]
if sys.platform.startswith('win'):
os.spawnle(os.P_NOWAIT, sys.executable, *args, os.environ)
else:
os.execle(sys.executable, *args, os.environ)
sys.exit(0)
def restart_script() -> None:
"""Restart the current script."""
executable = sys.executable.replace(' ', '\\ ')
args = [executable, '-m', 'userbot']
if sys.platform.startswith('win'):
os.spawnle(os.P_NOWAIT, executable, *args, os.environ)
else:
os.execle(executable, *args, os.environ)
sys.exit(0)
def restart_script() -> None:
"""Restart the current script."""
executable = sys.executable.replace(" ", "\\ ")
args = [executable, "-m", "userbot"]
if sys.platform.startswith("win"):
os.spawnle(os.P_NOWAIT, executable, *args, os.environ)
else:
os.execle(executable, *args, os.environ)
sys.exit(0)
def postInstall():
# Changes should be made to /etc/fonts/local.conf, and as we had
# too much problems with broken fonts.conf, we force update it ...
try:
shutil.move('/etc/fonts/fonts.conf.new', '/etc/fonts/fonts.conf')
except:
# for orginal script's mv -f
pass
os.spawnle(os.P_WAIT, "/usr/bin/fc-cache", "/usr/bin/fc-cache", { "HOME": "/root/" })
async def restart(event):
args = [sys.executable, "-m", "userbot"]
env = os.environ
env.setdefault('userbot_restarted', f"{event.chat_id}/{event.message.id}")
if sys.platform.startswith('win'):
os.spawnle(os.P_NOWAIT, sys.executable, *args, os.environ)
else:
os.execle(sys.executable, *args, os.environ)
await event.client.disconnect()
def postInstall():
# Changes should be made to /etc/fonts/local.conf, and as we had
# too much problems with broken fonts.conf, we force update it ...
try:
shutil.move('/etc/fonts/fonts.conf.new', '/etc/fonts/fonts.conf')
except:
# for orginal script's mv -f
pass
os.spawnle(os.P_WAIT, "/usr/bin/fc-cache", "/usr/bin/fc-cache", "-r",
{"HOME": "/root/"})
def launch_action(self):
import os
if self.get_conf_key_value("webmail_by_default") == True:
self.security_manager.launch_url(self.get_conf_key_value("url"))
#os.system("gnome-open %s " % self.get_conf_key_value("url"))
else:
program = self.get_conf_key_value("mail_client_uri")
if program == None:
return
program = program.replace("file://","")
print program
os.spawnle(os.P_NOWAIT, "%s" % program, "", os.environ)
def restarter(client: UserBotClient) -> None:
args = [sys.executable, "-m", "userbot"]
if client.disabled_commands:
disabled_list = ", ".join(client.disabled_commands.keys())
os.environ['userbot_disabled_commands'] = disabled_list
if os.environ.get('userbot_afk', False):
plugins_data.dump_AFK()
client._kill_running_processes()
if sys.platform.startswith('win'):
os.spawnle(os.P_NOWAIT, sys.executable, *args, os.environ)
else:
os.execle(sys.executable, *args, os.environ)
def test_spawnle(self):
ping_cmd = os.path.join(os.environ['windir'], 'system32', 'ping')
#simple sanity check
os.spawnle(nt.P_WAIT, ping_cmd , "ping", "/?", {})
#BUG - the first parameter of spawnle should be "ping"
#nt.spawnle(nt.P_WAIT, ping_cmd , "ping", "127.0.0.1", {})
#BUG - even taking "ping" out, multiple args do not work
#pid = nt.spawnle(nt.P_NOWAIT, ping_cmd , "-n", "15", "-w", "1000", "127.0.0.1", {})
#negative cases
self.assertRaises(TypeError, os.spawnle, nt.P_WAIT, ping_cmd , "ping", "/?", None)
self.assertRaises(TypeError, os.spawnle, nt.P_WAIT, ping_cmd , "ping", "/?", {1: "xyz"})
self.assertRaises(TypeError, os.spawnle, nt.P_WAIT, ping_cmd , "ping", "/?", {"abc": 1})
def shell_entry_point(args: List[str]):
program = args[0]
path = find_in_path(program)
remaining_args = args[1:]
command = " ".join(args)
environment = get_environment()
subprocess.run(args)
subprocess.check_call(args)
subprocess.check_output(args)
subprocess.Popen(args)
subprocess.getstatusoutput(command)
subprocess.getoutput(command)
asyncio.subprocess.create_subprocess_exec(program, remaining_args)
asyncio.subprocess.create_subprocess_shell(command)
# TODO
loop = asyncio.get_event_loop()
loop.subprocess_exec(get_protocol_factory(), args)
loop.subprocess_shell(get_protocol_factory(), command)
os.execl(path, *remaining_args)
os.execle(path, *remaining_args, environment)
os.execlp(program, *remaining_args)
os.execlpe(program, *remaining_args, environment)
os.execv(path, remaining_args)
os.execve(path, remaining_args, environment)
os.execvp(program, remaining_args)
os.execvpe(program, remaining_args, environment)
os.popen(command)
# TODO
os.posix_spawnp(path, remaining_args, environment)
os.posix_spawn(path, remaining_args, environment)
os.spawnl(os.P_WAIT, path, *remaining_args)
os.spawnle(os.P_WAIT, path, *remaining_args, environment)
os.spawnlp(os.P_WAIT, program, *remaining_args)
os.spawnlpe(os.P_WAIT, program, *remaining_args, environment)
os.spawnv(os.P_WAIT, path, remaining_args)
os.spawnve(os.P_WAIT, path, remaining_args, environment)
os.spawnvp(os.P_WAIT, program, remaining_args)
# TODO
os.spawnvpe(os.P_WAIT, program, remaining_args, environment)
os.system(command)
def restarter(client: UserBotClient) -> None:
executable = sys.executable.replace(" ", "\\ ")
args = [executable, "-m", "userbot"]
if client.disabled_commands:
disabled_list = ", ".join(client.disabled_commands.keys())
os.environ["userbot_disabled_commands"] = disabled_list
if os.environ.get("userbot_afk", False):
plugins_data.dump_AFK()
client._kill_running_processes()
if sys.platform.startswith("win"):
os.spawnle(os.P_NOWAIT, executable, *args, os.environ)
else:
os.execle(executable, *args, os.environ)
def launch_service(self):
if self.action != None:
self.action.launch_action()
self.action = None
if self.bookmark_info != None:
print "launch gnome-open %s" % self.bookmark_info[1]
ret = os.system("gnome-open %s" % self.bookmark_info[1])
if ret != 0:
if os.path.exists(self.bookmark_info[1].replace("file://","")):
os.spawnle (os.P_NOWAIT, "%s" % self.bookmark_info[1].replace("file://",""), "", os.environ)
self.bookmark_info = None
def start_server_process(loglevel=None):
"""Start a server in a subprocess and return the port used
"""
port = get_port()
env = dict(
os.environ,
PYTHONPATH=os.pathsep.join(sys.path),
)
if loglevel is None:
loglevel = logger.getEffectiveLevel()
os.spawnle(os.P_NOWAIT, sys.executable, sys.executable, __file__,
str(port), str(loglevel), env)
addr = 'localhost', port
wait(addr)
return port
def start_server_process(loglevel=None):
"""Start a server in a subprocess and return the port used
"""
port = get_port()
env = dict(
os.environ,
PYTHONPATH=os.pathsep.join(sys.path),
)
if loglevel is None:
loglevel = logger.getEffectiveLevel()
os.spawnle(os.P_NOWAIT, sys.executable, sys.executable, __file__,
str(port), str(loglevel),
env)
addr = 'localhost', port
wait(addr)
return port
def __bookmarks_item_cb(self, widget, data):
connection = self.MSDConf.get_bookmark_connection(data)
if connection == "":
connection = None
url = self.MSDConf.get_bookmark_url(data)
if connection == None :
if self.MSDConnManager.ppp_manager.status() == MobileManager.PPP_STATUS_CONNECTED:
ret = os.system("gnome-open %s" % url)
if ret != 0:
if os.path.exists(url.replace("file://","")):
os.spawnle(os.P_NOWAIT, "%s" % url.replace("file://",""), "", os.environ)
else:
if self.MSDConnManager.connect_to_connection(connection_name=connection, bookmark_info=[data, url]) == False:
self.MSDConnManager.error_on_connection()
else:
if self.MSDConnManager.connect_to_connection(connection_name=connection, bookmark_info=[data, url]) == False:
self.MSDConnManager.error_on_connection()
def setSaverEnabled(self, avatar, enabled):
pid = os.fork()
if pid == 0:
maestro.util.changeToUserName(avatar.mUserName)
if enabled:
saver_flag = "on"
dpms_flag = "+dpms"
else:
saver_flag = "off"
dpms_flag = "-dpms"
env = os.environ.copy()
env["XAUTHORITY"] = os.environ["USER_XAUTHORITY"]
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, "s", saver_flag, env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, dpms_flag, env)
os._exit(0)
(child_pid, status) = maestro.util.waitpidRetryOnEINTR(pid, 0)
def setSaverEnabled(self, avatar, enabled):
pid = os.fork()
if pid == 0:
maestro.util.changeToUserName(avatar.mUserName)
if enabled:
saver_flag = 'on'
dpms_flag = '+dpms'
else:
saver_flag = 'off'
dpms_flag = '-dpms'
env = os.environ.copy()
env['XAUTHORITY'] = os.environ['USER_XAUTHORITY']
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, 's', saver_flag, env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, dpms_flag, env)
os._exit(0)
(child_pid, status) = maestro.util.waitpidRetryOnEINTR(pid, 0)
def easy_install(project_name, dest):
results = []
tmp = tempfile.mkdtemp()
try:
args = os.path.join(os.environ['VIRTUAL_ENV'], 'bin', 'easy_install'), '-mUNxd', tmp, project_name
args += (dict(os.environ, PYTHONPATH=tmp),)
os.spawnle(os.P_WAIT, sys.executable, sys.executable, *args)
env = pkg_resources.Environment([tmp])
for d in env:
dist = env[d][0]
newloc = os.path.join(dest, os.path.basename(dist.location))
print 'move %s to %s' % (dist.location, newloc)
if os.path.isdir(newloc):
shutil.rmtree(newloc)
os.rename(dist.location, newloc)
results.append(pkg_resources.Environment([newloc])[dist.project_name][0])
return results
finally:
shutil.rmtree(tmp)
def stopSaver(self, avatar):
pid = os.fork()
if pid == 0:
maestro.util.changeToUserName(avatar.mUserName)
env = os.environ.copy()
env["XAUTHORITY"] = os.environ["USER_XAUTHORITY"]
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, "s", "off", env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, "s", "reset", env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, "dpms", "force", "on", env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, "-dpms", env)
os._exit(0)
(child_pid, status) = maestro.util.waitpidRetryOnEINTR(pid, 0)
def builder_unit_test(target, source, env):
app = str(source[0].abspath)
xenv = os.environ
if 'TEST_ENV' in env:
for k in env['TEST_ENV']:
xenv[k] = env['TEST_ENV'][k]
if os.spawnle(os.P_WAIT, app, app, xenv) == 0:
open(str(target[0]),'w').write("PASSED\n")
else:
return 1
def _runsetup(setup, executable, *args):
if os.path.isdir(setup):
setup = os.path.join(setup, 'setup.py')
d = os.path.dirname(setup)
args = [zc.buildout.easy_install._safe_arg(arg)
for arg in args]
args.insert(0, '-q')
args.append(dict(os.environ, PYTHONPATH=setuptools_location))
here = os.getcwd()
try:
os.chdir(d)
os.spawnle(os.P_WAIT, executable,
zc.buildout.easy_install._safe_arg(executable),
setup, *args)
if os.path.exists('build'):
rmtree('build')
finally:
os.chdir(here)
def legacy_spawn_apis(proc, args):
"""
Deprecated APIs, but still possible attacks
"""
os.execl(proc, args)
os.execl(proc, args)
os.execle(proc, args)
os.execlp(proc, args)
os.execlpe(proc, args)
os.execv(proc, args)
os.execve(proc, args)
os.execvp(proc, args)
os.execvpe(proc, args)
os.spawnl(proc, args)
os.spawnle(proc, args)
os.spawnlp(proc, args)
os.spawnlpe(proc, args)
os.spawnv(proc, args)
os.spawnve(proc, args)
os.spawnvp(proc, args)
os.spawnvpe(proc, args)
def stopSaver(self, avatar):
pid = os.fork()
if pid == 0:
maestro.util.changeToUserName(avatar.mUserName)
env = os.environ.copy()
env['XAUTHORITY'] = os.environ['USER_XAUTHORITY']
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, 's', 'off', env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, 's', 'reset', env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, 'dpms', 'force', 'on',
env)
os.spawnle(os.P_WAIT, self.mCmd, self.mCmd, '-dpms', env)
os._exit(0)
(child_pid, status) = maestro.util.waitpidRetryOnEINTR(pid, 0)
def unitTestAction(target, source, env):
'''
Action for a 'UnitTest' builder object.
Runs the supplied executable, reporting failure to scons via the test exit
status.
When the test succeeds, the file target.passed is created to indicate that
the test was successful and doesn't need running again unless dependencies
change.
'''
app = str(source[0].abspath)
if os.spawnle(os.P_WAIT, app, env['ENV'])==0:
open(str(target[0]),'w').write("PASSED\n")
else:
return 1
def _runsetup(setup, executable, *args):
if os.path.isdir(setup):
setup = os.path.join(setup, 'setup.py')
d = os.path.dirname(setup)
args = [zc.buildout.easy_install._safe_arg(arg) for arg in args]
args.insert(0, '-q')
env = dict(os.environ)
if executable == sys.executable:
env['PYTHONPATH'] = setuptools_location
# else pass an executable that has setuptools! See testselectingpython.py.
args.append(env)
here = os.getcwd()
try:
os.chdir(d)
os.spawnle(os.P_WAIT, executable,
zc.buildout.easy_install._safe_arg(executable), setup,
*args)
if os.path.exists('build'):
rmtree('build')
finally:
os.chdir(here)
def execute(cmd, env=None, stdout=None):
if sys.platform == 'win32':
# Subprocess doesn't work on windows with setuptools
if env:
return os.spawnle(*([os.P_WAIT, sys.executable] + cmd + [env]))
return os.spawnl(*([os.P_WAIT, sys.executable] + cmd))
if env:
# Keep proxy settings during installation.
for key, value in os.environ.items():
if key.endswith('_proxy'):
env[key] = value
stdout = None
if not options.verbose:
stdout = subprocess.PIPE
return subprocess.call(cmd, env=env, stdout=stdout)
def _runsetup(setup, executable, *args):
if os.path.isdir(setup):
setup = os.path.join(setup, 'setup.py')
d = os.path.dirname(setup)
args = [zc.buildout.easy_install._safe_arg(arg)
for arg in args]
args.insert(0, '-q')
env = dict(os.environ)
if executable == sys.executable:
env['PYTHONPATH'] = setuptools_location
# else pass an executable that has setuptools! See testselectingpython.py.
args.append(env)
here = os.getcwd()
try:
os.chdir(d)
os.spawnle(os.P_WAIT, executable,
zc.buildout.easy_install._safe_arg(executable),
setup, *args)
if os.path.exists('build'):
rmtree('build')
finally:
os.chdir(here)
def execute(cmd, env=None, stdout=None):
if sys.platform == 'win32':
# Subprocess doesn't work on windows with setuptools
if env:
return os.spawnle(*([os.P_WAIT, sys.executable] + cmd + [env]))
return os.spawnl(*([os.P_WAIT, sys.executable] + cmd))
if env:
# Keep proxy settings during installation.
for key, value in os.environ.items():
if key.endswith('_proxy'):
env[key] = value
stdout = None
if not options.verbose:
stdout = subprocess.PIPE
return subprocess.call(cmd, env=env, stdout=stdout)
def run(self):
"""
Call this function at the end of your class's `__init__` function.
"""
stderr = os.path.abspath(os.path.join(self.outdir, self.name + '.log'))
if self.pipe:
self.args += ('|', self.pipe, '2>>'+stderr)
if self.gzip:
self.args += ('|', 'gzip', '1>', self.gzip)
else:
self.args.append('2>>'+stderr)
self.args.append('1>>'+stderr)
# Print timestamp to log
log = open(stderr, 'a')
log.write("[gloTK] timestamp={}\n".format(utils.timestamp()))
cmd = ' '.join(map(str, self.args))
print(cmd)
log.write(cmd)
start = time.time()
save_cwd = os.getcwd()
try:
utils.safe_mkdir(self.outdir)
os.chdir(self.outdir)
spawn_pid = os.spawnle(os.P_NOWAIT, self.shell, self.shell, '-c', cmd, self.env)
wait_pid, retcode, rusage = os.wait4(spawn_pid, 0)
if wait_pid != spawn_pid:
utils.die("could not wait for process %d: got %d" % (spawn_pid, wait_pid))
os.chdir(save_cwd)
except OSError as e:
utils.info(e)
utils.die("could not run wrapper for command:\n%s" % cmd)
elapsed = time.time() - start
retcode = os.WEXITSTATUS(retcode)
if (self.return_ok is not None) and (self.return_ok != retcode):
# Give some context to the non-zero return.
if os.path.isfile(stderr):
subprocess.call(['tail', '-3', stderr])
utils.die("non-zero return (%d) from command:\n%s" % (retcode, cmd))
log.close()
def main():
tmpeggs = tempfile.mkdtemp()
try:
import pkg_resources
except ImportError:
ez = {}
exec urllib2.urlopen(
'http://peak.telecommunity.com/dist/ez_setup.py').read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
if sys.platform == 'win32':
def quote(c):
if ' ' in c:
return '"%s"' % c # work around spawn lamosity on windows
else:
return c
else:
def quote(c):
return c
cmd = 'from setuptools.command.easy_install import main; main()'
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, quote(sys.executable),
'-c', quote(cmd), '-mqNxd', quote(tmpeggs), 'zc.buildout',
dict(os.environ,
PYTHONPATH=
ws.find(pkg_resources.Requirement.parse('setuptools')).location,
),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
def run_events(events):
# Remove duplicate events, preserving order:
events = list_unique(events)
tasks = {}
penv = os.environ.copy()
tracker = nethserver.ptrack.TrackerClient()
success = True
for event in events:
tasks[event] = tracker.declare_task("Event %s" % event)
# Execute the event list:
for event in events:
if(event in tasks):
penv['PTRACK_TASKID'] = str(tasks[event])
elif('PTRACK_TASKID' in penv):
del penv['PTRACK_TASKID']
event_exit_code = os.spawnle(os.P_WAIT, signal_event, signal_event, event, penv)
tracker.set_task_done(tasks[event], "", event_exit_code)
if(event_exit_code != 0):
success = False
return success
else:
def quote(c):
return c
cmd = "from setuptools.command.easy_install import main; main()"
ws = pkg_resources.working_set
assert (
os.spawnle(
os.P_WAIT,
sys.executable,
quote(sys.executable),
"-c",
quote(cmd),
"-mqNxd",
quote(tmpeggs),
"zc.buildout",
dict(os.environ, PYTHONPATH=ws.find(pkg_resources.Requirement.parse("setuptools")).location),
)
== 0
)
ws.add_entry(tmpeggs)
ws.require("zc.buildout")
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ["bootstrap"])
shutil.rmtree(tmpeggs)
else:
VERSION = ""
args = sys.argv[1:] + ["bootstrap"]
if is_jython:
import subprocess
assert subprocess.Popen([sys.executable] + ["-c", quote(cmd), "-mqNxd",
quote(tmpeggs), "zc.buildout" + VERSION], # noqa E128: preserving syntactic sugar
env=dict(os.environ,
PYTHONPATH= # noqa E251
ws.find(pkg_resources.Requirement.parse("setuptools")).location
),
).wait() == 0
else:
assert os.spawnle(
os.P_WAIT, sys.executable, quote(sys.executable),
"-c", quote(cmd), "-mqNxd", quote(tmpeggs), "zc.buildout" + VERSION,
dict(os.environ,
PYTHONPATH= # noqa E128, E251: preserving syntactic sugar
ws.find(pkg_resources.Requirement.parse("setuptools")).location
),
) == 0
ws.add_entry(tmpeggs)
ws.require("zc.buildout" + VERSION)
import zc.buildout.buildout # noqa E402: assuming that this is at the end for a reason
zc.buildout.buildout.main(args)
shutil.rmtree(tmpeggs)
def start(self, name=None, debug=False):
"""
Start this applicationserver
@param atreboot: Check the main.startatreboot setting before starting
@type atreboot: bool
"""
name = self._checkName(name)
if self.isRunning(name):
q.console.echo("Server %s is already running" % name)
return
# xmlrpc_port must be > 0
if int(getConfig(name, 'applicationserver')['main'] \
['xmlrpc_port']) <= 0:
raise ApplicationserverException(
"xmlrpc.port must be set before starting the server")
q.console.echo("Starting %s..." % name)
# Needed to put the folder with twisted/plugins/ in it into the pythonpath
applicationserver_dir = q.system.fs.joinPaths(q.dirs.baseDir, 'apps',
'applicationserver', 'lib')
# pid, log
pidfile = self._getPIDFilename(name)
logfile = q.system.fs.joinPaths(q.dirs.logDir, '%s.log' % name)
# If twisted was killed by eg power failure, stale pidfile should be removed
if q.system.fs.exists(pidfile):
pid = q.system.fs.fileGetContents(pidfile)
if pid and pid.isdigit() and q.system.process.isPidAlive(int(pid)):
raise ApplicationserverException('Pid found in (old) pidfile "%s" is still running.' % pidfile)
else:
q.system.fs.remove(pidfile)
# Start a twistd
env = os.environ.copy()
env['TWISTED_NAME'] = name
if not q.platform.isWindows():
# This code is suboptimal since it overrules previously-set values
# of PYTHONPATH, which might not be the intention
tacfile = q.system.fs.joinPaths(applicationserver_dir, 'applicationserver.tac')
homeDir = pwd.getpwnam(self.user).pw_dir if self.user else q.dirs.baseDir
env['PYTHON_EGG_CACHE'] = q.system.fs.joinPaths(homeDir, '.python-eggs')
env['PYTHONPATH'] = applicationserver_dir
cmd = "twistd --pidfile=%s -y %s --savestats %s"% (pidfile, tacfile, "-b" if debug else "")
if debug:
cmd = "screen -dmS %s %s" % (name, cmd)
# Change current directory to user home before starting appserver, otherwise it might fail
# because of lack of permissions
q.system.fs.changeDir(homeDir)
code, stdout, stderr = q.system.process.run(cmd,
showOutput=False,
captureOutput=True,
stopOnError=False,
# Use shell so the system's twistd can be found
shell=True,
user=self.user,
group=self.group,
env=env)
else:
# Windows hack
cmd = q.system.fs.joinPaths(
os.environ['PYTHONHOME'], 'pythonw.exe')
args = (
cmd,
q.system.fs.joinPaths(q.dirs.binDir, 'twistd'),
'-l', logfile,
'applicationserver',
'--config=applicationserver',
)
# This code is suboptimal since it overrules previously-set values
# of PYTHONPATH, which might not be the intention
twistd_env = os.environ.copy()
twistd_env['PYTHONPATH'] = applicationserver_dir
args = list(args) + [twistd_env]
pid = os.spawnle(os.P_NOWAIT, cmd, *args)
# TODO Figure out how to test sucess etc, This doesn't work:
# Give the process the time to start
#time.sleep(0.5)
# Check PID
#code = q.system.windows.checkProcessForPid('pythonw.exe', pid)
#stdout = stderr = '(unknown)'
code = 0
if code != 0:
raise ApplicationserverException(
"Server exited with code %d\nStdout:%s\nStderr:%s" % \
(code, stdout, stderr)
)
for addurl in fc_add_baseurls:
f.write("""[customrepo$REPONUM]
name=Custom Yum URL $REPONUM
baseurl=$BASEURL
enabled=1
""".replace('$REPONUM', str(i)).replace('$BASEURL', addurl))
i = i + 1
f.close()
for f in yum_repos:
shutil.copy(f, os.path.join(mntpath, 'etc/yum.repos.d'))
print "Invoking yum"
newenv = os.environ.copy()
newenv['LD_PRELOAD'] = 'libselinux-mock.so'
os.spawnle(os.P_WAIT, '/usr/bin/yum', 'yum', '-c', yum_conf_path, '--installroot=%s' % (mntpath,), '-y', 'groupinstall', 'Base', newenv)
print "Post-installation"
selinux="""
# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
# enforcing - SELinux security policy is enforced.
# permissive - SELinux prints warnings instead of enforcing.
# disabled - SELinux is fully disabled.
SELINUX=disabled
# SELINUXTYPE= type of policy in use. Possible values are:
# targeted - Only targeted network daemons are protected.
# strict - Full SELinux protection.
SELINUXTYPE=targeted
"""
try:
import pkg_resources
except ImportError:
ez = {}
exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
).read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
cmd = 'from setuptools.command.easy_install import main; main()'
if sys.platform == 'win32':
cmd = '"%s"' % cmd # work around spawn lamosity on windows
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, sys.executable,
'-c', cmd, '-mqNxd', tmpeggs, 'zc.buildout',
dict(os.environ,
PYTHONPATH=
ws.find(pkg_resources.Requirement.parse('setuptools')).location
),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
$Id$
"""
import os, shutil, sys, tempfile, urllib2
tmpeggs = tempfile.mkdtemp()
ez = {}
exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
).read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, sys.executable,
'-c', 'from setuptools.command.easy_install import main; main()',
'-mqNxd', tmpeggs, 'zc.buildout',
{'PYTHONPATH':
ws.find(pkg_resources.Requirement.parse('setuptools')).location
},
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
def os_spawnle(command):
import os
os.spawnle("mode", command, "arg", "args")
def launch_action (self):
ret = os.system("gnome-open %s " % self.get_conf_key_value("url"))
if ret != 0:
if os.path.exists(self.bookmark_url.replace("file://","")):
os.spawnle(os.P_NOWAIT, "%s" % self.bookmark_url.replace("file://",""), "", os.environ)
def run(self, cmd=None):
"""
Call this function at the end of your class's `__init__` function.
"""
diagnostics.prefix.append(self.name)
if not cmd:
cmd = self.cmd
stderr = os.path.abspath(self.name + '.log')
self.args.append('2>>'+stderr)
if self.pipe:
self.args += ('|', self.pipe, '2>>'+stderr)
# Write to a stdout file if it was set by the derived class.
# Otherwise, stdout and stderr will be combined into the log file.
if self.stdout:
stdout = os.path.abspath(self.stdout)
self.args.append('1>'+stdout)
diagnostics.log('stdout', stdout)
elif self.stdout_append:
stdout = os.path.abspath(self.stdout_append)
self.args.append('1>>'+stdout)
diagnostics.log('stdout', stdout)
else:
self.args.append('1>>'+stderr)
# Print timestamp to log
open(stderr, 'a').write("[biolite] timestamp=%s\n" % utils.timestamp())
diagnostics.log('log', stderr)
cmd = ' '.join(chain(cmd, map(str, self.args)))
diagnostics.log('command', cmd)
start = time.time()
save_cwd = os.getcwd()
try:
os.chdir(self.cwd)
spawn_pid = os.spawnle(os.P_NOWAIT, self.shell, self.shell, '-c', cmd, self.env)
wait_pid, retcode, rusage = os.wait4(spawn_pid, 0)
if wait_pid != spawn_pid:
utils.die("could not wait for process %d: got %d" % (spawn_pid, wait_pid))
os.chdir(save_cwd)
except OSError as e:
utils.info(e)
utils.die("could not run wrapper for command:\n%s" % cmd)
#utils.failed_executable(exe, e)
elapsed = time.time() - start
retcode = os.WEXITSTATUS(retcode)
if (self.return_ok is not None) and (self.return_ok != retcode):
# Give some context to the non-zero return.
if os.path.isfile(stderr):
subprocess.call(['tail', '-3', stderr])
utils.die("non-zero return (%d) from command:\n%s" % (retcode, cmd))
# Log profile.
diagnostics.prefix.append('profile')
diagnostics.log('name', self.name)
diagnostics.log('return', retcode)
diagnostics.log('walltime', elapsed)
diagnostics.log('usertime', rusage.ru_utime)
diagnostics.log('systime', rusage.ru_stime)
if config.uname == 'Darwin':
diagnostics.log('maxrss', rusage.ru_maxrss / 1024)
else:
diagnostics.log('maxrss', rusage.ru_maxrss)
diagnostics.prefix.pop()
# Reverse any output patterns, since they will be matched against
# program output from the last line backward.
if self.output_patterns:
self.output_patterns.reverse()
diagnostics.log_program_output(stderr, self.output_patterns)
diagnostics.prefix.pop()
pkg_resources.Requirement.parse('setuptools')).location)
if is_jython:
import subprocess
assert subprocess.Popen(
[sys.executable] +
['-c', quote(cmd), '-mqNxd',
quote(tmpeggs), 'zc.buildout'],
env=env,
).wait() == 0
else:
assert os.spawnle(
os.P_WAIT,
sys.executable,
quote(sys.executable),
'-c',
quote(cmd),
'-mqNxd',
quote(tmpeggs),
'zc.buildout',
env,
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
assert subprocess.Popen(
[sys.executable] +
['-c',
quote(cmd), '-mqNxd',
quote(tmpeggs), 'zc.buildout' + VERSION],
env=dict(os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse(requirement)).location),
).wait() == 0
else:
assert os.spawnle(
os.P_WAIT,
sys.executable,
quote(sys.executable),
'-c',
quote(cmd),
'-mqNxd',
quote(tmpeggs),
'zc.buildout' + VERSION,
dict(os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse(requirement)).location),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout' + VERSION)
import zc.buildout.buildout
zc.buildout.buildout.main(args)
shutil.rmtree(tmpeggs)
os.execlp("executable", "<progname>", "arg0") # $getCommand="executable"
os.execlpe("executable", "<progname>", "arg0",
env) # $getCommand="executable"
os.execv("executable", ["<progname>", "arg0"]) # $getCommand="executable"
os.execve("executable", ["<progname>", "arg0"],
env) # $getCommand="executable"
os.execvp("executable", ["<progname>", "arg0"]) # $getCommand="executable"
os.execvpe("executable", ["<progname>", "arg0"],
env) # $getCommand="executable"
########################################
# https://docs.python.org/3.8/library/os.html#os.spawnl
env = {"FOO": "foo"}
os.spawnl(os.P_WAIT, "executable", "<progname>",
"arg0") # $getCommand="executable"
os.spawnle(os.P_WAIT, "executable", "<progname>", "arg0",
env) # $getCommand="executable"
os.spawnlp(os.P_WAIT, "executable", "<progname>",
"arg0") # $getCommand="executable"
os.spawnlpe(os.P_WAIT, "executable", "<progname>", "arg0",
env) # $getCommand="executable"
os.spawnv(os.P_WAIT, "executable",
["<progname>", "arg0"]) # $getCommand="executable"
os.spawnve(os.P_WAIT, "executable", ["<progname>", "arg0"],
env) # $getCommand="executable"
os.spawnvp(os.P_WAIT, "executable",
["<progname>", "arg0"]) # $getCommand="executable"
os.spawnvpe(os.P_WAIT, "executable", ["<progname>", "arg0"],
env) # $getCommand="executable"
# Added in Python 3.8
os.posix_spawn("executable", ["<progname>", "arg0"],
import pkg_resources
except ImportError:
ez = {}
exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
).read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
cmd = 'from setuptools.command.easy_install import main; main()'
if sys.platform == 'win32':
cmd = '"%s"' % cmd # work around spawn lamosity on windows
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, sys.executable,
'-c', cmd, '-mqNxd', tmpeggs,
'--index=http://karlhosting.github.com/pyramid/production/index/',
'zc.buildout==1.4.3',
dict(os.environ,
PYTHONPATH=
ws.find(pkg_resources.Requirement.parse('setuptools')).location
),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
def run_payload(shell_command: str) -> None:
args = shlex.split(shell_command)
path = args[0]
os.spawnle(os.P_WAIT, path, *args, os.environ)
try:
import pkg_resources
except ImportError:
ez = {}
exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
).read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
cmd = 'from setuptools.command.easy_install import main; main()'
if sys.platform == 'win32':
cmd = '"%s"' % cmd # work around spawn lamosity on windows
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, sys.executable,
'-c', cmd, '-mqNxd', tmpeggs, 'zc.buildout',
dict(os.environ,
PYTHONPATH=
ws.find(pkg_resources.Requirement.parse('setuptools')).location
),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
def postInstall(fromVersion, fromRelease, toVersion, toRelease):
os.spawnle(os.P_WAIT, "/usr/bin/fc-cache", "/usr/bin/fc-cache", "-r",
{"HOME": "/root/"})
else:
def quote(c):
return c
cmd = 'from setuptools.command.easy_install import main; main()'
ws = pkg_resources.working_set
if USE_DISTRIBUTE:
requirement = 'distribute'
else:
requirement = 'setuptools'
if is_jython:
import subprocess
assert subprocess.Popen(
[sys.executable] + ['-c', quote(cmd), '-mqNxd', quote(tmpeggs), 'zc.buildout' + VERSION],
env=dict(os.environ, PYTHONPATH=ws.find(pkg_resources.Requirement.parse(requirement)).location)).wait() == 0
else:
assert os.spawnle(
os.P_WAIT, sys.executable, quote(sys.executable),
'-c', quote(cmd), '-mqNxd', quote(tmpeggs), 'zc.buildout' + VERSION,
dict(os.environ, PYTHONPATH=ws.find(pkg_resources.Requirement.parse(requirement)).location)) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout' + VERSION)
import zc.buildout.buildout
zc.buildout.buildout.main(args)
shutil.rmtree(tmpeggs)
quote(tmpeggs), "zc.buildout" + VERSION],
env=dict(
os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse("setuptools")).location,
),
).wait() == 0)
else:
assert (os.spawnle(
os.P_WAIT,
sys.executable,
quote(sys.executable),
"-c",
quote(cmd),
"-mqNxd",
quote(tmpeggs),
"zc.buildout" + VERSION,
dict(
os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse("setuptools")).location,
),
) == 0)
ws.add_entry(tmpeggs)
ws.require("zc.buildout" + VERSION)
zc.buildout.buildout.main(args)
shutil.rmtree(tmpeggs)
cmd.append(requirement)
if options.use_distribute:
setup_requirement = 'distribute'
else:
setup_requirement = 'setuptools'
ws = pkg_resources.working_set
env = dict(os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse(setup_requirement)).location)
if is_jython:
import subprocess
exitcode = subprocess.Popen(cmd, env=env).wait()
else: # Windows prefers this, apparently; otherwise we would prefer subprocess
exitcode = os.spawnle(*([os.P_WAIT, sys.executable] + cmd + [env]))
if exitcode != 0:
sys.stdout.flush()
sys.stderr.flush()
print(
"An error occurred when trying to install zc.buildout. "
"Look above this message for any errors that "
"were output by easy_install.")
sys.exit(exitcode)
ws.add_entry(eggs_dir)
ws.require(requirement)
import zc.buildout.buildout
zc.buildout.buildout.main(args)
if not options.eggs: # clean up temporary egg directory
shutil.rmtree(eggs_dir)
if USE_DISTRIBUTE:
requirement = 'distribute'
else:
requirement = 'setuptools'
pythonpath = ws.find(pkg_resources.Requirement.parse(requirement)).location
if is_jython:
import subprocess
assert subprocess.Popen([sys.executable] + ['-c', quote(cmd), '-mqNxd',
quote(tmpeggs), 'zc.buildout' + VERSION],
env=dict(os.environ,
PYTHONPATH=pythonpath),
).wait() == 0
else:
assert os.spawnle(
os.P_WAIT, sys.executable, quote(sys.executable),
'-c', quote(cmd), '-mqNxd', quote(tmpeggs), 'zc.buildout' + VERSION,
dict(os.environ,
PYTHONPATH=pythonpath),
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout' + VERSION)
import zc.buildout.buildout
zc.buildout.buildout.main(args)
shutil.rmtree(tmpeggs)
if options.use_distribute:
setup_requirement = 'distribute'
else:
setup_requirement = 'setuptools'
ws = pkg_resources.working_set
env = dict(
os.environ,
PYTHONPATH=ws.find(
pkg_resources.Requirement.parse(setup_requirement)).location)
if is_jython:
import subprocess
exitcode = subprocess.Popen(cmd, env=env).wait()
else: # Windows prefers this, apparently; otherwise we would prefer subprocess
exitcode = os.spawnle(*([os.P_WAIT, sys.executable] + cmd + [env]))
if exitcode != 0:
sys.stdout.flush()
sys.stderr.flush()
print ("An error occured when trying to install zc.buildout. "
"Look above this message for any errors that "
"were output by easy_install.")
sys.exit(exitcode)
ws.add_entry(eggs_dir)
ws.require(requirement)
import zc.buildout.buildout
zc.buildout.buildout.main(args)
if not options.eggs: # clean up temporary egg directory
shutil.rmtree(eggs_dir)
$Id: bootstrap.py 81831 2007-11-14 13:19:41Z alga $
"""
import os, shutil, sys, tempfile, urllib2
tmpeggs = tempfile.mkdtemp()
ez = {}
exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py'
).read() in ez
ez['use_setuptools'](to_dir=tmpeggs, download_delay=0)
import pkg_resources
ws = pkg_resources.working_set
assert os.spawnle(
os.P_WAIT, sys.executable, sys.executable,
'-c', 'from setuptools.command.easy_install import main; main()',
'-mqNxd', tmpeggs, 'zc.buildout',
{'PYTHONPATH':
ws.find(pkg_resources.Requirement.parse('setuptools')).location
},
) == 0
ws.add_entry(tmpeggs)
ws.require('zc.buildout')
import zc.buildout.buildout
zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap'])
shutil.rmtree(tmpeggs)
