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 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 _glib():
from xpra.gtk_common.gobject_compat import import_glib
return import_glib()
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
