def run(self, *args): if len(args) == 1 and args[0] == "status": from xpra.log import get_all_loggers return "logging is enabled for: %s" % str( list([ str(x) for x in get_all_loggers() if x.is_debug_enabled() ])) if len(args) < 2: self.raise_error("not enough arguments") log_cmd = args[0] if log_cmd not in ("enable", "disable"): self.raise_error("only 'enable' and 'disable' verbs are supported") #support both separate arguments and csv: categories = [] for x in args[1:]: categories += [v.strip() for v in x.split(",")] from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for if log_cmd == "enable": add_debug_category(*categories) loggers = enable_debug_for(*categories) else: assert log_cmd == "disable" add_disabled_category(*categories) loggers = disable_debug_for(*categories) if not loggers: log.info("no loggers matching: %s", csv(categories)) else: log.info("%sd debugging for: %s", log_cmd, csv(loggers)) return "logging %sd for %s" % (log_cmd, csv(loggers))
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except: pass try: sys.argv.remove("--verbose") except: pass from xpra.platform import init, clean from xpra.log import enable_color try: init("PyCUPS Printing") enable_color() validate_setup() log.info("") log.info("printer definitions:") for k, v in get_printer_definitions().items(): log.info("* %-32s: %s", k, v) log.info("") log.info("local printers:") printers = get_printers() for k, d in get_all_printers().items(): log.info("* %s%s", k, [" (NOT EXPORTED)", ""][int(k in printers)]) for pk, pv in d.items(): if pk == "printer-state" and pv in PRINTER_STATE: pv = "%s (%s)" % (pv, PRINTER_STATE.get(pv)) log.info(" %-32s: %s", pk, pv) finally: clean()
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except: pass try: sys.argv.remove("--verbose") except: pass from xpra.util import nonl, pver def print_dict(d): for k in sorted(d.keys()): v = d[k] print("* %s : %s" % (k.ljust(32), nonl(pver(v)))) from xpra.platform import init, clean try: init("Printing", "Printing") if len(sys.argv) < 3: print_dict(get_printers()) else: printer = sys.argv[1] print_files(printer, sys.argv[2:], "Print Command", {}) finally: clean()
def run(self, *args): if len(args)==1 and args[0]=="status": from xpra.log import get_all_loggers return "logging is enabled for: %s" % str(list([str(x) for x in get_all_loggers() if x.is_debug_enabled()])) if len(args)<2: self.raise_error("not enough arguments") log_cmd = args[0] if log_cmd not in ("enable", "disable"): self.raise_error("only 'enable' and 'disable' verbs are supported") #support both separate arguments and csv: categories = [] for x in args[1:]: categories += [v.strip() for v in x.split(",")] from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for if log_cmd=="enable": add_debug_category(*categories) loggers = enable_debug_for(*categories) else: assert log_cmd=="disable" add_disabled_category(*categories) loggers = disable_debug_for(*categories) if not loggers: log.info("no loggers matching: %s", csv(categories)) else: log.info("%sd debugging for: %s", log_cmd, csv(loggers)) return "logging %sd for %s" % (log_cmd, csv(loggers))
def main(): for arg in list(sys.argv): if arg in ("-v", "--verbose"): from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") sys.argv.remove(arg) from xpra.platform import program_context from xpra.log import enable_color with program_context("PyCUPS Printing"): enable_color() validate_setup() log.info("") log.info("printer definitions:") for k,v in get_printer_definitions().items(): log.info("* %-32s: %s", k, v) log.info("") log.info("local printers:") try: printers = get_printers() except RuntimeError as e: log.error("Error accessing the printing system") log.error(" %s", e) else: for k,d in get_all_printers().items(): log.info("* %s%s", k, [" (NOT EXPORTED)", ""][int(k in printers)]) for pk, pv in d.items(): if pk=="printer-state" and pv in PRINTER_STATE: pv = "%s (%s)" % (pv, PRINTER_STATE.get(pv)) log.info(" %-32s: %s", pk, pv)
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(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except: pass try: sys.argv.remove("--verbose") except: pass from xpra.platform import program_context from xpra.log import enable_color with program_context("PyCUPS Printing"): enable_color() validate_setup() log.info("") log.info("printer definitions:") for k, v in get_printer_definitions().items(): log.info("* %-32s: %s", k, v) log.info("") log.info("local printers:") printers = get_printers() for k, d in get_all_printers().items(): log.info("* %s%s", k, [" (NOT EXPORTED)", ""][int(k in printers)]) for pk, pv in d.items(): if pk == "printer-state" and pv in PRINTER_STATE: pv = "%s (%s)" % (pv, PRINTER_STATE.get(pv)) log.info(" %-32s: %s", pk, pv)
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(): 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(): import sys if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category add_debug_category("webcam") from xpra.platform import program_context with program_context("Webcam Info", "Webcam Info"): devices = get_virtual_video_devices() log.info("Found %i virtual video device%s:", len(devices), engs(devices)) for no, d in devices.items(): log.info("%-2i: %s", no, d)
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, command_error from xpra.platform.gui import init, set_default_icon with program_context("Webcam", "Webcam"): from xpra.log import Logger, add_debug_category log = Logger("webcam") for x in list(sys.argv): if x in ("-v", "--verbose"): sys.argv.remove(x) add_debug_category("webcam") log.enable_debug() set_default_icon("webcam.png") init() log("importing opencv") try: import cv2 except ImportError as e: command_error("Error: no opencv support module: %s" % e) return 1 log("cv2=%s", cv2) device = 0 if len(sys.argv) == 2: try: device = int(sys.argv[1]) except ValueError: command_error( "Warning: failed to parse value as a device number: '%s'" % sys.argv[1]) log("opening %s with device=%s", cv2.VideoCapture, device) # @UndefinedVariable try: cap = cv2.VideoCapture(device) # @UndefinedVariable except Exception as e: command_error( "Error: failed to capture video using device %s:\n%s" % (device, e)) return 1 log.info("capture device for %i: %s", device, cap) while True: ret, frame = cap.read() if not ret: command_error("Error: frame capture failed using device %s" % device) return 1 cv2.imshow('frame', frame) # @UndefinedVariable if cv2.waitKey(10) & 0xFF in (ord('q'), 27): # @UndefinedVariable break cap.release() cv2.destroyAllWindows() # @UndefinedVariable return 0
def run(self, *args): if len(args) == 1 and args[0] == "status": from xpra.log import get_all_loggers return "logging is enabled for: %s" % str( list([ str(x) for x in get_all_loggers() if x.is_debug_enabled() ])) log_cmd = args[0] if log_cmd == "mark": for _ in range(10): log.info("*" * 80) if len(args) > 1: log.info("mark: %s", " ".join(args[1:])) else: log.info("mark") for _ in range(10): log.info("*" * 80) return "mark inserted into logfile" if len(args) < 2: self.raise_error("not enough arguments") if log_cmd not in ("enable", "disable"): self.raise_error("only 'enable' and 'disable' verbs are supported") from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for #each argument is a group loggers = [] groups = args[1:] for group in groups: #and each group is a list of categories #preferably separated by "+", #but we support "," for backwards compatibility: categories = [ v.strip() for v in group.replace("+", ",").split(",") ] if log_cmd == "enable": add_debug_category(*categories) loggers += enable_debug_for(*categories) else: assert log_cmd == "disable" add_disabled_category(*categories) loggers += disable_debug_for(*categories) if not loggers: log.info("%s debugging, no new loggers matching: %s", log_cmd, csv(groups)) else: log.info("%sd debugging for:", log_cmd) for l in loggers: log.info(" - %s", l) return "logging %sd for %s" % (log_cmd, csv(loggers) or "<no match found")
def _process_control(self, packet): command = packet[1] if command == "show_session_info": args = packet[2:] log("calling show_session_info%s on server request", args) self.show_session_info(*args) elif command == "show_bug_report": self.show_bug_report() elif command in ("enable_%s" % x for x in compression.get_enabled_compressors()): compressor = command.split("_")[1] log.info("switching to %s on server request", compressor) self._protocol.enable_compressor(compressor) elif command in ("enable_%s" % x for x in packet_encoding.get_enabled_encoders()): pe = command.split("_")[1] log.info("switching to %s on server request", pe) self._protocol.enable_encoder(pe) elif command == "name": assert len(args) >= 3 self.server_session_name = args[2] log.info("session name updated from server: %s", self.server_session_name) #TODO: reset tray tooltip, session info title, etc.. elif command == "debug": args = packet[2:] if len(args) < 2: log.warn("not enough arguments for debug control command") return log_cmd = args[0] if log_cmd not in ("enable", "disable"): log.warn( "invalid debug control mode: '%s' (must be 'enable' or 'disable')", log_cmd) return categories = args[1:] from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for if log_cmd == "enable": add_debug_category(*categories) loggers = enable_debug_for(*categories) else: assert log_cmd == "disable" add_disabled_category(*categories) loggers = disable_debug_for(*categories) log.info("%sd debugging for: %s", log_cmd, loggers) return else: log.warn("received invalid control command from server: %s", command)
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(): 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 nonl, pver def print_dict(d): for k in sorted(d.keys()): v = d[k] print("* %s : %s" % (k.ljust(32), nonl(pver(v)))) from xpra.platform import init, clean try: init("Path-Info", "Path Info") print_dict(get_info()) finally: clean()
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.platform import program_context, command_error with program_context("Webcam", "Webcam"): from xpra.log import Logger, add_debug_category log = Logger("webcam") if "-v" in sys.argv or "--verbose" in sys.argv: add_debug_category("webcam") log.enable_debug() try: import cv2 except ImportError as e: command_error("Error: no opencv support module: %s" % e) return 1 device = 0 if len(sys.argv) == 2: try: device = int(sys.argv[1]) except: command_error( "Warning: failed to parse value as a device number: '%s'" % sys.argv[1]) try: cap = cv2.VideoCapture(device) except Exception as e: command_error( "Error: failed to capture video using device %s:\n%s" % (device, e)) return 1 log.info("capture device for %i: %s", device, cap) while True: ret, frame = cap.read() if not ret: command_error("Error: frame capture failed using device %s" % device) return 1 cv2.imshow('frame', frame) if cv2.waitKey(10) & 0xFF in (ord('q'), 27): break cap.release() cv2.destroyAllWindows() return 0
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) if len(sys.argv)>1: for x in sys.argv[1:]: if os.path.isabs(x): v = load_icon_from_file(x) print("load_icon_from_file(%s)=%s" % (x, v)) else: menu = load_xdg_menu_data() if menu: print_nested_dict(menu, vformat={"IconData" : icon_fmt}) else: print("no menu data found") return 0
def main(): import sys from xpra.net.net_util import 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:") for iface in get_interfaces(): if if_nametoindex: print("* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface))) else: print("* %s" % iface) print_iface(iface)
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 from xpra.platform import program_context, command_error with program_context("Webcam", "Webcam"): from xpra.log import Logger, add_debug_category log = Logger("webcam") if "-v" in sys.argv or "--verbose" in sys.argv: add_debug_category("webcam") log.enable_debug() try: import cv2 except ImportError as e: command_error("Error: no opencv support module: %s" % e) return 1 device = 0 if len(sys.argv)==2: try: device = int(sys.argv[1]) except: command_error("Warning: failed to parse value as a device number: '%s'" % sys.argv[1]) try: cap = cv2.VideoCapture(device) except Exception as e: command_error("Error: failed to capture video using device %s:\n%s" % (device, e)) return 1 log.info("capture device for %i: %s", device, cap) while True: ret, frame = cap.read() if not ret: command_error("Error: frame capture failed using device %s" % device) return 1 cv2.imshow('frame', frame) if cv2.waitKey(10) & 0xFF in (ord('q'), 27): break cap.release() cv2.destroyAllWindows() return 0
def test_ssh_parsing(self): assert parse_ssh_string("auto")[0] in ("paramiko", "ssh") assert parse_ssh_string("ssh") == ["ssh"] assert parse_ssh_string("ssh -v") == ["ssh", "-v"] with nomodule_context("paramiko"): add_debug_category("ssh") def pssh(s, e): r = parse_ssh_string(s)[0] assert r == e, "expected %s got %s" % (e, r) if WIN32: pssh("auto", "plink.exe") else: pssh("auto", "ssh") remove_debug_category("ssh") #args: def targs(e, *args, **kwargs): r = add_ssh_args(*args, **kwargs) assert r == e, "expected %s but got %s" % (e, r) targs([], None, None, None, None, None, is_paramiko=True) targs( ["-pw", "password", "-l", "username", "-P", "2222", "-T", "host"], "username", "password", "host", 2222, None, is_putty=True) if not WIN32: keyfile = os.path.expanduser("~/key") targs( ["-l", "username", "-p", "2222", "-T", "host", "-i", keyfile], "username", "password", "host", 2222, keyfile) #proxy: def pargs(e, n, *args, **kwargs): r = add_ssh_proxy_args(*args, **kwargs)[:n] assert r == e, "expected %s but got %s" % (e, r) pargs(["-o"], 1, "username", "password", "host", 222, None, ["ssh"]) pargs(["-proxycmd"], 1, "username", "password", "host", 222, None, ["putty.exe"], is_putty=True) #proxy attributes: assert parse_proxy_attributes("somedisplay") == ("somedisplay", {}) attr = parse_proxy_attributes("10?proxy=username:password@host:222")[1] assert attr == { "proxy_host": "host", "proxy_port": 222, "proxy_username": "******", "proxy_password": "******" } def f(s): v = parse_proxy_attributes(s) assert v[1] == {}, "parse_proxy_attributes(%s) should fail" % s f("somedisplay?proxy=") f("somedisplay?proxy=:22") f("somedisplay?proxy=:@host:22") f("somedisplay?proxy=:password@host:22")
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except: pass try: sys.argv.remove("--verbose") except: pass from xpra.util import nonl, pver def dump_printers(d): for k in sorted(d.keys()): v = d[k] print("* %s" % k) pk = None try: for pk,pv in v.items(): try: if type(pv)==unicode: sv = pv.encode("utf8") else: sv = nonl(pver(pv)) except Exception as e: sv = repr(pv) print(" %s : %s" % (pk.ljust(32), sv)) except Exception as e: print(" error on %s: %s" % (pk, e)) print(" raw attributes: " % v) attr = get_printer_attributes(k) if attr: print(" attributes:") for a in attr: print(" %s" % a) from xpra.platform import init, clean from xpra.log import enable_color from xpra.util import csv try: init("Printing", "Printing") enable_color() if len(sys.argv)<=1: dump_printers(get_printers()) return 0 printers = get_printers() if len(printers)==0: print("Cannot print: no printers found") return 1 if len(sys.argv)==2: filename = sys.argv[1] if not os.path.exists(filename): print("Cannot print file '%s': file does not exist" % filename) return 1 printer = get_default_printer() if not printer: printer = printers.keys()[0] if len(printers)>1: print("More than one printer found: %s", csv(printer.keys())) print("Using printer '%s'" % printer) filenames = [filename] if len(sys.argv)>2: printer = sys.argv[1] if printer not in printers: print("Invalid printer '%s'" % printer) return 1 filenames = sys.argv[2:] for filename in filenames: if not os.path.exists(filename): print("File '%s' does not exist" % filename) return 1 print("Printing: %s" % csv(filenames)) print_files(printer, filenames, "Print Command", {}) return 0 finally: clean()
def EnableDebug(self, category): c = ns(category) add_debug_category(c) enable_debug_for(c)
def _process_control(self, packet): command = bytestostr(packet[1]) if command == "show_session_info": args = packet[2:] log("calling %s%s on server request", self.show_session_info, args) self.show_session_info(*args) elif command == "show_bug_report": self.show_bug_report() elif command in ("enable_%s" % x for x in compression.get_enabled_compressors()): compressor = command.split("_")[1] log.info("switching to %s on server request", compressor) self._protocol.enable_compressor(compressor) elif command in ("enable_%s" % x for x in packet_encoding.get_enabled_encoders()): pe = command.split("_")[1] log.info("switching to %s on server request", pe) self._protocol.enable_encoder(pe) elif command == "name": assert len(args) >= 3 self.server_session_name = args[2] log.info("session name updated from server: %s", self.server_session_name) #TODO: reset tray tooltip, session info title, etc.. elif command == "debug": args = packet[2:] if not args: log.warn("not enough arguments for debug control command") return from xpra.log import ( add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for, get_all_loggers, ) log_cmd = bytestostr(args[0]) if log_cmd == "status": dloggers = [ x for x in get_all_loggers() if x.is_debug_enabled() ] if dloggers: log.info("logging is enabled for:") for l in dloggers: log.info(" - %s", l) else: log.info("logging is not enabled for any loggers") return log_cmd = bytestostr(args[0]) if log_cmd not in ("enable", "disable"): log.warn( "invalid debug control mode: '%s' (must be 'enable' or 'disable')", log_cmd) return if len(args) < 2: log.warn( "not enough arguments for '%s' debug control command" % log_cmd) return loggers = [] #each argument is a group groups = [bytestostr(x) for x in args[1:]] for group in groups: #and each group is a list of categories #preferably separated by "+", #but we support "," for backwards compatibility: categories = [ v.strip() for v in group.replace("+", ",").split(",") ] if log_cmd == "enable": add_debug_category(*categories) loggers += enable_debug_for(*categories) else: assert log_cmd == "disable" add_disabled_category(*categories) loggers += disable_debug_for(*categories) if not loggers: log.info("%s debugging, no new loggers matching: %s", log_cmd, csv(groups)) else: log.info("%sd debugging for:", log_cmd) for l in loggers: log.info(" - %s", l) else: log.warn("received invalid control command from server: %s", command)
def EnableDebug(self, category): self.log(".EnableDebug(%s)", category) c = ns(category) add_debug_category(c) enable_debug_for(c)
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except ValueError: pass try: sys.argv.remove("--verbose") except ValueError: pass from xpra.util import nonl, pver def dump_dict(d): pk = None try: for pk, pv in d.items(): try: if isinstance(pv, unicode): sv = pv.encode("utf8") else: sv = nonl(pver(pv)) except Exception as e: sv = repr(pv) print(" %s : %s" % (pk.ljust(32), sv)) except Exception as e: print(" error on %s: %s" % (pk, e)) print(" raw attributes: " % d) def dump_info(d): print("System Configuration:") print_nested_dict(d) def dump_printers(d): for k in sorted(d.keys()): v = d[k] print("Printers:") print("* %s" % k) dump_dict(v) attr = get_printer_attributes(k) if attr: print(" attributes:") for a in attr: print(" %s" % a) from xpra.platform import program_context from xpra.log import enable_color from xpra.util import csv with program_context("Printing", "Printing"): enable_color() try: init_printing() except Exception as e: print("Error: initializing the printing tool") print(" %s" % e) if len(sys.argv) <= 1: dump_printers(get_printers()) print("") dump_info(get_info()) return 0 printers = get_printers() if not printers: print("Cannot print: no printers found") return 1 if len(sys.argv) == 2: filename = sys.argv[1] if not os.path.exists(filename): print("Cannot print file '%s': file does not exist" % filename) return 1 printer = get_default_printer() if not printer: printer = printers.keys()[0] if len(printers) > 1: print("More than one printer found: %s", csv(printer.keys())) print("Using printer '%s'" % printer) filenames = [filename] if len(sys.argv) > 2: printer = sys.argv[1] if printer not in printers: print("Invalid printer '%s'" % printer) return 1 filenames = sys.argv[2:] for filename in filenames: if not os.path.exists(filename): print("File '%s' does not exist" % filename) return 1 print("Printing: %s" % csv(filenames)) print_files(printer, filenames, "Print Command", {}) return 0
def main(): if "-v" in sys.argv or "--verbose" in sys.argv: from xpra.log import add_debug_category, enable_debug_for add_debug_category("printing") enable_debug_for("printing") try: sys.argv.remove("-v") except: pass try: sys.argv.remove("--verbose") except: pass from xpra.util import nonl, pver def dump_dict(d): pk = None try: for pk,pv in d.items(): try: if type(pv)==unicode: sv = pv.encode("utf8") else: sv = nonl(pver(pv)) except Exception as e: sv = repr(pv) print(" %s : %s" % (pk.ljust(32), sv)) except Exception as e: print(" error on %s: %s" % (pk, e)) print(" raw attributes: " % d) def dump_info(d): print("System Configuration:") dump_dict(d) def dump_printers(d): for k in sorted(d.keys()): v = d[k] print("* %s" % k) dump_dict(v) attr = get_printer_attributes(k) if attr: print(" attributes:") for a in attr: print(" %s" % a) from xpra.platform import program_context from xpra.log import enable_color from xpra.util import csv with program_context("Printing", "Printing"): enable_color() init_printing() if len(sys.argv)<=1: dump_printers(get_printers()) dump_info(get_info()) return 0 printers = get_printers() if len(printers)==0: print("Cannot print: no printers found") return 1 if len(sys.argv)==2: filename = sys.argv[1] if not os.path.exists(filename): print("Cannot print file '%s': file does not exist" % filename) return 1 printer = get_default_printer() if not printer: printer = printers.keys()[0] if len(printers)>1: print("More than one printer found: %s", csv(printer.keys())) print("Using printer '%s'" % printer) filenames = [filename] if len(sys.argv)>2: printer = sys.argv[1] if printer not in printers: print("Invalid printer '%s'" % printer) return 1 filenames = sys.argv[2:] for filename in filenames: if not os.path.exists(filename): print("File '%s' does not exist" % filename) return 1 print("Printing: %s" % csv(filenames)) print_files(printer, filenames, "Print Command", {}) return 0
def main(): from xpra.util import print_nested_dict, csv from xpra.platform import program_context from xpra.platform.netdev_query import get_interface_speed from xpra.log import enable_color, add_debug_category, enable_debug_for with program_context("Network-Info", "Network 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:") for iface in get_interfaces(): if if_nametoindex: s = "* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface)) else: s = "* %s" % iface speed = get_interface_speed(0, iface) if speed > 0: from xpra.simple_stats import std_unit s += " (speed=%sbps)" % std_unit(speed) print(s) 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:") for gt, idefs in get_gateways().items(): print("* %s" % gt) #ie: "INET" for i, idef in enumerate(idefs): try: if isinstance(idef, (list, tuple)): print(" [%i] %s" % (i, csv(idef))) continue except: print(" [%i] %s" % (i, idef)) print("") print("Protocol Capabilities:") 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 main(): # pragma: no cover from xpra.os_util import POSIX from xpra.util import print_nested_dict, csv from xpra.platform import program_context from xpra.platform.netdev_query import get_interface_info from xpra.log import enable_color, add_debug_category, enable_debug_for with program_context("Network-Info", "Network 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 pylint: disable=no-member 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(" %s" % info) finally: sock.close() if not POSIX: info = get_interface_info(0, iface) if info: print(" %s" % info) from xpra.os_util import bytestostr def pver(v): if isinstance(v, (tuple, list)): s = "" lastx = None for x in v: if lastx is not None: #dot seperated numbers if isinstance(lastx, int): s += "." else: s += ", " s += bytestostr(x) lastx = x return s if isinstance(v, bytes): v = bytestostr(v) if isinstance(v, str) and v.startswith("v"): return v[1:] return str(v) print("Gateways found:") for gt, idefs in get_gateways().items(): print("* %s" % gt) #ie: "INET" for i, idef in enumerate(idefs): if isinstance(idef, (list, tuple)): print(" [%i] %s" % (i, csv(idef))) continue print("") print("Protocol Capabilities:") netcaps = get_network_caps() netif = {"": bool(netifaces)} if netifaces_version: netif["version"] = netifaces_version netcaps["netifaces"] = netif print_nested_dict(netcaps, vformat=pver) 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(True)) 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) return 0