def start_fspot(button):
#would be cleaner if we could autostart using dbus,
#dbus.SessionBus().start_service_by_name(self.SERVICE_PATH)
gobject.spawn_async(("f-spot", ),
flags=gobject.SPAWN_SEARCH_PATH
| gobject.SPAWN_STDOUT_TO_DEV_NULL
| gobject.SPAWN_STDERR_TO_DEV_NULL)
def _start_uinput_bridge(self):
"""
Connect to a running uinput bridge. If none is running, we invoke one
using dbus activation or (if activation is not present) we invoke
uinputbridge our self.
"""
dbus_db = dinterface(dbus.SessionBus(),
"org.freedesktop.DBus",
"/",
"org.freedesktop.DBus")
if not "org.uinputbridge" in dbus_db.ListNames() and \
not "org.uinputbridge" in dbus_db.ListActivatableNames():
gobject.spawn_async([self.path.get_binfile("uinputbridge")],
flags=gobject.SPAWN_STDOUT_TO_DEV_NULL |
gobject.SPAWN_STDERR_TO_DEV_NULL )
count = 0
while count < 10:
count += 1
if "org.uinputbridge" in dbus_db.ListNames():
count = 11
time.sleep(1)
if count == 10:
raise UinputServiceStartException()
self.uinputbridge = dinterface(dbus.SessionBus(),
"org.uinputbridge",
"/UInputBridge",
"org.uinputbridge")
def showManual(self, data=None):
argv = []
argv.append("/usr/bin/firefox")
uri = "http://seedit.sourceforge.net/"
argv.append(uri)
prevusername = os.environ["USER"]
prevlogname = os.environ["LOGNAME"]
if os.environ.has_key("USERHELPER_UID"):
uidstr = os.environ["USERHELPER_UID"]
prevuid = os.getuid()
uid = int(uidstr)
username = pwd.getpwuid(uid)[0]
os.environ["USER"] = username
os.environ["LOGNAME"] = username
try:
gobject.spawn_async(argv)
except:
message = _("There was a problem launching the web browser")
self.showMessageDialog(gtk.MESSAGE_ERROR, message)
os.environ["USER"] = prevusername
os.environ["LOGNAME"] = prevlogname
def start_fspot(button):
#would be cleaner if we could autostart using dbus,
#dbus.SessionBus().start_service_by_name(self.SERVICE_PATH)
gobject.spawn_async(
("f-spot",),
flags=gobject.SPAWN_SEARCH_PATH|gobject.SPAWN_STDOUT_TO_DEV_NULL|gobject.SPAWN_STDERR_TO_DEV_NULL
)
def activate_status_icon(self, status_icon):
self.show_status_icon(False)
gobject.spawn_async([GKSU_PATH, UPDATEMANAGER])
if self.get_terminate_after_activate():
gtk.main_quit()
sys.exit(0)
else:
self.schedule_next_check_for_checks()
def _start_matchbox():
cmd = ['matchbox-window-manager']
cmd.extend(['-use_titlebar', 'no'])
cmd.extend(['-theme', 'sugar'])
cmd.extend(['-kbdconfig', os.path.join(config.data_path, 'kbdconfig')])
gobject.spawn_async(cmd, flags=gobject.SPAWN_SEARCH_PATH)
def __start_indexer_process(self): try: from gobject import spawn_async spawn_async([self.__python_executable, self.__executable, self.__editor.python_path], working_directory=self.__cwd) except: pass return False
def start_wine(self, *args):
if self.wine_pid:
logging.info("running command line: %s" % ' '.join(str(x) for x in args))
gobject.spawn_async(
['wine', 'explorer', '/desktop=%s' % self.desktop_name] + [str(x) for x in args],
flags=gobject.SPAWN_SEARCH_PATH)
else:
self.to_run.append(args)
def __start(self): from gobject import spawn_async from sys import executable from SCRIBES.Globals import python_path folder = self.__get_save_process_folder() module = self.__get_save_process_executable(folder) spawn_async([executable, module, python_path], working_directory=folder) return False
def __start_process(self): from gobject import spawn_async, GError try: args = [self.__python_executable, self.__executable, self.__editor.python_path] spawn_async(args, working_directory=self.__cwd) except GError: pass return False
def call(self):
"""
Execute the supplied command by spawning a subprozess
"""
self.logger.debug("Calling: " + str(self._to_array()))
gobject.spawn_async( self._to_array(),
flags= gobject.SPAWN_STDOUT_TO_DEV_NULL |
gobject.SPAWN_STDERR_TO_DEV_NULL )
def activate_status_icon(self, status_icon):
self.show_status_icon(False)
gobject.spawn_async([GKSU_PATH, UPDATEMANAGER])
if self.get_terminate_after_activate():
gtk.main_quit()
sys.exit(0)
else:
self.schedule_next_check_for_checks()
def cmd_spawn(self, cmd):
"""
Run cmd in a shell.
Example:
spawn("firefox")
"""
gobject.spawn_async([os.environ['SHELL'], '-c', cmd])
def cmd_spawn(self, cmd):
"""
Run cmd in a shell.
Example:
spawn("firefox")
"""
gobject.spawn_async([os.environ['SHELL'], '-c', cmd])
def __start(self):
from gobject import spawn_async
from sys import executable
from SCRIBES.Globals import python_path
folder = self.__get_save_process_folder()
module = self.__get_save_process_executable(folder)
spawn_async([executable, module, python_path],
working_directory=folder)
return False
def __open_to_line(self, view, path, column):
code = view.get_model()[path][0]
try:
lineno = "+%d" % code.co_firstlineno
filename = code.co_filename
except AttributeError: pass
else:
args = ['sensible-editor', lineno, filename]
gobject.spawn_async(args, flags=gobject.SPAWN_SEARCH_PATH)
def start_wine(self, *args):
if self.wine_pid:
logging.info("running command line: %s" %
' '.join(str(x) for x in args))
gobject.spawn_async(
['wine', 'explorer',
'/desktop=%s' % self.desktop_name] + [str(x) for x in args],
flags=gobject.SPAWN_SEARCH_PATH)
else:
self.to_run.append(args)
def __start_process(self):
from gobject import spawn_async, GError
try:
args = [
self.__python_executable, self.__executable,
self.__editor.python_path
]
spawn_async(args, working_directory=self.__cwd)
except GError:
pass
return False
def ui_help(self, ui):
'''The UI's help button was clicked.
This should open a help HTML page or website, call yelp with an
appropriate topic, etc. This gets the current UI object passed, which
can be used to determine whether GTK/KDE is used, etc.
'''
if 'gtk' in str(ui.__class__).lower():
import gobject
gobject.spawn_async(['yelp', 'help:ubuntu-help/hardware-driver-proprietary'],
flags=gobject.SPAWN_SEARCH_PATH)
def upload_files(self, menu, files):
# This is the method invoked when our extension is activated
# Do whatever you want to do with the files selected
if len(files) == 0:
return
names = [ unquote(file.get_uri()[7:]) for file in files ]
argv = [ PROGRAM_NAME ] + names
# TODO: use startup notification
gobject.spawn_async(argv, flags=gobject.SPAWN_SEARCH_PATH)
def __exit_app(self, restart=False):
gui_misc.shutdown_logging()
if restart:
try:
if self.image_dir_arg:
gobject.spawn_async([self.application_path, "--image-dir", self.image_dir_arg])
else:
gobject.spawn_async([self.application_path])
except gobject.GError, ex:
if debug:
print >>sys.stderr, "Exception occurred: %s" % ex
logger.error(ex)
def ui_help(self, ui):
'''The UI's help button was clicked.
This should open a help HTML page or website, call yelp with an
appropriate topic, etc. This gets the current UI object passed, which
can be used to determine whether GTK/KDE is used, etc.
'''
if 'gtk' in str(ui.__class__).lower():
import gobject
gobject.spawn_async(
['yelp', 'help:ubuntu-help/hardware-driver-proprietary'],
flags=gobject.SPAWN_SEARCH_PATH)
def upload_files(self, menu, files):
# This is the method invoked when our extension is activated
# Do whatever you want to do with the files selected
if len(files) == 0:
return
names = [unquote(file.get_uri()[7:]) for file in files]
argv = [PROGRAM_NAME] + names
# TODO: use startup notification
gobject.spawn_async(argv, flags=gobject.SPAWN_SEARCH_PATH)
def __exit_app(self, restart = False):
gui_misc.shutdown_logging()
if restart:
try:
if self.image_dir_arg:
gobject.spawn_async([self.application_path,
"--image-dir", self.image_dir_arg])
else:
gobject.spawn_async([self.application_path])
except gobject.GError, ex:
if debug:
print >> sys.stderr, "Exception occurred: %s" % ex
logger.error(ex)
def _create_activity(self):
if self._handle.activity_id is None:
self._handle.activity_id = create_activity_id()
self._shell.NotifyLaunch(
self._service_name, self._handle.activity_id,
reply_handler=self._no_reply_handler,
error_handler=self._notify_launch_error_handler)
environ = get_environment(self._bundle)
(log_path, log_file) = open_log_file(self._bundle)
command = get_command(self._bundle, self._handle.activity_id,
self._handle.object_id,
self._handle.uri)
if not self._use_rainbow:
# use gobject spawn functionality, so that zombies are
# automatically reaped by the gobject event loop.
def child_setup():
# clone logfile.fileno() onto stdout/stderr
os.dup2(log_file.fileno(), 1)
os.dup2(log_file.fileno(), 2)
# close all other fds
_close_fds()
# we need to sanitize and str-ize the various bits which
# dbus gives us.
gobject.spawn_async([str(s) for s in command],
envp=['%s=%s' % (k, str(v))
for k, v in environ.items()],
working_directory=str(self._bundle.get_path()),
child_setup=child_setup,
flags=(gobject.SPAWN_SEARCH_PATH |
gobject.SPAWN_LEAVE_DESCRIPTORS_OPEN))
log_file.close()
else:
log_file.close()
system_bus = dbus.SystemBus()
factory = system_bus.get_object(_RAINBOW_SERVICE_NAME,
_RAINBOW_ACTIVITY_FACTORY_PATH)
factory.CreateActivity(
log_path,
environ,
command,
environ['SUGAR_BUNDLE_PATH'],
environ['SUGAR_BUNDLE_ID'],
timeout=30,
reply_handler=self._create_reply_handler,
error_handler=self._create_error_handler,
dbus_interface=_RAINBOW_ACTIVITY_FACTORY_INTERFACE)
def on_parent_map(self, widget):
os.environ['WINE_DESKTOP_PARENT'] = str(self.desktop_parent.window.xid)
os.environ['SUGARED_WINE_TOPLEVEL'] = str(self.window.xid)
gtk.gdk.flush()
os.chdir(self.get_unix_path('c:\\'))
width = gtk.gdk.screen_width()
height = gtk.gdk.screen_height()
cmdline = ('wine', 'explorer', '/desktop=%s,%sx%s' % (self.desktop_name, width, height))
try:
args = self.settings['exec'].split(' ')
except KeyError:
pass
else:
cmdline += ('start', '/unix')
cmdline += (os.path.join(self.bundle_path, args[0]),)
cmdline += tuple(args[1:])
self.wine_pid, stdin, stdout, stderr = gobject.spawn_async(cmdline,
flags=gobject.SPAWN_SEARCH_PATH|gobject.SPAWN_DO_NOT_REAP_CHILD)
gobject.child_watch_add(self.wine_pid, self.on_wine_quit, None)
for cmdline in self.to_run:
self.start_wine(*cmdline)
def launch(self):
'''
Launch the service
'''
self.dead = False
runner = os.path.join(self.path, 'run')
if not os.path.exists(runner):
self.lastDied = time()
self.dead = True
self.parent.log(
'unable to start %s: run does not exist' % self.path)
return
if not os.access(runner, os.X_OK):
self.lastDied = time()
self.dead = True
self.parent.log(
'unable to start %s: run is not executable' % self.path)
return
self.parent.log('starting service: %s' % self.path)
(self.pid, stdin, stdout, stderr) = gobject.spawn_async(
[runner], working_directory=self.path, flags=gobject.SPAWN_DO_NOT_REAP_CHILD)
if self.pid <= 0:
self.lastDied = time()
self.dead = True
self.parent.log('failed to start process: %s', self.path)
else:
gobject.child_watch_add(self.pid, self.died)
self.changed('up')
def spawn_async(argv, in_dir="."): pretty.print_debug(__name__, "Spawn commandline", argv, in_dir) try: return gobject.spawn_async (argv, working_directory=in_dir, flags=gobject.SPAWN_SEARCH_PATH) except gobject.GError, exc: pretty.print_debug(__name__, "spawn_async", argv, exc)
def _start_uinput_bridge(self):
db = dinterface(dbus.SessionBus(), "org.freedesktop.DBus", "/", "org.freedesktop.DBus")
if not "org.uinputbridge" in db.ListNames() and \
not "org.uinputbridge" in db.ListActivatableNames():
gobject.spawn_async([self.path.get_binfile("uinputbridge")],
flags=gobject.SPAWN_STDOUT_TO_DEV_NULL |
gobject.SPAWN_STDERR_TO_DEV_NULL )
count = 0
while count < 10:
count += 1
if "org.uinputbridge" in db.ListNames():
count = 11
time.sleep(1)
if count == 10:
raise UinputServiceStartException()
self.uinputbridge = dinterface(dbus.SessionBus(), "org.uinputbridge", "/UInputBridge", "org.uinputbridge")
def run_cmd(self):
def child_setup():
os.setsid()
tty_slave_fd = os.open(self.tty_slave_name, os.O_RDWR)
os.close(tty_slave_fd)
os.close(self.tty_master_fd)
self.set_state(STATE_RUNNING)
self.cmd = self.cmd_widget.get_text()
self.tty_master_fd, self.tty_slave_fd = os.openpty()
self.tty_slave_name = os.ttyname(self.tty_slave_fd)
self.tty_view.set_fd(self.tty_master_fd)
set_raw_input(self.tty_master_fd)
try:
import shlex
self.pid, self.stdin_fd, self.stdout_fd, self.stderr_fd = \
gobject.spawn_async(shlex.split(self.cmd),
standard_output=True, standard_error=True,
flags=gobject.SPAWN_DO_NOT_REAP_CHILD | gobject.SPAWN_SEARCH_PATH,
child_setup=child_setup)
except Exception, e:
self.insert_text('stderr', str(e))
self.exit_status = -1
self.set_state(STATE_DONE)
return
def convert(self):
src = self.target
target = src.replace(self.codec, ".mp3")
if os.path.exists(target):
os.remove(target)
if sys.platform != "linux2":
ffmpeg_path = os.path.join(
os.path.dirname(os.path.dirname(config.exec_path)), "ffmpeg\\ffmpeg.exe"
).replace("\\", "\\\\")
target = target.replace("\\", "\\\\")
src = src.replace("\\", "\\\\")
else:
ffmpeg_path = "/usr/bin/ffmpeg"
self.print_info(_("Extracting audio..."))
try:
self.gui.throbber.show()
(pid, t, r, s) = gobject.spawn_async(
[str(ffmpeg_path), "-i", str(src), "-f", "mp3", "-ab", "192k", str(target)],
flags=gobject.SPAWN_DO_NOT_REAP_CHILD,
standard_output=True,
standard_error=True,
)
gobject.child_watch_add(pid, self.task_done)
except:
self.print_info(_("Extraction failed..."))
sleep(4)
self.print_info("")
self.gui.throbber.hide()
def _execute(self, options):
"""
Launch the monitored process
"""
if options is None:
cmdline = self._cmdline
else:
cmdline = [self._cmdline[0]] + options.split()
result = gobject.spawn_async(
cmdline,
envp="",
working_directory=os.environ.get("PWD", "/"),
flags=gobject.SPAWN_DO_NOT_REAP_CHILD, # needed for child watch
user_data=None,
standard_input=False,
standard_output=True,
standard_error=True)
if result[0] < 0:
raise OSError("foo")
self.pid, self.stdin, self.stdout, self.stderr = result
self._childwatch = gobject.child_watch_add(self.pid,
self._exitFromChild,
priority=100)
self._stdoutwatch = gobject.io_add_watch(self.stdout, gobject.IO_IN,
self._outputFromChild)
self._stderrwatch = gobject.io_add_watch(self.stderr, gobject.IO_IN,
self._errorFromChild)
def on_parent_map(self, widget):
os.environ['WINE_DESKTOP_PARENT'] = str(self.desktop_parent.window.xid)
os.environ['SUGARED_WINE_TOPLEVEL'] = str(self.window.xid)
gtk.gdk.flush()
os.chdir(self.get_unix_path('c:\\'))
width = gtk.gdk.screen_width()
height = gtk.gdk.screen_height()
cmdline = ('wine', 'explorer',
'/desktop=%s,%sx%s' % (self.desktop_name, width, height))
try:
args = self.settings['exec'].split(' ')
except KeyError:
pass
else:
cmdline += ('start', '/unix')
cmdline += (os.path.join(self.bundle_path, args[0]), )
cmdline += tuple(args[1:])
self.wine_pid, stdin, stdout, stderr = gobject.spawn_async(
cmdline,
flags=gobject.SPAWN_SEARCH_PATH | gobject.SPAWN_DO_NOT_REAP_CHILD)
gobject.child_watch_add(self.wine_pid, self.on_wine_quit, None)
for cmdline in self.to_run:
self.start_wine(*cmdline)
def action(self, text=None):
if TYPES[self.result["type"]].has_key("action"):
cmd = TYPES[self.result["type"]]["action"]
cmd = map(lambda arg : arg % self.result, cmd.split()) # we need this to handle spaces correctly
print "Opening Tracker hit with command:", cmd
try:
# deskbar >= 2.17
deskbar.Utils.spawn_async(cmd)
except AttributeError:
# deskbar <= 2.16
gobject.spawn_async(args, flags=gobject.SPAWN_SEARCH_PATH)
else:
try:
# deskbar >= 2.17
deskbar.Utils.url_show ("file://"+cgi.escape(self.result['uri']))
except AttributeError:
gnome.url_show("file://"+cgi.escape(self.result['uri']))
print "Opening Tracker hit:", self.result['uri']
def Run(self):
self.pid, stdin, self.stdout, self.stderr = gobject.spawn_async(
self.argv,
flags=gobject.SPAWN_DO_NOT_REAP_CHILD,
# make sure we can handle it's exit
standard_input=False,
standard_output=True,
standard_error=True)
gobject.child_watch_add(self.pid, self.__HandleExit)
def _check_agent_is_loaded(self):
self.label.set_text("checking agent")
pid, stdin, stdout, stderr = gobject.spawn_async(
["ssh-add", "-L"],
flags=gobject.SPAWN_DO_NOT_REAP_CHILD|
gobject.SPAWN_STDOUT_TO_DEV_NULL|
gobject.SPAWN_SEARCH_PATH)
pid.close()
gobject.child_watch_add(pid, self._check_agent_is_loaded_cb)
def main(argv):
""" The main daemon program.
Keyword arguments:
argv -- The arguments passed to the script.
"""
global child_pid
do_daemonize = True
redirect_stderr = True
redirect_stdout = True
auto_connect = True
try:
opts, args = getopt.getopt(sys.argv[1:], 'fenoah',
['help', 'no-daemon', 'no-poll', 'no-stderr', 'no-stdout',
'no-autoconnect'])
except getopt.GetoptError:
# Print help information and exit
usage()
sys.exit(2)
no_poll = False
for o, a in opts:
if o in ('-h', '--help'):
usage()
sys.exit()
if o in ('-e', '--no-stderr'):
redirect_stderr = False
if o in ('-o', '--no-stdout'):
redirect_stdout = False
if o in ('-f', '--no-daemon'):
do_daemonize = False
if o in ('-a', '--no-autoconnect'):
auto_connect = False
if o in ('-n', '--no-poll'):
no_poll = True
#This is commented only for testing purposes
#daemonize()
# Open the DBUS session
# TODO: Decide if I should use a SessionBus(SessionWide) or a SystemBus(SystemWide)
d_bus_name = dbus.service.BusName('org.filezaar.daemon', bus=dbus.SessionBus())
obj = FileZaarDBUS(d_bus_name, auto_connect=auto_connect)
gobject.threads_init()
(child_pid, aa, bb, cc) = gobject.spawn_async(["controller.py"],
flags=gobject.SPAWN_CHILD_INHERITS_STDIN)
signal.signal(signal.SIGINT, sigterm_caught)
signal.signal(signal.SIGTERM, sigterm_caught)
# Enter the main loop
mainloop = gobject.MainLoop()
mainloop.run()
def spawn_async(argv, in_dir="."): "Silently spawn @argv in the background" pretty.print_debug(__name__, "Spawn commandline", argv, in_dir) argv = _argv_to_locale(argv) try: return gobject.spawn_async (argv, working_directory=in_dir, flags=gobject.SPAWN_SEARCH_PATH) except gobject.GError, exc: pretty.print_debug(__name__, "spawn_async", argv, exc)
def _start_forwarding(self):
args = ['ssh', self.target, '-o', 'PasswordAuthentication no',
'-N', '-R', '21693:localhost:21693']
if self.keyfile:
args[2:2] = ['-i', self.keyfile]
flags = gobject.SPAWN_SEARCH_PATH | gobject.SPAWN_DO_NOT_REAP_CHILD
self.ssh_pid, stdin_fd, stdout_fd, stderr_fd = \
gobject.spawn_async(args, flags=flags)
gobject.child_watch_add(self.ssh_pid, self._restart_forwarding)
def init_xkb(self):
self.lang_line = ""
cpid, cstdin, cstdout, cstderr = gobject.spawn_async(
['xkb-switch', '-W'],
flags=gobject.SPAWN_SEARCH_PATH | gobject.SPAWN_DO_NOT_REAP_CHILD,
standard_output=True,
)
gobject.io_add_watch(cstdout, gobject.IO_IN, self.xkb_listener)
self.channel = os.fdopen(cstdout)
def on_help(self, widget):
"""
Display help
"""
if conduit.IS_INSTALLED:
uri = "ghelp:conduit"
else:
# if we are not installed then launch the ghelp uri with a full path
uri = "ghelp:%s" % os.path.join(conduit.DIRECTORY, "help", "C", "conduit.xml")
log.debug("Launching help: %s" % uri)
if gtk.gtk_version >= (2, 14, 0):
gtk.show_uri(self.mainWindow.get_screen(), uri, gtk.get_current_event_time())
else:
gobject.spawn_async(
argv=("xdg-open", uri),
flags=gobject.SPAWN_SEARCH_PATH | gobject.SPAWN_STDOUT_TO_DEV_NULL | gobject.SPAWN_STDERR_TO_DEV_NULL,
)
def Run(self):
self.pid, stdin, self.stdout, self.stderr = gobject.spawn_async(
self.argv,
flags = gobject.SPAWN_DO_NOT_REAP_CHILD,
# make sure we can handle it's exit
standard_input=False,
standard_output=True,
standard_error=True
)
gobject.child_watch_add(self.pid, self.__HandleExit)
def init_xkb(self):
self.lang_line = ""
cpid, cstdin, cstdout, cstderr = gobject.spawn_async(
['xkb-switch','-W'],
flags=gobject.SPAWN_SEARCH_PATH|gobject.SPAWN_DO_NOT_REAP_CHILD,
standard_output=True,
)
gobject.io_add_watch(cstdout,
gobject.IO_IN,
self.xkb_listener)
self.channel = os.fdopen(cstdout)
def install_pkgs(self):
try:
(pid, sin, sout, serr) = gobject.spawn_async(
["install-langs", tmpdir],
flags=gobject.SPAWN_SEARCH_PATH |
gobject.SPAWN_DO_NOT_REAP_CHILD)
gobject.child_watch_add(pid, self.install_pkgs_done)
if self.window.window:
self.window.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
except gobject.GError:
self.install = False
install_pkgs_done(self, None, None)
def run_cmd(self, *args):
pid, stdin, stdout, stderr = gobject.spawn_async(
args, flags=gobject.SPAWN_SEARCH_PATH, standard_output=True)
result = []
s = os.read(stdout, 4096)
while s:
result.append(s)
s = os.read(stdout, 4096)
result = ''.join(result)
return result
def spawn_async_raise(argv, workdir="."): """ A version of spawn_async that raises on error. raises SpawnError """ argv = _argv_to_locale(argv) pretty.print_debug(__name__, "spawn_async", argv, workdir) try: return gobject.spawn_async (argv, working_directory=workdir, flags=gobject.SPAWN_SEARCH_PATH) except gobject.GError as exc: raise SpawnError(exc)
def spawn(self, args=None, callback=None, data=None, cwd=None):
'''Start the application in the background and return immediately.
This is used to start an external in parallel with zim that is
not expected to exit immediatly, so we do not want to wait for
it - e.g. a webbrowser to show an URL that was clicked.
@param args: additional arguments to give to the command as tuple or list
@param callback: optional callback can be used to trigger when
the application exits. The signature is::
callback(status, data)
where 'C{status}' is the exit status of the process. The
application object provides a constant 'C{STATUS_OK}' which can
be used to test if the application was successful or not.
@param data: additional data for the callback
@param cwd: the folder to set as working directory for the command
@returns: the PID for the new process
'''
cwd, argv = self._checkargs(cwd, args)
opts = {}
flags = gobject.SPAWN_SEARCH_PATH
if callback:
flags |= gobject.SPAWN_DO_NOT_REAP_CHILD
# without this flag child is reaped automatically -> no zombies
logger.info('Spawning: %s (cwd: %s)', argv, cwd)
try:
pid, stdin, stdout, stderr = \
gobject.spawn_async(argv, flags=flags, **opts)
except gobject.GError:
from zim.gui.widgets import ErrorDialog
ErrorDialog(None, _('Failed running: %s') % argv[0]).run()
#~ # T: error when application failed to start
return None
else:
logger.debug('Process started with PID: %i', pid)
if callback:
# child watch does implicit reaping -> no zombies
if data is None:
gobject.child_watch_add(
pid, lambda pid, status: callback(status))
else:
gobject.child_watch_add(
pid, lambda pid, status, data: callback(status, data),
data)
return pid
def __init__(self, path, args=[], warnwords=[], env=None):
gobject.GObject.__init__(self)
self.path = path
self.args = args
self.warnwords = warnwords
self.env = env or os.environ
self.buffer = ""
self.linePublisher = EmitPublisher(self, "line",
EmitPublisher.SEND_LIST)
self.linePublisher.start()
self.defname = os.path.split(path)[1]
self.defname = self.defname[:1].upper() + self.defname[1:].lower()
t = time.time()
self.defname = (self.defname,
time.strftime("%H:%m:%%.3f", time.localtime(t)) %
(t % 60))
log.debug(path + "\n", self.defname)
argv = [str(u) for u in [self.path] + self.args]
self.pid, stdin, stdout, stderr = gobject.spawn_async(
argv,
child_setup=self.__setup,
standard_input=True,
standard_output=True,
standard_error=True,
flags=gobject.SPAWN_DO_NOT_REAP_CHILD | gobject.SPAWN_SEARCH_PATH)
self.__channelTags = []
self.inChannel = self._initChannel(stdin, None, None, False)
readFlags = gobject.IO_IN | gobject.IO_HUP #|gobject.IO_ERR
self.outChannel = self._initChannel(stdout, readFlags, self.__io_cb,
False)
self.errChannel = self._initChannel(stderr, readFlags, self.__io_cb,
True)
self.channelsClosed = False
self.channelsClosedLock = threading.Lock()
gobject.child_watch_add(self.pid, self.__child_watch_callback)
self.subprocExitCode = (None, None)
self.subprocFinishedEvent = threading.Event()
self.subprocFinishedEvent.clear()
subprocesses.append(self)
pool.start(self._wait4exit)
def Start(self):
"""Start program.
"""
logging.info("Starting program, executable=%r, args=%r",
self.__executable, self.__args)
# TODO: Make gobject.SPAWN_SEARCH_PATH controllable by caller?
flags = gobject.SPAWN_DO_NOT_REAP_CHILD | gobject.SPAWN_SEARCH_PATH
if self.__executable:
args = self.__FormatArgs([self.__executable] + self.__args)
flags |= gobject.SPAWN_FILE_AND_ARGV_ZERO
else:
args = self.__FormatArgs(self.__args)
# gobject.spawn_async doesn't take None for default values, hence we can
# only fill these parameters if they need to be set.
kwargs = {}
if self.__env is not None:
kwargs["envp"] = self.__FormatEnvironment(self.__env)
if self.__cwd is not None:
kwargs["working_directory"] = self.__cwd
(pid, stdin_fd, stdout_fd, stderr_fd) = \
gobject.spawn_async(args, flags=flags, child_setup=self.__ChildSetup,
standard_input=True,
standard_output=True,
standard_error=True,
**kwargs)
logging.info("Child %s[%d] started", self.__progname, pid)
self.__pid = pid
self.stdin.Attach(stdin_fd)
self.stdout.Attach(stdout_fd)
self.stderr.Attach(stderr_fd)
self.__child_watch_handle = \
gobject.child_watch_add(self.__pid, self.__HandleExit)
return self.pid
def spawn_exchangerates_updater():
if not is_update_check_due():
print "Time is low, skipping"
return 0
try:
try:
if CURRENT_PLATFORM in (PLATFORM_NAME_LINUX, PLATFORM_NAME_OSX):
import gobject # @UnresolvedImport
cmdline = [
"python",
os.path.join(_get_enso_directory(), "enso", "contrib",
"calc", "exchangerates", "updater.py")
]
argv = argv_to_locale(cmdline)
pid = gobject.spawn_async(
argv, #working_directory=workdir,
flags=gobject.SPAWN_SEARCH_PATH
| gobject.SPAWN_STDOUT_TO_DEV_NULL)
return pid
else:
cmdline = [
"python.exe",
os.path.join(_get_enso_directory(), "enso", "contrib",
"calc", "exchangerates", "updater.py")
]
pid = subprocess.Popen(
cmdline, shell=False, stdout=None
).pid # Only on windows: , creationflags=os.P_NOWAIT
return pid
except Exception as e:
logging.error(e)
except Exception as e:
logging.error("Error spawning exchangerates_updater process: %s", e)
return 0
finally:
reset_update_check_time()
def _start_window_manager():
cmd = ['metacity']
cmd.extend(['--no-force-fullscreen'])
gobject.spawn_async(cmd, flags=gobject.SPAWN_SEARCH_PATH)
def activate_mixer(self, widget):
gobject.spawn_async(
[MIXER_CMD],
flags=gobject.SPAWN_SEARCH_PATH
)
def perform_action(self):
cmd = ''
if self.action == ACTION_RECV:
self.wiz.set_page_title(self.progress_page, _('Receiving...'))
port = self.xml.get_widget('listen_port').get_text()
dest_dir = self.xml.get_widget('recv_dir').get_filename()
self.config.set('history', 'listen_port', port)
self.config.set('history', 'recv_dir', dest_dir)
cmd = "nc -l -v --close -p %s | tar -xvz -C '%s'" % (port,
dest_dir)
else: # ACTION_SEND
self.wiz.set_page_title(self.progress_page, _('Sending...'))
host = self.xml.get_widget('dest_host').get_text()
port = self.xml.get_widget('dest_port').get_text()
self.config.set('history', 'dest_host', host)
self.config.set('history', 'dest_port', port)
files = ' '
dirs = []
for it in self.send_list:
# special char like single quote should be escaped
files += ("'%s' " % it[1].replace("'", "'\\''"))
# FIXME: how to escape dir names correctly for transformation pattern?
dir = os.path.dirname(it[1])
if not dir in dirs:
dirs.append(dir)
transform = '--show-transformed-names '
# sort the dirs to put the longer ones before shorter ones
dirs.sort(lambda a, b: len(b) - len(a))
# use --transform to strip all prefix of the added files
for dir in dirs:
transform += ("--transform='s,^%s/,,' " % dir)
# striping dir paths of those files with --transform
cmd = "tar %s -cvzP %s| nc -w30 -v --close '%s' %s" % (
transform, files, host, port)
self.progress.insert(
self.progress.get_end_iter(), '%s %s\n\n%s\n\n' %
(_('Execute command:'), _('Processing...'), cmd))
# print cmd
(self.pid, self.stdi, self.stdo, self.stde) = gobject.spawn_async(
['sh', '-c', ('exec %s' % cmd)],
flags=gobject.SPAWN_SEARCH_PATH | gobject.SPAWN_DO_NOT_REAP_CHILD,
standard_input=True,
standard_output=True,
standard_error=True)
gobject.child_watch_add(self.pid, self.on_process_exit)
gobject.io_add_watch(self.stdo,
gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR,
self.on_stdout)
gobject.io_add_watch(self.stde,
gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR,
self.on_stderr)
# enable the Cancel button with very dirty hacks
def find_cancel_btn(btn, _self):
if btn and gobject.type_is_a(
btn, gtk.Button) and btn.get_label() == gtk.STOCK_CANCEL:
_self.cancel_btn = btn
def find_hbox(w, _self):
if w and gobject.type_is_a(w, gtk.HBox):
w.forall(find_cancel_btn, _self)
self.wiz.forall(find_hbox, self)
if self.cancel_btn:
self.cancel_btn.set_sensitive(True)
def start(self):
progname='tuxpaint'
tuxpaint_dir = None
flags = gobject.SPAWN_DO_NOT_REAP_CHILD | gobject.SPAWN_SEARCH_PATH
print platform.platform(), platform.platform().split('-')[0]
if (platform.platform().split('-')[0] == 'Windows'):
progname = 'tuxpaint.exe'
try:
import _winreg
tuxpaint_key = _winreg.OpenKey( _winreg.HKEY_LOCAL_MACHINE,
"Software\\TuxPaint" )
tuxpaint_dir, type = _winreg.QueryValueEx(tuxpaint_key, "Install_Dir")
flags = gobject.SPAWN_DO_NOT_REAP_CHILD
# escape mandatory in Win pygtk2.6
tuxpaint_dir = '"' + tuxpaint_dir + '"'
except:
pass
self.window = self.gcomprisBoard.canvas.get_toplevel()
Prop = gcompris.get_properties()
#get default values
self.config_dict = self.init_config()
#replace configured values
self.config_dict.update(gcompris.get_board_conf())
self.rootitem = goocanvas.Group(parent = self.gcomprisBoard.canvas.get_root_item())
options = [progname]
if (Prop.fullscreen and eval(self.config_dict['fullscreen'])):
options.append('--fullscreen')
if eval(self.config_dict['disable_shape_rotation']):
options.append('--simpleshapes')
if eval(self.config_dict['uppercase_text']):
options.append('--uppercase')
if eval(self.config_dict['disable_stamps']):
options.append('--nostamps')
if eval(self.config_dict['disable_stamps_control']):
options.append('--nostampcontrols')
gcompris.sound.close()
global pid
try:
# bug in working_directory=None ?
if (tuxpaint_dir):
pid, stdin, stdout, stderr = gobject.spawn_async(
argv=options,
flags=flags,
working_directory=tuxpaint_dir)
else:
pid, stdin, stdout, stderr = gobject.spawn_async(
argv=options,
flags=flags)
except:
gcompris.utils.dialog(_("Cannot find Tuxpaint.\nInstall it to use this activity !"),stop_board)
return
gobject.child_watch_add(pid, child_callback, data=self, priority=gobject.PRIORITY_HIGH)
gcompris.bar_set(gcompris.BAR_CONFIG)
gcompris.bar_hide(1)
gcompris.set_default_background(self.gcomprisBoard.canvas.get_root_item())
textItem = goocanvas.Text(
parent = self.rootitem,
text = _("Waiting for Tuxpaint to finish"),
x = gcompris.BOARD_WIDTH/2,
y = 185,
fill_color_rgba = 0x000000ffL,
anchor = gtk.ANCHOR_CENTER,
font = gcompris.skin.get_font("gcompris/board/title bold"),
)
def launch (self):
full_key = self._conf.resolve_plugin_key (self, "command")
command = self._conf.client.get_string (full_key)
flags = gobject.SPAWN_STDOUT_TO_DEV_NULL | gobject.SPAWN_STDERR_TO_DEV_NULL
gobject.spawn_async (["/bin/sh", "-c", command], flags=flags)
def _new_window_requested_cb (self, tab_content, view):
program = '/usr/bin/roaster'
launcher = '/usr/bin/python'
url = tab_content._hovered_uri
command = [launcher, program, url]
(cpid, cstdin, cstdout, cstderr)=gobject.spawn_async(command)