def __exit__(self, *_args): if self.xvfb_process: self.xvfb_process.terminate() self.xvfb_process = None self.stu.tearDown() ProcessTestUtil.tearDownClass() OSEnvContext.__exit__(self)
def __enter__(self): OSEnvContext.__enter__(self) if POSIX and not OSX: ProcessTestUtil.setUpClass() self.stu = ProcessTestUtil() self.stu.setUp() self.xvfb_process = self.stu.start_Xvfb() os.environ["GDK_BACKEND"] = "x11" os.environ["DISPLAY"] = self.xvfb_process.display from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source init_gdk_display_source()
def test_env_handler(self): from xpra.client.auth.env_handler import Handler with OSEnvContext(): os.environ["XPRA_PASSWORD"] = "******" self._test_handler(True, "password1", Handler) with OSEnvContext(): os.environ["XPRA_PASSWORD2"] = "password2" self._test_handler(True, "password2", Handler, name="XPRA_PASSWORD2") with OSEnvContext(): name = "XPRA_TEST_VARIABLE_DOES_NOT_EXIST" os.environ.pop(name, None) self._test_handler(False, None, Handler, name=name)
def test_env_context(self): import os env = os.environ.copy() with OSEnvContext(): os.environ["foo"] = "bar" assert os.environ.get("foo") != "bar" assert os.environ == env
def test_notification(self): with OSEnvContext(): #remove any existing dbus environment so we don't pollute it: for k in tuple(os.environ.keys()): if k.startswith("DBUS"): del os.environ[k] #start a dbus server: from xpra.server.dbus.dbus_start import start_dbus dbus_pid, dbus_env = start_dbus( "dbus-launch --sh-syntax --close-stderr") try: if dbus_env: os.environ.update(dbus_env) from xpra.server.mixins.notification_forwarder import NotificationForwarder, log opts = AdHocStruct() opts.notifications = "yes" with silence_info(log): self._test_mixin_class(NotificationForwarder, opts) self.verify_packet_error( ("notification-close", 1, "test", "hello")) self.verify_packet_error(("notification-action", 1)) self.handle_packet(("set-notify", False)) self.mixin.cleanup() time.sleep(0.1) finally: if dbus_pid: import signal os.kill(dbus_pid, signal.SIGINT)
def init(self, opts): self.webcam_option = opts.webcam self.webcam_forwarding = self.webcam_option.lower( ) not in FALSE_OPTIONS self.server_webcam = False self.server_virtual_video_devices = 0 if self.webcam_forwarding: with OSEnvContext(): os.environ["LANG"] = "C" os.environ["LC_ALL"] = "C" try: import cv2 from PIL import Image assert cv2 and Image except ImportError as e: log("init webcam failure", exc_info=True) if WIN32 and BITS == 32: log.info( "32-bit builds do not support webcam forwarding") else: log.warn("Warning: failed to import opencv:") log.warn(" %s", e) log.warn(" webcam forwarding is disabled") self.webcam_forwarding = False log("webcam forwarding: %s", self.webcam_forwarding)
def test_env_log(self): with OSEnvContext(): os.environ["XPRA_LOG_PACKETS"] = "info,ping,-bell" for log_packet_type in (False, True): os.environ["XPRA_LOG_PACKET_TYPE"] = str(int(log_packet_type)) common.init() inc = int(log_packet_type) logged = 1+inc for sending in (True, False): self.setup_log_intercept() def t(packet_type, *args): return self.t(sending, packet_type, *args) #pylint: disable=cell-var-from-loop self.lm() t("hello", {}) self.lm(inc) t("info", {"foo" : "bar"}) self.lm(logged) t("ping", 1, 2, 3) self.lm(logged) t("ping-echo", 1, 2, 3) self.lm(inc) t("bell", 100) self.lm(inc) t("info", "0"*common.PACKET_LOG_MAX_SIZE*2) assert len(self.log_messages[-1])<=common.PACKET_LOG_MAX_SIZE self.lm(logged)
def test_start_dbus(self): from xpra.server.dbus.dbus_start import start_dbus def f(v): r, d = start_dbus(v) assert r == 0 and not d, "dbus should not have started for '%s'" % v def w(v): r, d = start_dbus(v) assert r > 0 and d, "dbus should have started for '%s'" % v def rm(): os.environ.pop("DBUS_SESSION_BUS_ADDRESS", None) with OSEnvContext(): rm() f("no") f("0") os.environ["DBUS_SESSION_BUS_ADDRESS"] = "whatever" w("dbus-launch") rm() f("this-is-not-a-valid-command") f("shlex-parsing-error '") f("echo set DBUS_SESSION_BUS_PID") w("echo set DBUS_SESSION_BUS_PID=50") w("echo \"set DBUS_SESSION_BUS_PID='100';\"") w("echo set DBUS_SESSION_BUS_PID=150;") w("echo setenv DBUS_SESSION_BUS_PID 200") w("printf \"export DBUS_SESSION_BUS_PID\nset DBUS_SESSION_BUS_PID=250\n\"" )
def start_Xvfb(cls, display=None, screens=[(1024, 768)]): assert os.name == "posix" if display is None: display = cls.find_free_display() with OSEnvContext(): os.environ["DISPLAY"] = display XAUTHORITY = os.environ.get("XAUTHORITY", os.path.expanduser("~/.Xauthority")) if len(screens) > 1: cmd = [ "Xvfb", "+extension", "Composite", "-nolisten", "tcp", "-noreset", "-auth", XAUTHORITY ] for i, screen in enumerate(screens): (w, h) = screen cmd += ["-screen", "%i" % i, "%ix%ix24+32" % (w, h)] else: xvfb_cmd = cls.default_config.get("xvfb") assert xvfb_cmd, "no 'xvfb' command in default config" import shlex cmd = shlex.split(osexpand(xvfb_cmd)) if "/etc/xpra/xorg.conf" in cmd: cmd[cmd.index( "/etc/xpra/xorg.conf")] = "./etc/xpra/xorg.conf" cmd.append(display) xvfb = cls.run_command(cmd) assert pollwait( xvfb, XVFB_TIMEOUT ) is None, "xvfb command %s failed and returned %s" % (cmd, xvfb.poll()) return xvfb
def test_xsettings(self): from xpra.x11.xsettings_prop import ( get_settings, set_settings, get_local_byteorder, XSettingsTypeInteger, XSettingsTypeString, XSettingsTypeColor, ) disp = AdHocStruct() for DEBUG_XSETTINGS in (True, False): with OSEnvContext(): os.environ["XPRA_XSETTINGS_DEBUG"] = str(int(DEBUG_XSETTINGS)) serial = 1 data = b"" l = len(data) v = struct.pack(b"=BBBBII", get_local_byteorder(), 0, 0, 0, serial, l)+data+b"\0" v1 = get_settings(disp, v) assert v #get from cache: v2 = get_settings(disp, v) assert v1==v2 #test all types, set then get: #setting_type, prop_name, value, last_change_serial = setting settings = ( (XSettingsTypeInteger, "int1", 1, 0), (XSettingsTypeString, "str1", "1", 0), (XSettingsTypeColor, "color1", (128, 128, 64, 32), 0), ) serial = 2 data = set_settings(disp, (serial, settings)) assert data #parse it back: v = get_settings(disp, data) rserial, rsettings = v assert rserial==serial assert len(rsettings)==len(settings) #test error handling: for settings in ( ( #invalid color causes exception (XSettingsTypeColor, "bad-color", (128, ), 0), ), ( #invalid setting type is skipped with an error message: (255, "invalid-setting-type", 0, 0), ), ): serial = 3 data = set_settings(disp, (serial, settings)) assert data v = get_settings(disp, data) rserial, rsettings = v assert rserial==serial assert len(rsettings)==0 #parsing an invalid data type (9) should fail: hexdata = b"000000000200000001000000090004007374723100000000010000003100000000" data = binascii.unhexlify(hexdata) v = get_settings(disp, data) rserial, rsettings = v assert len(rsettings)==0
def test_default_nolog(self): with OSEnvContext(): os.environ.pop("XPRA_LOG_PACKETS", None) self.setup_log_intercept() for pt in common.PACKET_TYPES: self.t(True, pt, (1, 2)) self.t(False, pt, (1, 2)) self.lm(0)
def do_load_xdg_menu_data(): try: from xdg.Menu import parse, Menu, ParsingError except ImportError: log("do_load_xdg_menu_data()", exc_info=True) if first_time("no-python-xdg"): log.warn("Warning: cannot use application menu data:") log.warn(" no python-xdg module") return None menu = None error = None with OSEnvContext(): #see ticket #2340, #invalid values for XDG_CONFIG_DIRS can cause problems, #so try unsetting it if we can't load the menus with it: for cd in (False, True): if cd: try: del os.environ["XDG_CONFIG_DIRS"] except KeyError: continue #see ticket #2174, #things may break if the prefix is not set, #and it isn't set when logging in via ssh for prefix in (None, "", "gnome-", "kde-"): if prefix is not None: os.environ["XDG_MENU_PREFIX"] = prefix try: menu = parse() break except Exception as e: log("do_load_xdg_menu_data()", exc_info=True) error = e menu = None if menu is None: if error: log.error("Error parsing xdg menu data:") log.error(" %s", error) log.error(" this is either a bug in python-xdg,") log.error(" or an invalid system menu configuration") return None menu_data = {} for submenu in menu.getEntries(): if isinstance(submenu, Menu) and submenu.Visible: name = submenu.getName() try: menu_data[name] = load_xdg_menu(submenu) except Exception as e: log("load_xdg_menu_data()", exc_info=True) log.error("Error loading submenu '%s':", name) log.error(" %s", e) return menu_data
def start_Xvfb(cls, display=None, screens=[(1024, 768)]): assert POSIX if display is None: display = cls.find_free_display() with OSEnvContext(): XAUTHORITY = os.environ.get("XAUTHORITY", os.path.expanduser("~/.Xauthority")) for x in list(os.environ.keys()): if x in ("LOGNAME", "USER", "PATH", "LANG", "TERM", "HOME", "USERNAME", "PYTHONPATH", "HOSTNAME"): #DBUS_SESSION_BUS_ADDRESS #keep it continue try: del os.environ[x] except: pass if len(screens) > 1: cmd = [ "Xvfb", "+extension", "Composite", "-nolisten", "tcp", "-noreset", "-auth", XAUTHORITY ] for i, screen in enumerate(screens): (w, h) = screen cmd += ["-screen", "%i" % i, "%ix%ix24+32" % (w, h)] else: xvfb_cmd = cls.default_config.get("xvfb") assert xvfb_cmd, "no 'xvfb' command in default config" import shlex cmd = shlex.split(osexpand(xvfb_cmd)) try: i = cmd.index("/etc/xpra/xorg.conf") except ValueError: i = -1 if i > 0 and os.path.exists("./etc/xpra/xorg.conf"): cmd[i] = "./etc/xpra/xorg.conf" cmd.append(display) os.environ["DISPLAY"] = display os.environ["XPRA_LOG_DIR"] = "/tmp" cmd_expanded = [osexpand(v) for v in cmd] cmdstr = " ".join("'%s'" % x for x in cmd_expanded) xvfb = cls.run_command(cmd_expanded, stdout=sys.stdout, stderr=sys.stderr) time.sleep(1) print("xvfb(%s)=%s" % (cmdstr, xvfb)) assert pollwait( xvfb, XVFB_TIMEOUT ) is None, "xvfb command \"%s\" failed and returned %s" % ( cmdstr, xvfb.poll()) return xvfb
def test_systemd_run(self): for s in ("yes", "no", "auto"): if not use_systemd_run(s): continue for user in (True, False): for systemd_run_args in ("", "-d"): assert systemd_run_command("mode", systemd_run_args, user=user)[0] == "systemd-run" with OSEnvContext(): os.environ["XPRA_LOG_SYSTEMD_WRAP"] = "0" assert systemd_run_wrap("unused", ["xpra", "--version"], stdout=DEVNULL, stderr=DEVNULL) == 0
def test_ival(self): with OSEnvContext(): with silence_warn(log): for k in ("XYZ", "WHATEVER"): os.environ.pop("XPRA_BATCH_%s" % k, None) assert ival(k, 20, 0, 100) == 20 os.environ["XPRA_BATCH_%s" % k] = "notanumber" assert ival(k, 30, 0, 100) == 30 os.environ["XPRA_BATCH_%s" % k] = "50" assert ival(k, 0, 0, 100) == 50 os.environ["XPRA_BATCH_%s" % k] = "120" assert ival(k, 0, 0, 100) == 100 os.environ["XPRA_BATCH_%s" % k] = "10" assert ival(k, 0, 20, 100) == 20
def test_display(self): from xpra.x11.gtk3.gdk_display_util import verify_gdk_display with OSEnvContext(): os.environ["GDK_BACKEND"] = "x11" os.environ.pop("DISPLAY", None) for d in (None, ""): try: verify_gdk_display(d) except Exception: pass else: raise Exception("%s is not a valid display" % d) display = self.find_free_display() xvfb = self.start_Xvfb(display) os.environ["DISPLAY"] = display from xpra.x11.bindings.posix_display_source import X11DisplayContext #@UnresolvedImport with X11DisplayContext(display): verify_gdk_display(display) xvfb.terminate()
def init(self, opts): self.webcam_option = opts.webcam self.webcam_forwarding = self.webcam_option.lower() not in FALSE_OPTIONS self.server_webcam = False self.server_virtual_video_devices = 0 if self.webcam_forwarding: with OSEnvContext(): os.environ["LANG"] = "C" os.environ["LC_ALL"] = "C" try: import cv2 from PIL import Image assert cv2 and Image except ImportError as e: log("init webcam failure", exc_info=True) if WIN32: log.info("opencv not found:") log.info(" %s", e) log.info(" webcam forwarding is not available") self.webcam_forwarding = False log("webcam forwarding: %s", self.webcam_forwarding)
def load_xdg_menu_data(): try: from xdg.Menu import parse, Menu #pylint: disable=import-outside-toplevel except ImportError: log("load_xdg_menu_data()", exc_info=True) if first_time("no-python-xdg"): log.warn("Warning: cannot use application menu data:") log.warn(" no python-xdg module") return None menu = None error = None #see ticket #2340, #invalid values for XDG_CONFIG_DIRS can cause problems, #so try unsetting it if we can't load the menus with it: for cd in (False, True): with OSEnvContext(): if cd: if not os.environ.pop("XDG_CONFIG_DIRS", ""): #was already unset continue #see ticket #2174, #things may break if the prefix is not set, #and it isn't set when logging in via ssh for prefix in (None, "", "gnome-", "kde-"): if prefix is not None: os.environ["XDG_MENU_PREFIX"] = prefix try: log( "parsing xdg menu data for prefix %r with XDG_CONFIG_DIRS=%s and XDG_MENU_PREFIX=%s", prefix, os.environ.get("XDG_CONFIG_DIRS"), os.environ.get("XDG_MENU_PREFIX")) menu = parse() break except Exception as e: log("load_xdg_menu_data()", exc_info=True) error = e menu = None if menu: break if menu is None: if error: log.error("Error parsing xdg menu data:") log.error(" %s", error) log.error(" this is either a bug in python-xdg,") log.error(" or an invalid system menu configuration") return None menu_data = {} entries = tuple(menu.getEntries()) log("%s.getEntries()=%s", menu, entries) if len(entries) == 1 and entries[0].Submenus: entries = entries[0].Submenus log("using submenus %s", entries) for i, submenu in enumerate(entries): if not isinstance(submenu, Menu): log("entry '%s' is not a submenu", submenu) continue name = submenu.getName() log("* %-3i %s", i, name) if not submenu.Visible: log(" submenu '%s' is not visible", name) continue try: md = load_xdg_menu(submenu) if md: menu_data[name] = md else: log(" no menu data for %s", name) except Exception as e: log("load_xdg_menu_data()", exc_info=True) log.error("Error loading submenu '%s':", name) log.error(" %s", e) if LOAD_APPLICATIONS: from xdg.Menu import MenuEntry entries = {} for d in LOAD_APPLICATIONS: for f in os.listdir(d): if not f.endswith(".desktop"): continue try: me = MenuEntry(f, d) except Exception: log("failed to load %s from %s", f, d, exc_info=True) else: ed = load_xdg_entry(me.DesktopEntry) if not ed: continue name = ed.get("Name") #ensure we don't already have it in another submenu: for menu_category in menu_data.values(): if name in menu_category.get("Entries", {}): ed = None break if ed: entries[name] = ed log("entries(%s)=%s", LOAD_APPLICATIONS, remove_icons(entries)) if entries: #add an 'Applications' menu if we don't have one: md = menu_data.get("Applications") if not md: md = { "Name": "Applications", } menu_data["Applications"] = md md.setdefault("Entries", {}).update(entries) return menu_data
def test_networkstate(self): with OSEnvContext(): os.environ["XPRA_PING_TIMEOUT"] = "1" from xpra.server.mixins.networkstate_server import NetworkStateServer, MAX_BANDWIDTH_LIMIT, log, bandwidthlog from xpra.server.source.networkstate_mixin import NetworkStateMixin assert NetworkStateMixin.is_needed(typedict()) opts = AdHocStruct() opts.pings = 1 opts.bandwidth_limit = "1Gbps" #the limit for all clients: capped_at = 1 * 1000 * 1000 * 1000 #=="1Gbps" with silence_info(log): self._test_mixin_class(NetworkStateServer, opts, {}, NetworkStateMixin) self.assertEqual(capped_at, self.mixin.get_info().get("bandwidth-limit")) self.handle_packet(("ping", 10)) self.handle_packet(("ping", -1000)) self.handle_packet(("ping_echo", 10, 500, 500, 600, 10)) for v in (None, "foo", 1, 2.0, [], (), set()): try: self.handle_packet(("connection-data", v)) except TypeError: pass else: raise Exception( "should not allow %s (%s) as connection-data" % (v, type(v))) self.handle_packet(("connection-data", {})) for v in (None, "foo", 2.0, [], (), set()): try: self.handle_packet(("bandwidth-limit", v)) except TypeError: pass else: raise Exception( "should not allow %s (%s) as connection-data" % (v, type(v))) with silence_info(bandwidthlog): self.handle_packet(("bandwidth-limit", 10 * 1024 * 1024)) def get_limit(): return self.source.get_info().get("bandwidth-limit", {}).get("setting", 0) self.assertEqual(10 * 1024 * 1024, get_limit()) with silence_info(bandwidthlog): self.handle_packet( ("bandwidth-limit", MAX_BANDWIDTH_LIMIT + 1)) self.assertEqual(min(capped_at, MAX_BANDWIDTH_LIMIT), get_limit()) #test source: timeouts = [] def timeout(*args): timeouts.append(args) self.source.disconnect = timeout assert self.source.get_caps() self.source.ping() self.source.check_ping_echo_timeout(0, 0) #give time for the timeout to fire: self.glib.timeout_add(2000, self.main_loop.quit) self.main_loop.run()
def test_save_dbus_env(self): from xpra.server.dbus import dbus_start dbus_start.log = FakeLogger() with OSEnvContext(): #assert get_saved_dbus_env() pass
def test_misc_env_switches(self): with OSEnvContext(): os.environ["XPRA_NOMD5"] = "1" self._test_subcommand("version-info")
def test_nox(self): with OSEnvContext(): os.environ["DISPLAY"] = "not-a-display" nox() assert os.environ.get("DISPLAY") is None
def __init__(self): OSEnvContext.__init__(self) self.xvfb_process = None
def test_childreaper(self): for polling in (True, False): with OSEnvContext(): os.environ["XPRA_USE_PROCESS_POLLING"] = str(int(polling)) self.do_test_child_reaper()