def __init__(self, quit_cb=None): log("ChildReaper(%s)", quit_cb) from xpra.gtk_common.gobject_compat import import_glib self.glib = import_glib() self._quit = quit_cb self._proc_info = [] if USE_PROCESS_POLLING: log("using process polling every %s seconds", POLL_DELAY) self.glib.timeout_add(POLL_DELAY * 1000, self.poll) else: # with a less buggy python, we can just check the list of pids # whenever we get a SIGCHLD # however.. subprocess.Popen will no longer work as expected # see: http://bugs.python.org/issue9127 # so we must ensure certain things that exec happen first: from xpra.version_util import get_platform_info get_platform_info() signal.signal(signal.SIGCHLD, self.sigchld) # Check once after the mainloop is running, just in case the exit # conditions are satisfied before we even enter the main loop. # (Programming with unix the signal API sure is annoying.) def check_once(): self.check() return False # Only call once self.glib.timeout_add(0, check_once)
def __init__(self, codec): gobject.GObject.__init__(self) self.codec = codec self.codec_description = "" self.codec_mode = "" self.container_description = "" self.bus = None self.bus_message_handler_id = None self.bitrate = -1 self.pipeline = None self.pipeline_str = "" self.start_time = 0 self.state = "stopped" self.buffer_count = 0 self.byte_count = 0 self.emit_info_due = False self.info = { "codec" : self.codec, "state" : self.state, } glib = import_glib() self.idle_add = glib.idle_add self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove if gst_version[0]<1: #Gst 0.10: can handle both TAG and ELEMENT: self.parse_message = self.parse_message0 else: #Gst 1.0: (does not have MESSAGE_ELEMENT): self.parse_message = self.parse_message1
def gtk_main_quit_really(): # We used to call gtk.main_quit() repeatedly, but this doesn't actually # work -- gtk.main_quit() always marks the *current* level of main loop # for destruction, so it's actually idempotent. We have to call # gtk.main_quit once, and then return to the main loop, and then call it # again, and then return to the main loop, etc. So we use a trick: We # register a function that gtk should call 'forever' (i.e., as long as the # main loop is running!) def gtk_main_quit_forever(): # We import gtk inside here, rather than at the top of the file, # because importing gtk has the side-effect of trying to connect to # the X server (and this process may block, may cause us to later be # killed if the X server goes away, etc.), and we don't want to impose # that on every user of this function. from xpra.gtk_common.gobject_compat import import_gtk gtk = import_gtk() gtk.main_quit() # So long as there are more nested main loops, re-register ourselves # to be called again: if gtk.main_level() > 1: return True else: # But when we've just quit the outermost main loop, then # unregister ourselves so that it's possible to start the # main-loop again if desired: return False from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib.timeout_add(0, gtk_main_quit_forever)
def main(): log.enable_debug() from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() s = GTKStatusIconTray(None, "test", "xpra.png", None, None, None, gtk.main_quit) glib.timeout_add(1000*2, s.set_blinking, True) glib.timeout_add(1000*5, s.set_blinking, False) glib.timeout_add(1000*10, gtk.main_quit) gtk.main()
def glib_init(self): try: glib = import_glib() try: glib.threads_init() except AttributeError: #old versions of glib may not have this method pass except ImportError: pass
def main(): import random, signal port = int(20000*random.random())+10000 host = "0.0.0.0" host_ports = [(host, port)] ID = "test_%s" % int(random.random()*100000) publisher = BonjourPublishers(host_ports, ID, XPRA_MDNS_TYPE, {"somename":"somevalue"}) signal.signal(signal.SIGTERM, exit) from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib.idle_add(publisher.start) loop = glib.MainLoop() loop.run()
def __init__(self, description="wrapper"): self.process = None self.protocol = None self.command = None self.description = description self.send_queue = Queue() self.signal_callbacks = {} self.large_packets = [] #hook a default packet handlers: self.connect(Protocol.CONNECTION_LOST, self.connection_lost) self.connect(Protocol.GIBBERISH, self.gibberish) glib = import_glib() self.idle_add = glib.idle_add self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove
def init_attributes(self, *args): FileTransferAttributes.init_attributes(self, *args) self.remote_file_transfer = False self.remote_printing = False self.remote_open_files = False self.remote_file_size_limit = 0 self.remote_file_chunks = 0 self.send_chunks_in_progress = {} self.receive_chunks_in_progress = {} self.file_descriptors = set() if not getattr(self, "timeout_add", None): from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() self.timeout_add = glib.timeout_add self.idle_add = glib.idle_add self.source_remove = glib.source_remove
def session_change_event(self, event, session): event_name = WTS_SESSION_EVENTS.get(event, event) log("WM_WTSSESSION_CHANGE: %s on session %#x", event_name, session) c = self.client if not c: return if event in (WTS_SESSION_LOGOFF, WTS_SESSION_LOCK): log("will freeze all the windows") c.freeze() elif event in (WTS_SESSION_LOGON, WTS_SESSION_UNLOCK): log("will unfreeze all the windows") #don't unfreeze directly from here, #as the system may not be fully usable yet (see #997) from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib.idle_add(c.unfreeze)
def main(): def mdns_found(*args): print("mdns_found: %s" % (args, )) def mdns_add(*args): print("mdns_add: %s" % (args, )) def mdns_remove(*args): print("mdns_remove: %s" % (args, )) from xpra.dbus.common import loop_init loop_init() listener = AvahiListener(XPRA_MDNS_TYPE, mdns_found, mdns_add, mdns_remove) try: from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib.idle_add(listener.start) glib.MainLoop().run() finally: listener.stop()
def __init__(self, codec): gobject.GObject.__init__(self) self.codec = codec self.codec_description = "" self.codec_mode = "" self.bus = None self.bus_message_handler_id = None self.bitrate = -1 self.pipeline = None self.pipeline_str = "" self.start_time = 0 self.state = "stopped" self.buffer_count = 0 self.byte_count = 0 self.emit_info_due = False glib = import_glib() self.idle_add = glib.idle_add self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove
def main(): import sys if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category add_debug_category("webcam") run = "-r" in sys.argv or "--run" in sys.argv if run: from xpra.gtk_common.gobject_compat import import_glib, import_gobject glib = import_glib() gobject = import_gobject() gobject.threads_init() from xpra.util import engs, print_nested_dict from xpra.platform import program_context with program_context("Webcam Info", "Webcam Info"): devices = get_virtual_video_devices() or {} log.info("Found %i virtual video device%s:", len(devices), engs(devices)) print_nested_dict(devices) all_devices = get_all_video_devices() or {} log.info("Found %i video device%s in total:", len(all_devices), engs(all_devices)) print_nested_dict(all_devices) if run: log.info("add watch for video device changes") def callback(added=None, device=None): if added is not None or device: log.info("video device %s: %s", ["removed", "added"][added], device) else: log.info("device change") log.info("starting main loop") main_loop = glib.MainLoop() glib.idle_add(add_video_device_change_callback, callback) try: main_loop.run() except KeyboardInterrupt: pass log.info("terminating, removing callback") remove_video_device_change_callback(callback)
def _glib(): from xpra.gtk_common.gobject_compat import import_glib return import_glib()
def main(): from xpra.platform import program_context with program_context("Xpra-Sound-Source"): import os.path if "-v" in sys.argv: log.enable_debug() sys.argv.remove("-v") if len(sys.argv) not in (2, 3): log.error("usage: %s filename [codec] [--encoder=rencode]", sys.argv[0]) return 1 filename = sys.argv[1] if filename=="-": from xpra.os_util import disable_stdout_buffering disable_stdout_buffering() elif os.path.exists(filename): log.error("file %s already exists", filename) return 1 codec = None codecs = get_codecs() if len(sys.argv)==3: codec = sys.argv[2] if codec not in codecs: log.error("invalid codec: %s, codecs supported: %s", codec, codecs) return 1 else: parts = filename.split(".") if len(parts)>1: extension = parts[-1] if extension.lower() in codecs: codec = extension.lower() log.info("guessed codec %s from file extension %s", codec, extension) if codec is None: codec = MP3 log.info("using default codec: %s", codec) #in case we're running against pulseaudio, #try to setup the env: try: from xpra.platform.paths import get_icon_filename f = get_icon_filename("xpra.png") from xpra.sound.pulseaudio.pulseaudio_util import add_audio_tagging_env add_audio_tagging_env(icon_path=f) except Exception as e: log.warn("failed to setup pulseaudio tagging: %s", e) from threading import Lock if filename=="-": f = sys.stdout else: f = open(filename, "wb") ss = SoundSource(codecs=[codec]) lock = Lock() def new_buffer(ss, data, metadata): log.info("new buffer: %s bytes (%s), metadata=%s", len(data), type(data), metadata) with lock: if f: f.write(data) f.flush() from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib_mainloop = glib.MainLoop() ss.connect("new-buffer", new_buffer) ss.start() import signal def deadly_signal(sig, frame): log.warn("got deadly signal %s", SIGNAMES.get(sig, sig)) glib.idle_add(ss.stop) glib.idle_add(glib_mainloop.quit) def force_quit(sig, frame): sys.exit() signal.signal(signal.SIGINT, force_quit) signal.signal(signal.SIGTERM, force_quit) from xpra.gtk_common.gobject_compat import is_gtk3 if not is_gtk3(): signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) try: glib_mainloop.run() except Exception as e: log.error("main loop error: %s", e) ss.stop() f.flush() if f!=sys.stdout: log.info("wrote %s bytes to %s", f.tell(), filename) with lock: f.close() f = None return 0
def main(): from xpra.platform import program_context with program_context("Xpra-Sound-Source"): import os.path if "-v" in sys.argv: log.enable_debug() sys.argv.remove("-v") if len(sys.argv) not in (2, 3): log.error("usage: %s filename [codec] [--encoder=rencode]", sys.argv[0]) return 1 filename = sys.argv[1] if filename=="-": from xpra.os_util import disable_stdout_buffering disable_stdout_buffering() elif os.path.exists(filename): log.error("file %s already exists", filename) return 1 codec = None encoders = get_encoders() if len(sys.argv)==3: codec = sys.argv[2] if codec not in encoders: log.error("invalid codec: %s, codecs supported: %s", codec, encoders) return 1 else: parts = filename.split(".") if len(parts)>1: extension = parts[-1] if extension.lower() in encoders: codec = extension.lower() log.info("guessed codec %s from file extension %s", codec, extension) if codec is None: codec = MP3 log.info("using default codec: %s", codec) #in case we're running against pulseaudio, #try to setup the env: try: from xpra.platform.paths import get_icon_filename f = get_icon_filename("xpra.png") from xpra.sound.pulseaudio.pulseaudio_util import add_audio_tagging_env add_audio_tagging_env(icon_path=f) except Exception as e: log.warn("failed to setup pulseaudio tagging: %s", e) from threading import Lock if filename=="-": f = sys.stdout else: f = open(filename, "wb") ss = SoundSource(codecs=[codec]) lock = Lock() def new_buffer(_soundsource, data, metadata, packet_metadata): log.info("new buffer: %s bytes (%s), metadata=%s", len(data), type(data), metadata) with lock: if f: for x in packet_metadata: f.write(x) f.write(data) f.flush() from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() glib_mainloop = glib.MainLoop() ss.connect("new-buffer", new_buffer) ss.start() import signal def deadly_signal(sig, _frame): log.warn("got deadly signal %s", SIGNAMES.get(sig, sig)) glib.idle_add(ss.stop) glib.idle_add(glib_mainloop.quit) def force_quit(_sig, _frame): sys.exit() signal.signal(signal.SIGINT, force_quit) signal.signal(signal.SIGTERM, force_quit) signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) try: glib_mainloop.run() except Exception as e: log.error("main loop error: %s", e) ss.stop() f.flush() if f!=sys.stdout: log.info("wrote %s bytes to %s", f.tell(), filename) with lock: f.close() f = None return 0
# This file is part of Xpra. # Copyright (C) 2013-2017 Antoine Martin <*****@*****.**> # Copyright (C) 2008 Nathaniel Smith <*****@*****.**> # Xpra is released under the terms of the GNU GPL v2, or, at your option, any # later version. See the file COPYING for details. import os import sys from xpra.gtk_common.gobject_compat import import_glib, import_gobject glib = import_glib() glib.threads_init() gobject = import_gobject() gobject.threads_init() from multiprocessing import Queue as MQueue, freeze_support #@UnresolvedImport freeze_support() from xpra.log import Logger log = Logger("proxy") authlog = Logger("proxy", "auth") from xpra.util import LOGIN_TIMEOUT, AUTHENTICATION_ERROR, SESSION_NOT_FOUND, SERVER_ERROR, repr_ellipsized, print_nested_dict, csv, typedict from xpra.os_util import get_username_for_uid, get_groups, get_home_for_uid, WIN32, POSIX from xpra.server.proxy.proxy_instance_process import ProxyInstanceProcess from xpra.server.server_core import ServerCore from xpra.server.control_command import ArgsControlCommand, ControlError from xpra.child_reaper import getChildReaper from xpra.scripts.config import make_defaults_struct, PROXY_START_OVERRIDABLE_OPTIONS from xpra.scripts.main import parse_display_name, connect_to, start_server_subprocess from xpra.make_thread import start_thread
# later version. See the file COPYING for details. """ client_launcher.py This is a simple GUI for starting the xpra client. """ import os.path import sys import shlex import signal import traceback from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, import_gobject, import_pango, import_glib glib = import_glib() gobject = import_gobject() gobject.threads_init() gtk = import_gtk() gdk = import_gdk() try: gdk.threads_init() except: pass pango = import_pango() from xpra.platform.gui import init as gui_init gui_init() from xpra.scripts.config import read_config, make_defaults_struct, validate_config, save_config from xpra.codecs.loader import PREFERED_ENCODING_ORDER
def main(): from xpra.platform import init, clean init("Sound-Record") try: from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() args = sys.argv log.enable_debug() import os.path if len(args) not in (2, 3): print("usage: %s [-v|--verbose] filename [codec]" % sys.argv[0]) return 1 filename = args[1] if not os.path.exists(filename): print("file %s does not exist" % filename) return 2 codecs = get_codecs() if len(args)==3: codec = args[2] if codec not in codecs: print("invalid codec: %s" % codec) print("only supported: %s" % str(codecs.keys())) return 2 codecs = [codec] else: codec = None parts = filename.split(".") if len(parts)>1: extension = parts[-1] if extension.lower() in codecs: codec = extension.lower() print("guessed codec %s from file extension %s" % (codec, extension)) if codec is None: print("assuming this is an mp3 file...") codec = MP3 codecs = [codec] log.enable_debug() with open(filename, "rb") as f: data = f.read() print("loaded %s bytes from %s" % (len(data), filename)) #force no leak since we push all the data at once global QUEUE_LEAK, QUEUE_SILENT QUEUE_LEAK = GST_QUEUE_NO_LEAK QUEUE_SILENT = 1 ss = SoundSink(codecs=codecs) def eos(*args): print("eos") glib.idle_add(glib_mainloop.quit) ss.connect("eos", eos) ss.start() glib_mainloop = glib.MainLoop() import signal def deadly_signal(*args): glib.idle_add(ss.stop) glib.idle_add(glib_mainloop.quit) def force_quit(sig, frame): sys.exit() signal.signal(signal.SIGINT, force_quit) signal.signal(signal.SIGTERM, force_quit) from xpra.gtk_common.gobject_compat import is_gtk3 if not is_gtk3(): signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) def check_for_end(*args): qtime = ss.queue.get_property("current-level-time")//MS_TO_NS if qtime<=0: log.info("underrun (end of stream)") thread.start_new_thread(ss.stop, ()) glib.timeout_add(500, glib_mainloop.quit) return False return True glib.timeout_add(1000, check_for_end) glib.idle_add(ss.add_data, data) glib_mainloop.run() return 0 finally: clean()
def setup_mainloop(self): glib = import_glib() self.mainloop = glib.MainLoop() self.idle_add = glib.idle_add self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove
def main(): from xpra.platform import program_context with program_context("Sound-Record"): from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() args = sys.argv log.enable_debug() import os.path if len(args) not in (2, 3): print("usage: %s [-v|--verbose] filename [codec]" % sys.argv[0]) return 1 filename = args[1] if not os.path.exists(filename): print("file %s does not exist" % filename) return 2 codecs = get_codecs() if len(args)==3: codec = args[2] if codec not in codecs: print("invalid codec: %s" % codec) print("only supported: %s" % str(codecs.keys())) return 2 codecs = [codec] else: codec = None parts = filename.split(".") if len(parts)>1: extension = parts[-1] if extension.lower() in codecs: codec = extension.lower() print("guessed codec %s from file extension %s" % (codec, extension)) if codec is None: print("assuming this is an mp3 file...") codec = MP3 codecs = [codec] log.enable_debug() with open(filename, "rb") as f: data = f.read() print("loaded %s bytes from %s" % (len(data), filename)) #force no leak since we push all the data at once global QUEUE_LEAK, QUEUE_SILENT QUEUE_LEAK = GST_QUEUE_NO_LEAK QUEUE_SILENT = 1 ss = SoundSink(codecs=codecs) def eos(*args): print("eos") glib.idle_add(glib_mainloop.quit) ss.connect("eos", eos) ss.start() glib_mainloop = glib.MainLoop() import signal def deadly_signal(*args): glib.idle_add(ss.stop) glib.idle_add(glib_mainloop.quit) def force_quit(sig, frame): sys.exit() signal.signal(signal.SIGINT, force_quit) signal.signal(signal.SIGTERM, force_quit) from xpra.gtk_common.gobject_compat import is_gtk3 if not is_gtk3(): signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) def check_for_end(*args): qtime = ss.queue.get_property("current-level-time")//MS_TO_NS if qtime<=0: log.info("underrun (end of stream)") thread.start_new_thread(ss.stop, ()) glib.timeout_add(500, glib_mainloop.quit) return False return True glib.timeout_add(1000, check_for_end) glib.idle_add(ss.add_data, data) glib_mainloop.run() return 0