def do_command(self, caps : typedict): def print_fn(s): sys.stdout.write("%s\n" % (s,)) if not caps: self.quit(EXIT_NO_DATA) return exit_code = EXIT_OK try: if FLATTEN_INFO<2: #compatibility mode: c = flatten_dict(caps) for k in sorted_nicely(c.keys()): v = c.get(k) #FIXME: this is a nasty and horrible python3 workaround (yet again) #we want to print bytes as strings without the ugly 'b' prefix.. #it assumes that all the strings are raw or in (possibly nested) lists or tuples only #we assume that all strings we get are utf-8, #and fallback to the bytestostr hack if that fails def fixvalue(w): if isinstance(w, bytes): if k.endswith(".data"): return hexstr(w) return u(w) elif isinstance(w, (tuple,list)): return type(w)([fixvalue(x) for x in w]) return w v = fixvalue(v) k = fixvalue(k) print_fn("%s=%s" % (k, nonl(v))) else: print_nested_dict(caps, print_fn=print_fn) except OSError: exit_code = EXIT_IO_ERROR self.quit(exit_code)
def main(force_enable=False): from xpra.platform import program_context from xpra.platform.gui import init as gui_init from xpra.util import print_nested_dict from xpra.log import enable_color with program_context("OpenGL-Check"): gui_init() enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() from xpra.client.gl.gtk_compat import log as clog clog.enable_debug() # replace ImportError with a log message: global gl_check_error errors = [] def log_error(msg): log.error("ERROR: %s", msg) errors.append(msg) gl_check_error = log_error props = check_support(force_enable, verbose) log.info("") if len(errors) > 0: log.info("OpenGL errors:") for e in errors: log.info(" %s", e) log.info("") log.info("OpenGL properties:") print_nested_dict(props) return len(errors)
def main(force_enable=False): from xpra.platform import program_context from xpra.platform.gui import init as gui_init from xpra.util import print_nested_dict from xpra.log import enable_color with program_context("OpenGL-Check"): gui_init() enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() from xpra.client.gl.gtk_base.gtk_compat import log as clog clog.enable_debug() #replace ImportError with a log message: global gl_check_error errors = [] def log_error(msg): log.error("ERROR: %s", msg) errors.append(msg) gl_check_error = log_error props = check_support(force_enable, verbose) log.info("") if len(errors) > 0: log.info("OpenGL errors:") for e in errors: log.info(" %s", e) log.info("") log.info("OpenGL properties:") print_nested_dict(props) return len(errors)
def _process_input_devices(self, _proto, packet): self.input_devices_format = packet[1] self.input_devices_data = packet[2] from xpra.util import print_nested_dict mouselog("client %s input devices:", self.input_devices_format) print_nested_dict(self.input_devices_data, print_fn=mouselog) self.setup_input_devices()
def do_command(self): if self.server_capabilities: if FLATTEN_INFO<2: #compatibility mode: c = flatten_dict(self.server_capabilities) for k in sorted_nicely(c.keys()): v = c.get(k) if PYTHON3: #FIXME: this is a nasty and horrible python3 workaround (yet again) #we want to print bytes as strings without the ugly 'b' prefix.. #it assumes that all the strings are raw or in (possibly nested) lists or tuples only #we assume that all strings we get are utf-8, #and fallback to the bytestostr hack if that fails def fixvalue(w): if type(w)==bytes: try: return w.decode("utf-8") except: return bytestostr(w) elif type(w) in (tuple,list): return type(w)([fixvalue(x) for x in w]) return w v = fixvalue(v) k = fixvalue(k) log.info("%s=%s", k, nonl(v)) else: print_nested_dict(self.server_capabilities) self.quit(EXIT_OK)
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() from xpra.platform import program_context with program_context("Nvidia-Info", "Nvidia Info"): #this will log the version number: get_nvidia_module_version() if is_blacklisted(): log.warn("Warning: this driver version is blacklisted") log.info("NVENC license keys:") for v in (0, 8): keys = get_license_keys(v) log.info("* version %s: %s key(s)", v or "common", len(keys)) for k in keys: log.info(" %s", k) try: import pynvml assert pynvml except ImportError: log.warn("Warning: the pynvml library is missing") log.warn(" cannot identify the GPUs installed") else: cards = get_cards() if cards: log.info("") log.info("%i card%s:", len(cards), engs(cards)) print_nested_dict(cards, print_fn=log.info)
def main(): from xpra.platform import program_context #pylint: disable=import-outside-toplevel with program_context("XDG-Menu-Helper", "XDG Menu Helper"): for x in list(sys.argv): if x in ("-v", "--verbose"): sys.argv.remove(x) add_debug_category("menu") log.enable_debug() def icon_fmt(icondata): return "%i bytes" % len(icondata) if len(sys.argv) > 1: for x in sys.argv[1:]: if os.path.isabs(x): v = icon_util.load_icon_from_file(x) print("load_icon_from_file(%s)=%s" % (x, v)) else: menu = load_xdg_menu_data() if menu: print() print("application menu:") print_nested_dict(menu, vformat={"IconData": icon_fmt}) else: print("no application menu data found") #try desktop sessions: sessions = load_desktop_sessions() if sessions: print() print("session menu:") print_nested_dict(sessions, vformat={"IconData": icon_fmt}) else: print("no session menu data found") return 0
def main(): from xpra.platform import program_context from xpra.util import print_nested_dict from xpra.log import enable_color with program_context("GUI-Properties"): enable_color() init() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: from xpra.log import get_all_loggers for x in get_all_loggers(): x.enable_debug() # naughty, but how else can I hook this up? import os if os.name == "posix": try: from xpra.x11.bindings import posix_display_source # @UnusedImport except: pass # maybe running on OSX? hope for the best.. i = get_info() print_nested_dict(i)
def main(): from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("Features-Info", "Features Info"): d = {} for k in _features_list_: d[k] = globals()[k] print_nested_dict(d)
def main(args): from xpra.platform import program_context from xpra.log import enable_color, LOG_FORMAT, NOPREFIX_FORMAT from xpra.util import print_nested_dict, pver with program_context("Loader", "Encoding Info"): verbose = "-v" in args or "--verbose" in args args = [x for x in args if x not in ("-v", "--verbose")] format_string = NOPREFIX_FORMAT if verbose: format_string = LOG_FORMAT log.enable_debug() enable_color(format_string) if len(args)>1: for x in args[1:]: load_codec(x) list_codecs = args[1:] else: load_codecs() list_codecs = ALL_CODECS #not really a codec, but gets used by codecs, so include version info: add_codec_version("numpy", "numpy") print("codecs and csc modules found:") #print("codec_status=%s" % codecs) for name in sorted(list_codecs): mod = codecs.get(name, "") f = mod if mod and hasattr(mod, "__file__"): f = mod.__file__ if f.startswith(os.getcwd()): f = f[len(os.getcwd()):] if f.startswith(os.path.sep): f = f[1:] print("* %s : %s" % (name.ljust(20), f)) if mod and verbose: try: if name.find("csc")>=0: cs = list(mod.get_input_colorspaces()) for c in list(cs): cs += list(mod.get_output_colorspaces(c)) print(" colorspaces: %s" % csv(list(set(cs)))) elif name.find("enc")>=0 or name.find("dec")>=0: encodings = mod.get_encodings() print(" encodings: %s" % csv(encodings)) try: i = mod.get_info() for k,v in sorted(i.items()): print(" %s = %s" % (k,v)) except Exception: pass except Exception as e: print("error getting extra information on %s: %s" % (name, e)) print("") print("codecs versions:") def forcever(v): return pver(v, numsep=".", strsep=".").lstrip("v") print_nested_dict(codec_versions, vformat=forcever) return 0
def main(): from xpra.util import print_nested_dict crypto_backend_init() from xpra.platform import program_context import sys if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() with program_context("Encryption Properties"): print_nested_dict(get_crypto_caps())
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category add_debug_category("util") from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("Path-Info", "Path Info"): print_nested_dict(get_info())
def main(): import sys from xpra.platform.win32.common import WTSGetActiveConsoleSessionId csid = WTSGetActiveConsoleSessionId() print("WTSGetActiveConsoleSessionId()=%s" % csid) print_nested_dict(get_sessions()) if len(sys.argv)>1: for x in sys.argv[1:]: print("find_session(%s)=%s" % (x, find_session(x)))
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() add_debug_category("nvfbc") from xpra.platform import program_context with program_context("NvFBC-Capture", "NvFBC Capture"): from xpra.platform.paths import get_download_dir from xpra.util import print_nested_dict from xpra.os_util import WIN32, LINUX if WIN32: from xpra.codecs.nvfbc import fbc_capture_win as fbc_capture #@UnresolvedImport @UnusedImport elif LINUX: from xpra.codecs.nvfbc import fbc_capture_linux as fbc_capture #@UnresolvedImport @Reimport else: raise Exception("nvfbc is not support on %s" % sys.platform) fbc_capture.init_module() log.info("Info:") print_nested_dict(fbc_capture.get_info(), print_fn=log.info) log.info("Status:") print_nested_dict(fbc_capture.get_status(), print_fn=log.info) try: log("creating test capture class") if USE_NVFBC_CUDA: c = fbc_capture.NvFBC_CUDACapture() #@UndefinedVariable else: c = fbc_capture.NvFBC_SysCapture() #@UndefinedVariable log("Capture=%s", c) c.init_context() assert c.refresh() except Exception as e: log("Capture()", exc_info=True) log.error("Error: failed to create test capture instance:") log.error(" %s", e) return 1 image = c.get_image() assert image from PIL import Image w = image.get_width() h = image.get_height() pixels = memoryview_to_bytes(image.get_pixels()) stride = image.get_rowstride() rgb_format = image.get_pixel_format() try: img = Image.frombuffer("RGB", (w, h), pixels, "raw", rgb_format, stride, 1) filename = os.path.join( os.path.expanduser(get_download_dir()), "screenshot-%s-%i.png" % (rgb_format, time.time())) img.save(filename, "png") log.info("screenshot saved to %s", filename) return 0 except Exception as e: log.warn("Error: failed to save %s:", rgb_format) log.warn(" %s", e) return 1
def main(): #use gtk as display source: from xpra.x11.gtk2 import gdk_display_source assert gdk_display_source from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("GTK-Keyboard", "GTK Keyboard"): x = GTKKeyboardHelper(None, True, "") x.query_xkbmap() print_nested_dict(x.get_keymap_properties())
def main(): from xpra.platform import program_context from xpra.log import enable_color from xpra.util import print_nested_dict with program_context("Pulseaudio-Info"): enable_color() if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() i = get_info() print_nested_dict(i)
def main(): import sys from xpra.os_util import WIN32, OSX, POSIX, bytestostr from xpra.util import print_nested_dict, csv from xpra.platform import program_context from xpra.log import Logger, enable_color with program_context("Keyboard-Tool", "Keyboard Tool"): #use the logger for the platform module we import from global log log = None platform_import(globals(), "keyboard", True, "log") if log is None: log = Logger("keyboard") enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv or \ (WIN32 and not ("-q" in sys.argv or "--quiet")) if verbose: log.enable_debug() #naughty, but how else can I hook this up? if POSIX and not OSX: try: from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport init_posix_display_source() except Exception as e: print("failed to connect to the X11 server:") print(" %s" % e) #hope for the best.. keyboard = Keyboard() mod_meanings, mod_managed, mod_pointermissing = keyboard.get_keymap_modifiers( ) print("Modifiers:") print_nested_dict(mod_meanings) print("") print("Server Managed : %s" % (csv(mod_managed) or "None")) print("Missing from pointer events : %s" % (csv(mod_pointermissing) or "None")) print("") layout, layouts, variant, variants, options = keyboard.get_layout_spec( ) print("Layout: '%s'" % bytestostr(layout or b"")) print("Layouts: %s" % csv("'%s'" % x for x in (layouts or []))) print("Variant: '%s'" % bytestostr(variant or b"")) print("Variants: %s" % csv("'%s'" % x for x in (variants or []))) print("Options: %s" % (options)) print("") print("Repeat: %s" % csv(keyboard.get_keyboard_repeat())) if verbose and POSIX: keysyms = keyboard.get_x11_keymap() if keysyms: print("Keysyms:") for keycode, keysyms in keysyms.items(): print(" %3i : %s" % (keycode, csv(keysyms)))
def main(): #use gtk as display source: from xpra.os_util import POSIX, OSX if POSIX and not OSX: from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source init_gdk_display_source() from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("GTK-Keyboard", "GTK Keyboard"): x = GTKKeyboardHelper(None, True, "") x.query_xkbmap() print_nested_dict(x.get_keymap_properties())
def main(): import sys import socket from xpra.os_util import POSIX from xpra.util import print_nested_dict from xpra.net.net_util import import_netifaces, get_interfaces, if_nametoindex from xpra.platform import program_context from xpra.log import Logger, enable_color, add_debug_category, enable_debug_for log = Logger("network") with program_context("Network-Device-Info", "Network Device Info"): enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: enable_debug_for("network") add_debug_category("network") log.enable_debug() print("Network interfaces found:") netifaces = import_netifaces() for iface in get_interfaces(): if if_nametoindex: print("* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface))) else: print("* %s" % iface) addresses = netifaces.ifaddresses(iface) #@UndefinedVariable for addr, defs in addresses.items(): if addr in (socket.AF_INET, socket.AF_INET6): for d in defs: ip = d.get("addr") if ip: stype = { socket.AF_INET: "IPv4", socket.AF_INET6: "IPv6", }[addr] print(" * %s: %s" % (stype, ip)) if POSIX: from xpra.net.socket_util import create_tcp_socket try: sock = create_tcp_socket(ip, 0) sockfd = sock.fileno() info = get_interface_info(sockfd, iface) if info: print_nested_dict(info, prefix=" ", lchar="-") finally: sock.close() if not POSIX: info = get_interface_info(0, iface) if info: print(" %s" % info)
def main(): from xpra.platform import program_context from xpra.log import enable_color with program_context("GTK-Version-Info", "GTK Version Info"): enable_color() print("%s" % get_gtk_version_info()) if POSIX and not OSX: from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport init_posix_display_source() import warnings warnings.simplefilter("ignore") print(get_screen_sizes()[0]) print_nested_dict(get_screens_info()[0])
def main(): from xpra.platform import program_context from xpra.log import enable_color from xpra.util import print_nested_dict, pver with program_context("Loader", "Encoding Info"): enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() load_codecs() print("codecs and csc modules found:") #print("codec_status=%s" % codecs) for name in sorted(ALL_CODECS): mod = codecs.get(name, "") f = mod if mod and hasattr(mod, "__file__"): f = mod.__file__ if f.startswith(os.getcwd()): f = f[len(os.getcwd()):] if f.startswith(os.path.sep): f = f[1:] print("* %s : %s" % (name.ljust(20), f)) if mod and verbose: try: if name.find("csc") >= 0: cs = list(mod.get_input_colorspaces()) for c in list(cs): cs += list(mod.get_output_colorspaces(c)) print(" colorspaces: %s" % ", ".join(list(set(cs)))) elif name.find("enc") >= 0 or name.find("dec") >= 0: encodings = mod.get_encodings() print(" encodings: %s" % ", ".join(encodings)) try: i = mod.get_info() for k, v in sorted(i.items()): print(" %s = %s" % (k, v)) except: pass except Exception as e: print("error getting extra information on %s: %s" % (name, e)) print("") print("codecs versions:") def forcever(v): return pver(v, numsep=".", strsep=".").lstrip("v") print_nested_dict(codec_versions, vformat=forcever)
def log_ssl_info(ssl_sock): from xpra.log import Logger ssllog = Logger("ssl") ssllog("server_hostname=%s", ssl_sock.server_hostname) cipher = ssl_sock.cipher() if cipher: ssllog.info(" %s, %s bits", cipher[0], cipher[2]) try: cert = ssl_sock.getpeercert() except ValueError: pass else: if cert: ssllog("certificate:") print_nested_dict(ssl_sock.getpeercert(), prefix=" ", print_fn=ssllog)
def main(): from xpra.platform import program_context with program_context("XDG-Menu-Helper", "XDG Menu Helper"): for x in list(sys.argv): if x in ("-v", "--verbose"): sys.argv.remove(x) add_debug_category("menu") log.enable_debug() def icon_fmt(icondata): return "%i bytes" % len(icondata) menu = load_xdg_menu_data() print_nested_dict(menu, vformat={"IconData": icon_fmt}) return 0
def main(): from xpra.codecs.loader import log as loader_log, load_codecs from xpra.util import print_nested_dict from xpra.log import enable_color from xpra.platform import program_context with program_context("Video Helper"): enable_color() if "-v" in sys.argv or "--verbose" in sys.argv: loader_log.enable_debug() log.enable_debug() load_codecs() vh = getVideoHelper() vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS) vh.init() info = vh.get_info() print_nested_dict(info)
def main(): from xpra.codecs.loader import log as loader_log, load_codecs from xpra.util import print_nested_dict from xpra.log import enable_color from xpra.platform import program_context with program_context("Video Helper"): enable_color() if "-v" in sys.argv or "--verbose" in sys.argv: loader_log.enable_debug() log.enable_debug() load_codecs() vh = getVideoHelper() vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS) vh.init() log.info("VideoHelper.get_info():") info = vh.get_info() print_nested_dict(info)
def main(): from xpra.platform import program_context from xpra.log import enable_color from xpra.util import print_nested_dict, pver with program_context("Loader", "Encoding Info"): enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() load_codecs() print("codecs and csc modules found:") #print("codec_status=%s" % codecs) for name in sorted(ALL_CODECS): mod = codecs.get(name, "") f = mod if mod and hasattr(mod, "__file__"): f = mod.__file__ if f.startswith(os.getcwd()): f = f[len(os.getcwd()):] if f.startswith(os.path.sep): f = f[1:] print("* %s : %s" % (name.ljust(20), f)) if mod and verbose: try: if name.find("csc")>=0: cs = list(mod.get_input_colorspaces()) for c in list(cs): cs += list(mod.get_output_colorspaces(c)) print(" colorspaces: %s" % ", ".join(list(set(cs)))) elif name.find("enc")>=0 or name.find("dec")>=0: encodings = mod.get_encodings() print(" encodings: %s" % ", ".join(encodings)) try: i = mod.get_info() for k,v in sorted(i.items()): print(" %s = %s" % (k,v)) except: pass except Exception as e: print("error getting extra information on %s: %s" % (name, e)) print("") print("codecs versions:") def forcever(v): return pver(v, numsep=".", strsep=".").lstrip("v") print_nested_dict(codec_versions, vformat=forcever)
def main(): from xpra.platform import program_context from xpra.platform.gui import init as gui_init from xpra.util import print_nested_dict from xpra.log import enable_color with program_context("OpenGL-Check"): gui_init() enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() if POSIX and not OSX: from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source init_gdk_display_source() force_enable = "-f" in sys.argv or "--force" in sys.argv from xpra.platform.gl_context import GLContext log("testing %s", GLContext) gl_context = GLContext() log("GLContext=%s", gl_context) #replace ImportError with a log message: global gl_check_error, raise_fatal_error errors = [] def log_error(msg): log.error("ERROR: %s", msg) errors.append(msg) gl_check_error = log_error raise_fatal_error = log_error try: props = gl_context.check_support(force_enable) except Exception as e: props = {} log("check_support", exc_info=True) errors.append(e) log.info("") if len(errors) > 0: log.info("OpenGL errors:") for e in errors: log.info(" %s", e) if props: log.info("") log.info("OpenGL properties:") print_nested_dict(props) return len(errors)
def main(): from xpra.os_util import load_binary_file if "-v" in sys.argv: log.enable_debug() sys.argv.remove("-v") if len(sys.argv)>1: for filename in sys.argv[1:]: if not os.path.exists(filename): log.warn("file argument '%s' does not exist, ignoring", filename) continue data = load_binary_file(filename) devices = do_get_pa_device_options(data, True, False) log.info("%s devices found in '%s'", len(devices), filename) print_nested_dict(devices) return i = get_info() print_nested_dict(i)
def main(): from xpra.util import nonl, pver, flatten_dict, print_nested_dict def print_version_dict(d, vformat=pver): for k in sorted(d.keys()): v = d[k] print("* %-48s : %s" % (str(k).replace(".version", "").ljust(12), nonl(vformat(v)))) from xpra.platform import program_context with program_context("GTK-Version-Info", "GTK Version Info"): from xpra.platform.gui import init as gui_init, ready gui_init() ready() from xpra.gtk_common import gtk_util if "-v" in sys.argv or "--verbose" in sys.argv: gtk_util.SHOW_ALL_VISUALS = True print("GTK Version:") print_version_dict(flatten_dict(gtk_util.get_gtk_version_info())) print("Display:") print_nested_dict(gtk_util.get_display_info(), vformat=str)
def main(): import sys if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for enable_debug_for("webcam") 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 main(): import sys from xpra.util import print_nested_dict, csv from xpra.platform import program_context from xpra.log import Logger, enable_color with program_context("Keyboard-Tool", "Keyboard Tool"): #use the logger for the platform module we import from global log log = None platform_import(globals(), "keyboard", True, "log") if log is None: log = Logger("keyboard") enable_color() if "-v" in sys.argv or "--verbose" in sys.argv or \ (sys.platform.startswith("win") and not ("-q" in sys.argv or "--quiet")): log.enable_debug() #naughty, but how else can I hook this up? import os if os.name == "posix": try: from xpra.x11.bindings import posix_display_source #@UnusedImport except: pass #maybe running on OSX? hope for the best.. keyboard = Keyboard() mod_meanings, mod_managed, mod_pointermissing = keyboard.get_keymap_modifiers( ) print("Modifiers:") print_nested_dict(mod_meanings) print("") print("Server Managed : %s" % (csv(mod_managed) or "None")) print("Missing from pointer events : %s" % (csv(mod_pointermissing) or "None")) print("") layout, layouts, variant, variants = keyboard.get_layout_spec() print("Layout: '%s'" % (layout)) print("Layouts: %s" % (layouts, )) print("Variant: '%s'" % (variant or "")) print("Variants: %s" % (variants, )) print("") print("Repeat: %s" % csv(keyboard.get_keyboard_repeat()))
def main(): from xpra.platform import program_context from xpra.util import print_nested_dict from xpra.os_util import OSX, POSIX from xpra.log import enable_color with program_context("GUI-Properties"): enable_color() init() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: from xpra.log import get_all_loggers for x in get_all_loggers(): x.enable_debug() #naughty, but how else can I hook this up? if POSIX and not OSX: from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport init_posix_display_source() i = get_info() print_nested_dict(i, hex_keys=("data", "icc-data", "icc-profile")) return 0
def do_command(self): if self.server_capabilities: if FLATTEN_INFO<2: #compatibility mode: for k in sorted_nicely(self.server_capabilities.keys()): v = self.server_capabilities.get(k) if sys.version_info[0]>=3: #FIXME: this is a nasty and horrible python3 workaround (yet again) #we want to print bytes as strings without the ugly 'b' prefix.. #it assumes that all the strings are raw or in (possibly nested) lists or tuples only def fixvalue(w): if type(w)==bytes: return bytestostr(w) elif type(w) in (tuple,list): return type(w)([fixvalue(x) for x in w]) return w v = fixvalue(v) log.info("%s=%s", bytestostr(k), nonl(v)) else: print_nested_dict(self.server_capabilities) self.quit(EXIT_OK)
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() from xpra.platform import program_context with program_context("Nvidia-Info", "Nvidia Info"): #this will log the version number: get_nvidia_module_version() if is_blacklisted(): log.warn("Warning: this driver version is blacklisted") log.info("NVENC license keys:") for v in (0, 7): keys = get_nvenc_license_keys(v) log.info("* version %s: %s key(s)", v or "common", len(keys)) for k in keys: log.info(" %s", k) cards = get_cards() if cards: log.info("") log.info("%i card%s:", len(cards), engs(cards)) print_nested_dict(cards, print_fn=log.info)
def main(): from xpra.platform import program_context from xpra.util import print_nested_dict from xpra.log import enable_color with program_context("GUI-Properties"): enable_color() init() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: from xpra.log import get_all_loggers for x in get_all_loggers(): x.enable_debug() #naughty, but how else can I hook this up? if os.name == "posix": try: from xpra.x11.bindings import posix_display_source #@UnusedImport except: pass #maybe running on OSX? hope for the best.. i = get_info() print_nested_dict(i, hex_keys=("data", "icc-data", "icc-profile"))
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 main(): import sys if "-v" in sys.argv or "--verbose" in sys.argv: log.enable_debug() from xpra.platform import program_context with program_context("CUDA-Info", "CUDA Info"): log.info("pycuda_info") print_nested_dict(get_pycuda_info(), print_fn=log.info) log.info("cuda_info") print_nested_dict(get_cuda_info(), print_fn=log.info) log.info("preferences:") print_nested_dict(get_prefs())
def main(): from xpra.platform import program_context with program_context("Version-Info", "Version Info"): print("Build:") print_nested_dict(get_version_info()) print("") print("Platform:") pi = get_platform_info() #ugly workaround for the fact that "sys.platform" has no key.. if "" in pi: pi["sys"] = pi[""] del pi[""] print_nested_dict(pi) print("") print("Host:") d = get_host_info() #add os specific version info: try: from xpra.platform.info import get_version_info as pvinfo d.update(pvinfo()) except: pass print_nested_dict(d)
"BGRA" : ("YUV2BGRA_I420", "BGRA2YUV_I420"), "BGRX" : ("YUV2BGRA_I420", "BGRA2YUV_I420"), }.items(): fromyuv, toyuv = conv for src_fmt, dst_fmt, conv_const in ( ("YUV420P", rgb_fmt, fromyuv), (rgb_fmt, "YUV420P", toyuv), ): f = "COLOR_%s" % conv_const v = getattr(cv2, f, None) if v is not None: FLAG_STR[int(v)] = conv_const CONVERSIONS.setdefault(src_fmt, {})[dst_fmt] = int(v) log("csc_opencv FLAGS: %s", FLAG_STR) log("csc_opencv CONVERSIONS:") print_nested_dict(CONVERSIONS, print_fn=log) def get_input_colorspaces(): #we don't handle planar input yet: return [x for x in CONVERSIONS.keys() if x!="YUV420P"] def get_output_colorspaces(input_colorspace): return CONVERSIONS[input_colorspace] def get_spec(in_colorspace, out_colorspace): assert in_colorspace in CONVERSIONS, "invalid input colorspace: %s (must be one of %s)" % (in_colorspace, get_input_colorspaces()) out_cs = CONVERSIONS[in_colorspace] assert out_colorspace in out_cs, "invalid output colorspace: %s (must be one of %s)" % (out_colorspace, out_cs) #low score as this should be used as fallback only: return csc_spec(ColorspaceConverter, codec_type=get_type(), quality=50, speed=0, setup_cost=40, min_w=2, min_h=2, max_w=16*1024, max_h=16*1024, can_scale=False)
def main(): from xpra.util import print_nested_dict from xpra.platform import program_context from xpra.log import enable_color with program_context("Network-Info", "Network Info"): enable_color() verbose = "-v" in sys.argv or "--verbose" in sys.argv if verbose: log.enable_debug() print("Network interfaces found:") for iface in get_interfaces(): if if_nametoindex: print("* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface))) else: print("* %s" % iface) def pver(v): if type(v) in (tuple, list): s = "" for i in range(len(v)): if i>0: #dot seperated numbers if type(v[i-1])==int: s += "." else: s += ", " s += str(v[i]) return s if type(v)==bytes: from xpra.os_util import bytestostr v = bytestostr(v) if type(v)==str and v.startswith("v"): return v[1:] return str(v) print("Gateways found:") print_nested_dict(get_gateways()) print("") print("Protocol Capabilities:") from xpra.net.protocol import get_network_caps netcaps = get_network_caps() netif = {"" : has_netifaces} if netifaces_version: netif["version"] = netifaces_version netcaps["netifaces"] = netif print_nested_dict(netcaps) print("") print("Network Config:") print_nested_dict(get_net_config()) net_sys = get_net_sys_config() if net_sys: print("") print("Network System Config:") print_nested_dict(net_sys) print("") print("SSL:") print_nested_dict(get_ssl_info()) try: from xpra.net.crypto import crypto_backend_init, get_crypto_caps crypto_backend_init() ccaps = get_crypto_caps() if ccaps: print("") print("Crypto Capabilities:") print_nested_dict(ccaps) except Exception as e: print("No Crypto:") print(" %s" % e)
def start_proxy(self, client_proto, c, auth_caps): def disconnect(reason, *extras): log("disconnect(%s, %s)", reason, extras) self.send_disconnect(client_proto, reason, *extras) #find the target server session: if not client_proto.authenticator: log.error("Error: the proxy server requires an authentication mode,") try: log.error(" client connection '%s' does not specify one", client_proto._conn.socktype) except: pass log.error(" use 'none' to disable authentication") disconnect(SESSION_NOT_FOUND, "no sessions found") return try: sessions = client_proto.authenticator.get_sessions() except Exception as e: authlog("failed to get the list of sessions", exc_info=True) authlog.error("Error: failed to get the list of sessions using '%s' authenticator", client_proto.authenticator) authlog.error(" %s", e) disconnect(AUTHENTICATION_ERROR, "cannot access sessions") return authlog("start_proxy(%s, {..}, %s) found sessions: %s", client_proto, auth_caps, sessions) if sessions is None: disconnect(SESSION_NOT_FOUND, "no sessions found") return uid, gid, displays, env_options, session_options = sessions if os.name=="posix": if uid==0 or gid==0: log.error("Error: proxy instances should not run as root") log.error(" use a different uid and gid (ie: nobody)") disconnect(AUTHENTICATION_ERROR, "cannot run proxy instances as root") return username = get_username_for_uid(uid) groups = get_groups(username) if "xpra" not in groups: log.error("Error: user '%s' (uid=%i) is not in the xpra group", username, uid) log.error(" it belongs to: %s", csv(groups) or None) disconnect(PERMISSION_ERROR, "user missing 'xpra' group membership") return #ensure we don't loop back to the proxy: proxy_virtual_display = os.environ.get("DISPLAY") if proxy_virtual_display in displays: displays.remove(proxy_virtual_display) #remove proxy instance virtual displays: displays = [x for x in displays if not x.startswith(":proxy-")] #log("unused options: %s, %s", env_options, session_options) opts = make_defaults_struct() display = None proc = None sns = c.dictget("start-new-session") authlog("start_proxy: displays=%s, start-new-session=%s", displays, bool(sns)) if len(displays)==0 or sns: if self._start_sessions: #start a new session mode = sns.get("mode", "start") assert mode in ("start", "start-desktop", "shadow"), "invalid start-new-session mode '%s'" % mode sns = typedict(sns) display = sns.get("display") args = [] if display: args = [display] start = sns.strlistget("start") start_child = sns.strlistget("start-child") exit_with_children = sns.boolget("exit-with-children") exit_with_client = sns.boolget("exit-with-client") log("starting new server subprocess: mode=%s, socket-dir=%s, socket-dirs=%s, start=%s, start-child=%s, exit-with-children=%s, exit-with-client=%s, uid=%s, gid=%s", mode, opts.socket_dir, opts.socket_dirs, start, start_child, exit_with_children, exit_with_client, uid, gid) try: proc, socket_path = start_server_subprocess(sys.argv[0], args, mode, opts, opts.socket_dir, opts.socket_dirs, start, start_child, exit_with_children, exit_with_client, uid=uid, gid=gid) display = "socket:%s" % socket_path except Exception as e: log("start_server_subprocess failed", exc_info=True) log.error("Error: failed to start server subprocess:") log.error(" %s", e) disconnect(SERVER_ERROR, "failed to start a new session") return if proc: self.child_reaper.add_process(proc, "server-%s" % display, "xpra start", True, True) else: disconnect(SESSION_NOT_FOUND, "no displays found") return if display is None: display = c.strget("display") authlog("start_proxy: proxy-virtual-display=%s (ignored), user specified display=%s, found displays=%s", proxy_virtual_display, display, displays) if display==proxy_virtual_display: disconnect(SESSION_NOT_FOUND, "invalid display") return if display: if display not in displays: disconnect(SESSION_NOT_FOUND, "display '%s' not found" % display) return else: if len(displays)!=1: disconnect(SESSION_NOT_FOUND, "please specify a display, more than one is available: %s" % csv(displays)) return display = displays[0] def stop_server_subprocess(): if proc: proc.terminate() log("start_proxy(%s, {..}, %s) using server display at: %s", client_proto, auth_caps, display) def parse_error(*args): stop_server_subprocess() disconnect(SESSION_NOT_FOUND, "invalid display string") log.warn("Error: parsing failed for display string '%s':", display) for arg in args: log.warn(" %s", arg) raise Exception("parse error on %s: %s" % (display, args)) opts.username = client_proto.authenticator.username disp_desc = parse_display_name(parse_error, opts, display) if uid or gid: disp_desc["uid"] = uid disp_desc["gid"] = gid log("display description(%s) = %s", display, disp_desc) try: server_conn = connect_to(disp_desc, opts) except Exception as e: log("cannot connect", exc_info=True) log.error("Error: cannot start proxy connection:") log.error(" %s", e) log.error(" connection definition:") print_nested_dict(disp_desc, prefix=" ", lchar="*", pad=20, print_fn=log.error) disconnect(SESSION_NOT_FOUND, "failed to connect to display") stop_server_subprocess() return log("server connection=%s", server_conn) #no other packets should be arriving until the proxy instance responds to the initial hello packet def unexpected_packet(packet): if packet: log.warn("Warning: received an unexpected packet on the proxy connection %s:", client_proto) log.warn(" %s", repr_ellipsized(packet)) client_conn = client_proto.steal_connection(unexpected_packet) client_state = client_proto.save_state() cipher = None encryption_key = None if auth_caps: cipher = auth_caps.get("cipher") if cipher: encryption_key = self.get_encryption_key(client_proto.authenticator, client_proto.keyfile) log("start_proxy(..) client connection=%s", client_conn) log("start_proxy(..) client state=%s", client_state) #this may block, so run it in a thread: def do_start_proxy(): log("do_start_proxy()") message_queue = MQueue() try: ioe = client_proto.wait_for_io_threads_exit(5+self._socket_timeout) if not ioe: log.error("Error: some network IO threads have failed to terminate") return client_conn.set_active(True) process = ProxyInstanceProcess(uid, gid, env_options, session_options, self._socket_dir, self.video_encoders, self.csc_modules, client_conn, client_state, cipher, encryption_key, server_conn, c, message_queue) log("starting %s from pid=%s", process, os.getpid()) self.processes[process] = (display, message_queue) process.start() log("process started") popen = process._popen assert popen #when this process dies, run reap to update our list of proxy processes: self.child_reaper.add_process(popen, "xpra-proxy-%s" % display, "xpra-proxy-instance", True, True, self.reap) finally: #now we can close our handle on the connection: client_conn.close() server_conn.close() message_queue.put("socket-handover-complete") start_thread(do_start_proxy, "start_proxy(%s)" % client_conn)
def main(): from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("Compression", "Compression Info"): print_nested_dict(get_compression_caps())
def main(): from xpra.util import print_nested_dict from xpra.platform import program_context with program_context("Packet Encoding", "Packet Encoding Info"): print_nested_dict(get_packet_encoding_caps())
def parse_shortcuts(self, strs): #TODO: maybe parse with re instead? if len(strs)==0: """ if none are defined, add this as default it would be nicer to specify it via OptionParser in main but then it would always have to be there with no way of removing it whereas now it is enough to define one (any shortcut) """ strs = ["meta+shift+F4:quit"] log("parse_shortcuts(%s)" % str(strs)) shortcuts = {} #modifier names contains the internal modifiers list, ie: "mod1", "control", ... #but the user expects the name of the key to be used, ie: "alt" or "super" #whereas at best, we keep "Alt_L" : "mod1" mappings... (xposix) #so generate a map from one to the other: modifier_names = {} meanings = self.xkbmap_mod_meanings or DEFAULT_MODIFIER_MEANINGS DEFAULT_MODIFIER_IGNORE_KEYNAMES = ["Caps_Lock", "Num_Lock", "Scroll_Lock"] for pub_name,mod_name in meanings.items(): if mod_name in DEFAULT_MODIFIER_NUISANCE or pub_name in DEFAULT_MODIFIER_IGNORE_KEYNAMES: continue #just hope that xxx_L is mapped to the same modifier as xxx_R! if pub_name.endswith("_L") or pub_name.endswith("_R"): pub_name = pub_name[:-2] elif pub_name=="ISO_Level3_Shift": pub_name = "AltGr" if pub_name not in modifier_names: modifier_names[pub_name.lower()] = mod_name if pub_name.lower()=="control": #alias "control" to "ctrl" as it is often used: modifier_names["ctrl"] = mod_name for s in strs: #example for s: Control+F8:some_action() parts = s.split(":", 1) if len(parts)!=2: log.error("Error: invalid key shortcut '%s'", s) continue #example for action: "quit" action = parts[1] args = () if action.find("(")>0 and action.endswith(")"): try: action, all_args = action[:-1].split("(", 1) args = [] for x in all_args.split(","): x = x.strip() if len(x)==0: continue if (x[0]=='"' and x[-1]=='"') or (x[0]=="'" and x[-1]=="'"): args.append(x[1:-1]) elif x=="None": args.append(None) elif x.find("."): args.append(float(x)) else: args.append(int(x)) args = tuple(args) except Exception as e: log.warn("failed to parse arguments of shortcut '%s': %s", s, e) continue log("action(%s)=%s%s", s, action, args) #example for keyspec: ["Alt", "F8"] keyspec = parts[0].split("+") modifiers = [] if len(keyspec)>1: valid = True #ie: ["Alt"] for mod in keyspec[:len(keyspec)-1]: #ie: "alt_l" -> "mod1" imod = modifier_names.get(mod.lower()) if not imod: log.error("Error: invalid modifier '%s' in keyboard shortcut '%s'", mod, s) log.error(" the modifiers must be one of: %s", csv(modifier_names.keys())) valid = False break modifiers.append(imod) if not valid: continue #TODO: validate keyname keyname = keyspec[len(keyspec)-1] shortcuts.setdefault(keyname, []).append((modifiers, action, args)) log("shortcut(%s)=%s", keyname, (modifiers, action, args)) log("parse_shortcuts(%s)=%s" % (str(strs), shortcuts)) print_nested_dict(shortcuts, print_fn=log) return shortcuts