示例#1
0
 def get_connect_info(self):
     cinfo = []
     pinfo = ""
     if self.client_platform:
         pinfo = " %s" % platform_name(
             self.client_platform, self.client_linux_distribution
             or self.client_release)
     if self.client_session_type:
         pinfo += " %s" % self.client_session_type
     revinfo = ""
     if self.client_revision:
         revinfo = "-r%s" % self.client_revision
     bitsstr = ""
     if self.client_bits:
         bitsstr = " %i-bit" % self.client_bits
     cinfo.append("%s%s client version %s%s%s" %
                  (std(self.client_type), pinfo, std(
                      self.client_version), std(revinfo), bitsstr))
     msg = ""
     if self.hostname:
         msg += "connected from '%s'" % std(self.hostname)
     if self.username:
         msg += " as '%s'" % std(self.username)
         if self.name and self.name != self.username:
             msg += " - '%s'" % std(self.name)
     if msg:
         cinfo.append(msg)
     if self.client_proxy:
         msg = "via %s proxy version %s" % (platform_name(
             self.proxy_platform,
             self.proxy_release), std(self.proxy_version or "unknown"))
         if self.proxy_hostname:
             msg += " on '%s'" % std(self.proxy_hostname)
         cinfo.append(msg)
     return cinfo
示例#2
0
    def parse_server_capabilities(self):
        for c in CLIENT_BASES:
            if not c.parse_server_capabilities(self):
                log.info("failed to parse server capabilities in %s", c)
                return  False
        c = self.server_capabilities
        self.server_session_name = strtobytes(c.rawget("session_name", b"")).decode("utf-8")
        set_name("Xpra", self.session_name or self.server_session_name or "Xpra")
        self.server_platform = c.strget("platform")
        self.server_sharing = c.boolget("sharing")
        self.server_sharing_toggle = c.boolget("sharing-toggle")
        self.server_lock = c.boolget("lock")
        self.server_lock_toggle = c.boolget("lock-toggle")
        self.server_keyboard = c.boolget("keyboard", True)
        self.server_toggle_keyboard_sync = self.server_keyboard and c.boolget("toggle_keyboard_sync", True)
        self.server_pointer = c.boolget("pointer", True)
        self.server_start_new_commands = c.boolget("start-new-commands")
        if self.server_start_new_commands:
            self.xdg_menu = c.dictget("xdg-menu")
        if self.start_new_commands or self.start_child_new_commands:
            if self.server_start_new_commands:
                self.after_handshake(self.send_start_new_commands)
            else:
                log.warn("Warning: cannot start new commands")
                log.warn(" the feature is currently disabled on the server")
        self.server_commands_info = c.boolget("server-commands-info")
        self.server_commands_signals = c.strlistget("server-commands-signals")
        self.server_readonly = c.boolget("readonly")
        if self.server_readonly and not self.readonly:
            log.info("server is read only")
            self.readonly = True
        if not self.server_keyboard and self.keyboard_helper:
            #swallow packets:
            def nosend(*args):
                pass
            self.keyboard_helper.send = nosend

        i = platform_name(self._remote_platform, c.strlistget("platform.linux_distribution") or c.strget("platform.release", ""))
        r = self._remote_version
        if self._remote_revision:
            r += "-r%s" % self._remote_revision
        mode = c.strget("server.mode", "server")
        bits = c.intget("python.bits", 32)
        log.info("Xpra %s server version %s %i-bit", mode, std(r), bits)
        if i:
            log.info(" running on %s", std(i))
        if c.boolget("proxy"):
            proxy_hostname = c.strget("proxy.hostname")
            proxy_platform = c.strget("proxy.platform")
            proxy_release = c.strget("proxy.platform.release")
            proxy_version = c.strget("proxy.version")
            proxy_version = c.strget("proxy.build.version", proxy_version)
            proxy_distro = c.strget("linux_distribution")
            msg = "via: %s proxy version %s" % (platform_name(proxy_platform, proxy_distro or proxy_release), std(proxy_version or "unknown"))
            if proxy_hostname:
                msg += " on '%s'" % std(proxy_hostname)
            log.info(msg)
        return True
示例#3
0
 def get_connect_info(self) -> list:
     cinfo = []
     #client platform / version info:
     pinfo = ""
     if self.client_platform:
         pinfo = " %s" % platform_name(
             self.client_platform, self.client_linux_distribution
             or self.client_release)
     if self.client_session_type:
         pinfo += " %s" % self.client_session_type
     revinfo = ""
     if self.client_revision:
         revinfo = "-r%s" % self.client_revision
     bitsstr = ""
     if self.client_bits:
         bitsstr = " %i-bit" % self.client_bits
     cinfo.append("%s%s client version %s%s%s" %
                  (std(self.client_type), pinfo, std(
                      self.client_version), std(revinfo), bitsstr))
     #opengl info:
     if self.client_opengl:
         msg = "OpenGL is "
         if not self.client_opengl.boolget("enabled"):
             msg += "disabled"
         else:
             msg += "enabled"
             driver_info = self.client_opengl.strget(
                 "renderer") or self.client_opengl.strget("vendor")
             if driver_info:
                 msg += " with %s" % driver_info
         cinfo.append(msg)
     #connection info:
     msg = ""
     if self.hostname:
         msg += "connected from '%s'" % std(self.hostname)
     if self.username:
         msg += " as '%s'" % std(self.username)
         if self.name and self.name != self.username:
             msg += " - '%s'" % std(self.name)
     if msg:
         cinfo.append(msg)
     #proxy info
     if self.client_proxy:
         msg = "via %s proxy version %s" % (platform_name(
             self.proxy_platform,
             self.proxy_release), std(self.proxy_version or "unknown"))
         if self.proxy_hostname:
             msg += " on '%s'" % std(self.proxy_hostname)
         cinfo.append(msg)
     return cinfo
示例#4
0
    def parse_server_capabilities(self):
        for c in UIXpraClient.__bases__:
            if not c.parse_server_capabilities(self):
                log.info("failed to parse server capabilities in %s", c)
                return False
        c = self.server_capabilities
        self.server_session_name = strtobytes(c.rawget("session_name",
                                                       b"")).decode("utf-8")
        set_name("Xpra", self.session_name or self.server_session_name
                 or "Xpra")
        self.server_platform = c.strget("platform")
        self.server_sharing = c.boolget("sharing")
        self.server_sharing_toggle = c.boolget("sharing-toggle")
        self.server_lock = c.boolget("lock")
        self.server_lock_toggle = c.boolget("lock-toggle")
        self.server_start_new_commands = c.boolget("start-new-commands")
        self.server_commands_info = c.boolget("server-commands-info")
        self.server_commands_signals = c.strlistget("server-commands-signals")
        self.server_readonly = c.boolget("readonly")
        if self.server_readonly and not self.readonly:
            log.info("server is read only")
            self.readonly = True

        i = platform_name(
            self._remote_platform,
            c.strlistget("platform.linux_distribution")
            or c.strget("platform.release", ""))
        r = self._remote_version
        if self._remote_revision:
            r += "-r%s" % self._remote_revision
        mode = c.strget("server.mode", "server")
        bits = c.intget("python.bits", 32)
        log.info("Xpra %s server version %s %i-bit", mode, std(r), bits)
        if i:
            log.info(" running on %s", std(i))
        if c.boolget("proxy"):
            proxy_hostname = c.strget("proxy.hostname")
            proxy_platform = c.strget("proxy.platform")
            proxy_release = c.strget("proxy.platform.release")
            proxy_version = c.strget("proxy.version")
            proxy_version = c.strget("proxy.build.version", proxy_version)
            proxy_distro = c.strget("linux_distribution")
            msg = "via: %s proxy version %s" % (platform_name(
                proxy_platform, proxy_distro
                or proxy_release), std(proxy_version or "unknown"))
            if proxy_hostname:
                msg += " on '%s'" % std(proxy_hostname)
            log.info(msg)
        return True
示例#5
0
    def get_info(self) -> dict:
        info = {
            "version":
            self.client_version or "unknown",
            "revision":
            self.client_revision or "unknown",
            "platform_name":
            platform_name(self.client_platform, self.client_release),
            "session-type":
            self.client_session_type or "",
            "session-type.full":
            self.client_session_type_full or "",
            "sharing":
            bool(self.sharing),
        }

        def addattr(k, name=None):
            v = getattr(self, (name or k).replace("-", "_"))
            #skip empty values:
            if v is not None:
                info[k] = v

        for k in ("session-id", "uuid", "user", "name", "argv"):
            addattr(k)
        for x in ("type", "platform", "release", "machine", "processor",
                  "proxy", "wm_name", "session_type"):
            addattr(x, "client_" + x)
        return info
示例#6
0
    def get_info(self):
        info = {
            "version":
            self.client_version or "unknown",
            "revision":
            self.client_revision or "unknown",
            "platform_name":
            platform_name(self.client_platform, self.client_release),
            "session-type":
            self.client_session_type,
            "session-type.full":
            self.client_session_type_full,
            "uuid":
            self.uuid,
            "hostname":
            self.hostname or "",
            "argv":
            self.argv,
        }

        def addattr(k, name):
            v = getattr(self, name)
            if v is not None:
                info[k] = v

        for x in ("type", "platform", "release", "machine", "processor",
                  "proxy", "wm_name", "session_type"):
            addattr(x, "client_" + x)
        return info
示例#7
0
 def make_os_str(sys_platform, platform_release, platform_platform,
                 platform_linux_distribution):
     s = platform_name(sys_platform, platform_release)
     if platform_linux_distribution and len(
             platform_linux_distribution) == 3 and len(
                 platform_linux_distribution[0]) > 0:
         s += "\n%s" % (" ".join(platform_linux_distribution))
     elif platform_platform:
         s += "\n%s" % platform_platform
     return s
示例#8
0
    def __init__(self):
        log.info("Xpra %s client version %s %i-bit", self.client_toolkit(),
                 full_version_str(), BITS)
        for c in UIXpraClient.__bases__:
            c.__init__(self)
        try:
            pinfo = get_platform_info()
            osinfo = "%s" % platform_name(
                sys.platform,
                pinfo.get("linux_distribution") or pinfo.get("sysrelease", ""))
            log.info(" running on %s", osinfo)
        except:
            log("platform name error:", exc_info=True)
        wm = get_wm_name()
        if wm:
            log.info(" window manager is '%s'", wm)

        self._ui_events = 0
        self.title = ""
        self.session_name = u""

        self.server_platform = ""
        self.server_session_name = None

        #features:
        self.opengl_enabled = False
        self.opengl_props = {}
        self.readonly = False
        self.xsettings_enabled = False
        self.server_start_new_commands = False

        #in WindowClient - should it be?
        #self.server_is_desktop = False
        self.server_sharing = False
        self.server_sharing_toggle = False
        self.server_lock = False
        self.server_lock_toggle = False
        self.server_window_filters = False

        self.client_supports_opengl = False
        self.client_supports_sharing = False
        self.client_lock = False

        #helpers and associated flags:
        self.client_extras = None
        self.keyboard_helper_class = KeyboardHelper
        self.keyboard_helper = None
        self.keyboard_grabbed = False
        self.pointer_grabbed = False
        self.kh_warning = False
        self.menu_helper = None

        #state:
        self._on_handshake = []
        self._on_server_setting_changed = {}
示例#9
0
 def make_os_str(sys_platform, platform_release, platform_platform, platform_linux_distribution):
     s = platform_name(sys_platform, platform_release)
     if (
         platform_linux_distribution
         and len(platform_linux_distribution) == 3
         and len(platform_linux_distribution[0]) > 0
     ):
         s += "\n%s" % (" ".join(platform_linux_distribution))
     elif platform_platform:
         s += "\n%s" % platform_platform
     return s
示例#10
0
def do_get_platform_info():
    from xpra.os_util import platform_name
    info = {
            ""          : sys.platform,
            "name"      : platform_name(sys.platform, python_platform.release()),
            "release"   : python_platform.release(),
            "platform"  : python_platform.platform(),
            "machine"   : python_platform.machine(),
            "processor" : python_platform.processor(),
            }
    if sys.platform.startswith("linux") and hasattr(python_platform, "linux_distribution"):
        info["linux_distribution"] = python_platform.linux_distribution()
    return info
示例#11
0
 def print_run_info(self):
     try:
         from xpra.src_info import REVISION
         rev_info = "-r%s" % REVISION
     except:
         rev_info = ""
     log.info("xpra %s version %s%s", self.get_server_mode(), local_version, rev_info)
     try:
         pinfo = get_platform_info()
         osinfo = " on %s" % platform_name(sys.platform, pinfo.get("linux_distribution") or pinfo.get("release", ""))
     except:
         log("platform name error:", exc_info=True)
         osinfo = ""
     log.info(" running with pid %s%s", os.getpid(), osinfo)
示例#12
0
def do_get_platform_info():
    from xpra.scripts.config import python_platform
    from xpra.os_util import platform_name
    info = {
            "platform"           : sys.platform,
            "platform.name"      : platform_name(sys.platform, python_platform.release()),
            "platform.release"   : python_platform.release(),
            "platform.platform"  : python_platform.platform(),
            "platform.machine"   : python_platform.machine(),
            "platform.processor" : python_platform.processor(),
            }
    if sys.platform.startswith("linux"):
        info["platform.linux_distribution"] = python_platform.linux_distribution()
    return info
示例#13
0
def do_get_platform_info():
    from xpra.os_util import platform_name, platform_release
    pp = sys.modules.get("platform", python_platform)

    def get_processor_name():
        if pp.system() == "Windows":
            return pp.processor()
        elif pp.system() == "Darwin":
            os.environ['PATH'] = os.environ['PATH'] + os.pathsep + '/usr/sbin'
            command = "sysctl -n machdep.cpu.brand_string"
            import subprocess
            return subprocess.check_output(command).strip()
        elif pp.system() == "Linux":
            with open("/proc/cpuinfo") as f:
                data = f.read()
            import re
            for line in data.split("\n"):
                if "model name" in line:
                    return re.sub(".*model name.*:", "", line, 1).strip()
        assert False

    info = {}
    ld = get_linux_distribution()
    if ld:
        info["linux_distribution"] = ld
    release = platform_release(pp.release())
    info.update({
        "":
        sys.platform,
        "name":
        platform_name(sys.platform,
                      info.get("linux_distribution") or release),
        "release":
        pp.release(),
        "sysrelease":
        release,
        "platform":
        pp.platform(),
        "machine":
        pp.machine(),
        "processor":
        pp.processor(),
        "architecture":
        pp.architecture(),
    })
    try:
        info["processor"] = get_processor_name()
    except:
        info["processor"] = pp.processor()
    return info
示例#14
0
def do_get_platform_info():
    from xpra.os_util import platform_name
    info = {
        "": sys.platform,
        "name": platform_name(sys.platform, python_platform.release()),
        "release": python_platform.release(),
        "platform": python_platform.platform(),
        "machine": python_platform.machine(),
        "processor": python_platform.processor(),
    }
    if sys.platform.startswith("linux") and hasattr(python_platform,
                                                    "linux_distribution"):
        info["linux_distribution"] = python_platform.linux_distribution()
    return info
示例#15
0
    def populate_form(self):
        btn = link_btn("https://github.com/Xpra-org/xpra/blob/master/docs/Features/Webcam.md",
                       label="Open Webcam Documentation", icon_name=None)
        self.vbox.pack_start(btn, expand=True, fill=False, padding=20)

        tb = self.table()
        cb = self.bool_cb(tb, "Webcam", "webcam")
        if OSX or WIN32:
            cb.set_sensitive(False)
            cb.set_active(False)
            tb.inc()
            tb.attach(Gtk.Label(""), 0, 2)
            tb.inc()
            tb.attach(Gtk.Label("Webcam forwarding is not supported on %s" % platform_name()), 0, 2)
        self.vbox.show_all()
示例#16
0
 def print_run_info(self):
     try:
         from xpra.src_info import REVISION
         rev_info = "-r%s" % REVISION
     except:
         rev_info = ""
     log.info("xpra %s version %s%s", self.get_server_mode(), local_version,
              rev_info)
     try:
         pinfo = get_platform_info()
         osinfo = " on %s" % platform_name(
             sys.platform,
             pinfo.get("linux_distribution") or pinfo.get("release", ""))
     except:
         log("platform name error:", exc_info=True)
         osinfo = ""
     log.info(" running with pid %s%s", os.getpid(), osinfo)
示例#17
0
 def session_toggled(self, *args):
     localhost = self.localhost_btn.get_active()
     log("session_toggled(%s) localhost=%s", args, localhost)
     shadow = self.shadow_btn.get_active()
     local_shadow_only = WIN32 or OSX
     if shadow:
         self.exit_with_client_cb.set_active(True)
     elif local_shadow_only and localhost:
         #can only do shadow on localhost, so switch to remote:
         self.remote_btn.set_active(True)
     can_use_localhost = shadow or not local_shadow_only
     self.localhost_btn.set_sensitive(can_use_localhost)
     self.localhost_btn.set_tooltip_text(
         "Start sessions on the local system" if can_use_localhost else
         "Cannot start local desktop or seamless sessions on %s" %
         platform_name())
     self.display_changed()
     self.populate_menus()
     self.entry_changed()
示例#18
0
def do_get_platform_info():
    from xpra.os_util import platform_name

    def get_processor_name():
        if pp.system() == "Windows":
            return pp.processor()
        elif pp.system() == "Darwin":
            os.environ["PATH"] = os.environ["PATH"] + os.pathsep + "/usr/sbin"
            command = "sysctl -n machdep.cpu.brand_string"
            import subprocess

            return subprocess.check_output(command).strip()
        elif pp.system() == "Linux":
            with open("/proc/cpuinfo") as f:
                data = f.read()
            import re

            for line in data.split("\n"):
                if "model name" in line:
                    return re.sub(".*model name.*:", "", line, 1).strip()
        assert False

    info = {}
    if sys.platform.startswith("linux") and hasattr(pp, "linux_distribution"):
        info["linux_distribution"] = pp.linux_distribution()
    info.update(
        {
            "": sys.platform,
            "name": platform_name(sys.platform, info.get("linux_distribution") or pp.release()),
            "release": pp.release(),
            "platform": pp.platform(),
            "machine": pp.machine(),
            "processor": pp.processor(),
            "architecture": pp.architecture(),
        }
    )
    try:
        info["processor"] = get_processor_name()
    except:
        info["processor"] = pp.processor()
    return info
示例#19
0
    def get_info(self) -> dict:
        info = {
            "version":
            self.client_version or "unknown",
            "revision":
            self.client_revision or "unknown",
            "platform_name":
            platform_name(self.client_platform, self.client_release),
            "session-type":
            self.client_session_type or "",
            "session-type.full":
            self.client_session_type_full or "",
            "session-id":
            self.session_id or "",
            "uuid":
            self.uuid or "",
            "hostname":
            self.hostname or "",
            "user":
            self.user,
            "name":
            self.name,
            "argv":
            self.argv or (),
            "sharing":
            bool(self.sharing),
        }

        def addattr(k, name):
            v = getattr(self, name)
            if v is not None:
                info[k] = v

        for x in ("type", "platform", "release", "machine", "processor",
                  "proxy", "wm_name", "session_type"):
            addattr(x, "client_" + x)
        return info
示例#20
0
文件: gui.py 项目: DiGuoZhiMeng/Xpra
    def __init__(self, title="Xpra"):
        self.exit_code = 0
        self.start_session = None
        gtk.Window.__init__(self)
        self.set_title(title)
        self.set_border_width(10)
        self.set_resizable(True)
        self.set_decorated(True)
        self.set_position(WIN_POS_CENTER)
        icon = get_pixbuf("xpra")
        if icon:
            self.set_icon(icon)
        add_close_accel(self, self.quit)
        add_window_accel(self, 'F1', self.show_about)
        self.connect("delete_event", self.quit)

        self.vbox = gtk.VBox(False, 10)
        self.add(self.vbox)
        #with most window managers,
        #the window's title bar already shows "Xpra"
        #title_label = gtk.Label(title)
        #title_label.modify_font(pango.FontDescription("sans 14"))
        #self.vbox.add(title_label)
        self.widgets = []
        label_font = pango.FontDescription("sans 16")
        if has_client:
            icon = get_pixbuf("browse.png")
            self.browse_button = imagebutton(
                "Browse",
                icon,
                "Browse and connect to local sessions",
                clicked_callback=self.browse,
                icon_size=48,
                label_font=label_font)
            self.widgets.append(self.browse_button)
            icon = get_pixbuf("connect.png")
            self.connect_button = imagebutton(
                "Connect",
                icon,
                "Connect to a session",
                clicked_callback=self.show_launcher,
                icon_size=48,
                label_font=label_font)
            self.widgets.append(self.connect_button)
        if has_server:
            icon = get_pixbuf("server-connected.png")
            self.shadow_button = imagebutton(
                "Shadow",
                icon,
                "Start a shadow server",
                clicked_callback=self.start_shadow,
                icon_size=48,
                label_font=label_font)
            if not has_shadow:
                set_tooltip_text(
                    self.shadow_button,
                    "This build of Xpra does not support starting sessions")
                self.shadow_button.set_sensitive(False)
            self.widgets.append(self.shadow_button)
            icon = get_pixbuf("windows.png")
            self.start_button = imagebutton("Start",
                                            icon,
                                            "Start a session",
                                            clicked_callback=self.start,
                                            icon_size=48,
                                            label_font=label_font)
            #not all builds and platforms can start sessions:
            if OSX or WIN32:
                set_tooltip_text(
                    self.start_button,
                    "Starting sessions is not supported on %s" %
                    platform_name(sys.platform))
                self.start_button.set_sensitive(False)
            elif not has_server:
                set_tooltip_text(
                    self.start_button,
                    "This build of Xpra does not support starting sessions")
                self.start_button.set_sensitive(False)
            self.widgets.append(self.start_button)
        assert len(self.widgets) % 2 == 0
        table = gtk.Table(len(self.widgets) // 2, 2, True)
        for i, widget in enumerate(self.widgets):
            table.attach(widget,
                         i % 2,
                         i % 2 + 1,
                         i // 2,
                         i // 2 + 1,
                         xpadding=10,
                         ypadding=10)
        self.vbox.add(table)
        self.vbox.show_all()
        self.set_size_request(640, 100 + 100 * len(self.widgets) // 2)

        def focus_in(window, event):
            log("focus_in(%s, %s)", window, event)

        def focus_out(window, event):
            log("focus_out(%s, %s)", window, event)
            self.reset_cursors()

        self.connect("focus-in-event", focus_in)
        self.connect("focus-out-event", focus_out)
示例#21
0
    def do_update_screen(self):
        self.log("do_update_screen()")
        #c = self.stdscr.getch()
        #if c==curses.KEY_RESIZE:
        height, width = self.stdscr.getmaxyx()
        #log.info("update_screen() %ix%i", height, width)
        title = get_title()
        sli = self.server_last_info

        def _addstr(pad, y, x, s, *args):
            if len(s) + x >= width - pad:
                s = s[:max(0, width - x - 2 - pad)] + ".."
            self.stdscr.addstr(y, x, s, *args)

        def addstr_main(y, x, s, *args):
            _addstr(0, y, x, s, *args)

        def addstr_box(y, x, s, *args):
            _addstr(2, y, x, s, *args)

        try:
            x = max(0, width // 2 - len(title) // 2)
            addstr_main(0, x, title, curses.A_BOLD)
            if height <= 1:
                return
            server_info = self.slidictget("server")
            build = self.slidictget("server", "build")
            vstr = caps_to_version(build)
            mode = server_info.strget("mode", "server")
            python_info = typedict(server_info.dictget("python", {}))
            bits = python_info.intget("bits", 32)
            server_str = "Xpra %s server version %s %i-bit" % (mode, vstr,
                                                               bits)
            proxy_info = self.slidictget("proxy")
            if proxy_info:
                proxy_platform_info = typedict(
                    proxy_info.dictget("platform", {}))
                proxy_platform = proxy_platform_info.strget("")
                proxy_release = proxy_platform_info.strget("release")
                proxy_build_info = typedict(proxy_info.dictget("build", {}))
                proxy_version = proxy_build_info.strget("version")
                proxy_distro = proxy_info.strget("linux_distribution")
                server_str += " via: %s proxy version %s" % (platform_name(
                    proxy_platform, proxy_distro
                    or proxy_release), std(proxy_version or "unknown"))
            addstr_main(1, 0, server_str)
            if height <= 2:
                return
            #load and uptime:
            now = datetime.now()
            uptime = ""
            elapsed_time = server_info.intget("elapsed_time")
            if elapsed_time:
                td = timedelta(seconds=elapsed_time)
                uptime = " up %s" % str(td).lstrip("0:")
            clients_info = self.slidictget("clients")
            nclients = clients_info.intget("")
            load_average = ""
            load = sli.inttupleget("load")
            if load and len(load) == 3:
                float_load = tuple(v / 1000.0 for v in load)
                load_average = ", load average: %1.2f, %1.2f, %1.2f" % float_load
            addstr_main(
                2, 0, "xpra top - %s%s, %2i users%s" %
                (now.strftime("%H:%M:%S"), uptime, nclients, load_average))
            if height <= 3:
                return
            thread_info = self.slidictget("threads")
            rinfo = "%i threads" % thread_info.intget("count")
            server_pid = server_info.intget("pid", 0)
            if server_pid:
                rinfo += ", pid %i" % server_pid
                machine_id = server_info.get("machine-id")
                if machine_id is None or machine_id == get_machine_id():
                    try:
                        process = self.psprocess.get(server_pid)
                        if not process:
                            import psutil
                            process = psutil.Process(server_pid)
                            self.psprocess[server_pid] = process
                        else:
                            cpu = process.cpu_percent()
                            rinfo += ", %i%% CPU" % (cpu)
                    except Exception:
                        pass
            cpuinfo = self.slidictget("cpuinfo")
            if cpuinfo:
                rinfo += ", %s" % cpuinfo.strget("hz_actual")
            elapsed = monotonic_time() - self.server_last_info_time
            color = WHITE
            if self.server_last_info_time == 0:
                rinfo += " - no server data"
            elif elapsed > 2:
                rinfo += " - last updated %i seconds ago" % elapsed
                color = RED
            addstr_main(3, 0, rinfo, curses.color_pair(color))
            if height <= 4:
                return
            #display:
            dinfo = []
            server = self.slidictget("server")
            rws = server.intpair("root_window_size", None)
            if rws:
                sinfo = "%ix%i display" % (rws[0], rws[1])
                mds = server.intpair("max_desktop_size")
                if mds:
                    sinfo += " (max %ix%i)" % (mds[0], mds[1])
                dinfo.append(sinfo)
            cursor_info = self.slidictget("cursor")
            if cursor_info:
                cx, cy = cursor_info.inttupleget("position", (0, 0))
                dinfo.append("cursor at %ix%i" % (cx, cy))
            display_info = self.slidictget("display")
            pid = display_info.intget("pid")
            if pid:
                dinfo.append("pid %i" % pid)
            addstr_main(4, 0, csv(dinfo))
            if height <= 5:
                return
            hpos = 5
            gl_info = self.get_gl_info(display_info.dictget("opengl"))
            if gl_info:
                addstr_main(5, 0, gl_info)
                hpos += 1

            if hpos < height - 3:
                hpos += 1
                if nclients == 0:
                    addstr_main(hpos, 0, "no clients connected")
                else:
                    addstr_main(
                        hpos, 0,
                        "%i client%s connected:" % (nclients, engs(nclients)))
                hpos += 1
            client_info = self.slidictget("client")
            client_no = 0
            while True:
                ci = client_info.dictget(client_no)
                if not ci:
                    break
                client_no += 1
                ci = typedict(ci)
                session_id = ci.strget("session-id")
                if session_id:
                    #don't show ourselves:
                    if session_id == self.session_id:
                        continue
                elif not ci.boolget("windows", True):
                    #for older servers, hide any client that doesn't display windows:
                    continue
                ci = self.get_client_info(ci)
                l = len(ci)
                if hpos + 2 + l > height:
                    if hpos < height:
                        more = nclients - client_no
                        addstr_box(
                            hpos, 0,
                            "%i client%s not shown" % (more, engs(more)),
                            curses.A_BOLD)
                    break
                self.box(1, hpos, width - 2, 2 + l)
                for i, info in enumerate(ci):
                    info_text, color = info
                    cpair = curses.color_pair(color)
                    addstr_box(hpos + i + 1, 2, info_text, cpair)
                hpos += 2 + l

            windows = self.slidictget("windows")
            if hpos < height - 3:
                hpos += 1
                addstr_main(hpos, 0,
                            "%i window%s:" % (len(windows), engs(windows)))
                hpos += 1
            wins = tuple(windows.values())
            nwindows = len(wins)
            for win_no, win in enumerate(wins):
                wi = self.get_window_info(typedict(win))
                l = len(wi)
                if hpos + 2 + l > height:
                    if hpos < height:
                        more = nwindows - win_no
                        addstr_main(hpos, 0, "terminal window is too small: %i window%s not shown" % \
                                           (more, engs(more)), curses.A_BOLD)
                    break
                self.box(1, hpos, width - 2, 2 + l)
                for i, info in enumerate(wi):
                    info_text, color = info
                    cpair = curses.color_pair(color)
                    addstr_box(hpos + i + 1, 2, info_text, cpair)
                hpos += 2 + l
        except Exception as e:
            self.err(e)
示例#22
0
    def __init__(self):
        log.info("Xpra %s client version %s %i-bit", self.client_toolkit(), full_version_str(), BITS)
        #mmap_enabled belongs in the MmapClient mixin,
        #but it is used outside it, so make sure we define it:
        self.mmap_enabled = False
        #same for tray:
        self.tray = None
        for c in CLIENT_BASES:
            log("calling %s.__init__()", c)
            c.__init__(self)
        try:
            pinfo = get_platform_info()
            osinfo = "%s" % platform_name(sys.platform, pinfo.get("linux_distribution") or pinfo.get("sysrelease", ""))
            log.info(" running on %s", osinfo)
        except Exception:
            log("platform name error:", exc_info=True)
        wm = get_wm_name()      #pylint: disable=assignment-from-none
        if wm:
            log.info(" window manager is '%s'", wm)

        self._ui_events = 0
        self.title = ""
        self.session_name = u""

        self.server_platform = ""
        self.server_session_name = None

        #features:
        self.opengl_enabled = False
        self.opengl_props = {}
        self.readonly = False
        self.xsettings_enabled = False
        self.server_start_new_commands = False
        self.server_xdg_menu = None
        self.start_new_commands  = []
        self.start_child_new_commands  = []

        #in WindowClient - should it be?
        #self.server_is_desktop = False
        self.server_sharing = False
        self.server_sharing_toggle = False
        self.server_lock = False
        self.server_lock_toggle = False
        self.server_window_filters = False
        self.server_keyboard = True
        self.server_toggle_keyboard_sync = False
        self.server_pointer = True

        self.client_supports_opengl = False
        self.client_supports_sharing = False
        self.client_lock = False

        #helpers and associated flags:
        self.client_extras = None
        self.keyboard_helper_class = KeyboardHelper
        self.keyboard_helper = None
        self.keyboard_grabbed = False
        self.keyboard_sync = False
        self.pointer_grabbed = False
        self.kh_warning = False
        self.menu_helper = None

        #state:
        self._on_handshake = []
        self._on_server_setting_changed = {}
示例#23
0
    def do_update_screen(self):
        #c = self.stdscr.getch()
        #if c==curses.KEY_RESIZE:
        height, width = self.stdscr.getmaxyx()
        #log.info("update_screen() %ix%i", height, width)
        title = "Xpra top %s" % __version__
        try:
            from xpra.src_info import REVISION, LOCAL_MODIFICATIONS
            title += "-r%s" % REVISION
            if LOCAL_MODIFICATIONS:
                title += "M"
        except ImportError:
            pass
        x = max(0, width // 2 - len(title) // 2)
        sli = self.server_last_info
        try:
            self.stdscr.addstr(0, x, title, curses.A_BOLD)
            if height <= 1:
                return
            server_info = self.dictget("server")
            build = self.dictget("build")
            v = build.strget("version")
            revision = build.strget("revision")
            if v and revision:
                v = " version %s-r%s" % (v, revision)
            mode = server_info.strget("mode", "server")
            python_info = typedict(server_info.dictget("python", {}))
            bits = python_info.intget("bits", 32)
            server_str = "Xpra %s server%s %i-bit" % (mode, std(v), bits)
            proxy_info = self.dictget("proxy")
            if proxy_info:
                proxy_platform_info = typedict(
                    proxy_info.dictget("platform", {}))
                proxy_platform = proxy_platform_info.strget("")
                proxy_release = proxy_platform_info.strget("release")
                proxy_build_info = typedict(proxy_info.dictget("build", {}))
                proxy_version = proxy_build_info.strget("version")
                proxy_distro = proxy_info.strget("linux_distribution")
                server_str += " via: %s proxy version %s" % (platform_name(
                    proxy_platform, proxy_distro
                    or proxy_release), std(proxy_version or "unknown"))
            self.stdscr.addstr(1, 0, server_str)
            if height <= 2:
                return
            #load and uptime:
            now = datetime.now()
            uptime = ""
            elapsed_time = server_info.intget("elapsed_time")
            if elapsed_time:
                td = timedelta(seconds=elapsed_time)
                uptime = " up %s" % str(td).lstrip("0:")
            clients_info = self.dictget("clients")
            nclients = clients_info.intget("")
            load_average = ""
            load = sli.intlistget("load")
            if load and len(load) == 3:
                float_load = tuple(v / 1000.0 for v in load)
                load_average = ", load average: %1.2f, %1.2f, %1.2f" % float_load
            self.stdscr.addstr(
                2, 0, "xpra top - %s%s, %2i users%s" %
                (now.strftime("%H:%M:%S"), uptime, nclients, load_average))
            if height <= 3:
                return
            thread_info = self.dictget("threads")
            self.stdscr.addstr(3, 0,
                               "%i threads" % thread_info.intget("count"))
            if height <= 4:
                return
            #cursor:
            cursor_info = self.dictget("cursor")
            cx, cy = cursor_info.intlistget("position", (0, 0))
            self.stdscr.addstr(4, 0, "cursor at %ix%i" % (cx, cy))
            if height <= 5:
                return

            hpos = 6
            client_info = self.dictget("client")
            client_no = 0
            while True:
                ci = client_info.dictget(client_no)
                if not ci:
                    break
                client_no += 1
                ci = typedict(ci)
                if not ci.boolget("windows", True):
                    continue
                ci = self.get_client_info(ci)
                l = len(ci)
                if hpos + 2 + l > height:
                    if hpos < height:
                        more = nclients - client_no
                        self.stdscr.addstr(
                            hpos, 0,
                            "%i client%s not shown" % (more, engs(more)),
                            curses.A_BOLD)
                    break
                self.box(self.stdscr, 1, hpos, width - 2, 2 + l)
                for i, info in enumerate(ci):
                    info_text, color = info
                    cpair = curses.color_pair(color)
                    self.stdscr.addstr(hpos + i + 1, 2, info_text, cpair)
                hpos += 2 + l

            windows = self.dictget("windows")
            if hpos < height - 3:
                hpos += 1
                self.stdscr.addstr(hpos, 0, "%i windows" % len(windows))
                hpos += 1
            wins = tuple(windows.values())
            nwindows = len(wins)
            for win_no, win in enumerate(wins):
                wi = self.get_window_info(typedict(win))
                l = len(wi)
                if hpos + 2 + l > height:
                    if hpos < height:
                        more = nwindows - win_no
                        self.stdscr.addstr(
                            hpos, 0,
                            "terminal window is too small: %i window%s not shown"
                            % (more, engs(more)), curses.A_BOLD)
                    break
                self.box(self.stdscr, 1, hpos, width - 2, 2 + l)
                for i, info in enumerate(wi):
                    info_text, color = info
                    cpair = curses.color_pair(color)
                    self.stdscr.addstr(hpos + i + 1, 2, info_text, cpair)
                hpos += 2 + l
        except Exception as e:
            import traceback
            self.stdscr.addstr(0, 0, str(e))
            self.stdscr.addstr(0, 1, traceback.format_exc())
示例#24
0
    def parse_server_capabilities(self, c : typedict) -> bool:
        for cb in CLIENT_BASES:
            if not cb.parse_server_capabilities(self, c):
                log.info("failed to parse server capabilities in %s", cb)
                return False
        self.server_session_name = c.uget("session_name")
        set_name("Xpra", self.session_name or self.server_session_name or "Xpra")
        self.server_platform = c.strget("platform")
        self.server_sharing = c.boolget("sharing")
        self.server_sharing_toggle = c.boolget("sharing-toggle")
        self.server_lock = c.boolget("lock")
        self.server_lock_toggle = c.boolget("lock-toggle")
        self.server_keyboard = c.boolget("keyboard", True)
        self.server_pointer = c.boolget("pointer", True)
        self.server_start_new_commands = c.boolget("start-new-commands")
        if self.server_start_new_commands:
            self.server_xdg_menu = c.dictget("xdg-menu", None)
        if self.start_new_commands or self.start_child_new_commands:
            if self.server_start_new_commands:
                self.after_handshake(self.send_start_new_commands)
            else:
                log.warn("Warning: cannot start new commands")
                log.warn(" the feature is currently disabled on the server")
        self.server_commands_info = c.boolget("server-commands-info")
        self.server_commands_signals = c.strtupleget("server-commands-signals")
        self.server_readonly = c.boolget("readonly")
        if self.server_readonly and not self.readonly:
            log.info("server is read only")
            self.readonly = True
        if not self.server_keyboard and self.keyboard_helper:
            #swallow packets:
            def nosend(*_args):
                pass
            self.keyboard_helper.send = nosend

        i = platform_name(self._remote_platform,
                          c.strtupleget("platform.linux_distribution") or c.strget("platform.release", ""))
        r = self._remote_version
        if self._remote_revision:
            r += "-r%s" % self._remote_revision
        mode = c.strget("server.mode", "server")
        bits = c.intget("python.bits", 32)
        log.info("Xpra %s server version %s %i-bit", mode, std(r), bits)
        if i:
            log.info(" running on %s", std(i))
        if c.boolget("desktop") or c.boolget("shadow"):
            v = c.intpair("actual_desktop_size")
            if v:
                w, h = v
                ss = c.tupleget("screen_sizes")
                if ss:
                    log.info(" remote desktop size is %sx%s with %s screen%s:", w, h, len(ss), engs(ss))
                    log_screen_sizes(w, h, ss)
                else:
                    log.info(" remote desktop size is %sx%s", w, h)
        if c.boolget("proxy"):
            proxy_hostname = c.strget("proxy.hostname")
            proxy_platform = c.strget("proxy.platform")
            proxy_release = c.strget("proxy.platform.release")
            proxy_version = c.strget("proxy.version")
            proxy_version = c.strget("proxy.build.version", proxy_version)
            proxy_distro = c.strget("proxy.linux_distribution")
            msg = "via: %s proxy version %s" % (
                platform_name(proxy_platform, proxy_distro or proxy_release),
                std(proxy_version or "unknown")
                )
            if proxy_hostname:
                msg += " on '%s'" % std(proxy_hostname)
            log.info(msg)
        return True
示例#25
0
    def __init__(self, title="Xpra"):
        self.exit_code = 0
        self.start_session = None
        Gtk.Window.__init__(self)

        hb = Gtk.HeaderBar()
        hb.set_show_close_button(True)
        hb.props.title = "Xpra"
        self.set_titlebar(hb)
        hb.add(self.button("About", "help-about", about))
        try:
            from xpra.client.gtk_base.toolbox import ToolboxGUI
        except ImportError:
            pass
        else:

            def show():
                w = None

                def hide(*_args):
                    w.hide()

                ToolboxGUI.quit = hide
                w = ToolboxGUI()
                w.show()

            hb.add(self.button("Toolbox", "applications-utilities", show))
            hb.show_all()

        self.set_title(title)
        self.set_border_width(10)
        self.set_resizable(True)
        self.set_decorated(True)
        self.set_position(Gtk.WindowPosition.CENTER)
        icon = get_icon_pixbuf("xpra.png")
        if icon:
            self.set_icon(icon)
        add_close_accel(self, self.quit)
        add_window_accel(self, 'F1', self.show_about)
        self.connect("delete_event", self.quit)
        self.set_wmclass("xpra-gui", "Xpra-GUI")

        self.vbox = Gtk.VBox(False, 10)
        self.add(self.vbox)
        #with most window managers,
        #the window's title bar already shows "Xpra"
        #title_label = Gtk.Label(title)
        #title_label.modify_font(pango.FontDescription("sans 14"))
        #self.vbox.add(title_label)
        self.widgets = []
        label_font = Pango.FontDescription("sans 16")
        if has_client:
            icon = get_icon_pixbuf("browse.png")
            self.browse_button = imagebutton(
                "Browse",
                icon,
                "Browse and connect to local sessions",
                clicked_callback=self.browse,
                icon_size=48,
                label_font=label_font)
            self.widgets.append(self.browse_button)
            icon = get_icon_pixbuf("connect.png")
            self.connect_button = imagebutton(
                "Connect",
                icon,
                "Connect to a session",
                clicked_callback=self.show_launcher,
                icon_size=48,
                label_font=label_font)
            self.widgets.append(self.connect_button)
        if has_server:
            icon = get_icon_pixbuf("server-connected.png")
            self.shadow_button = imagebutton(
                "Shadow",
                icon,
                "Start a shadow server",
                clicked_callback=self.start_shadow,
                icon_size=48,
                label_font=label_font)
            if not has_shadow:
                self.shadow_button.set_tooltip_text(
                    "This build of Xpra does not support starting sessions")
                self.shadow_button.set_sensitive(False)
            self.widgets.append(self.shadow_button)
            icon = get_icon_pixbuf("windows.png")
            self.start_button = imagebutton("Start",
                                            icon,
                                            "Start a session",
                                            clicked_callback=self.start,
                                            icon_size=48,
                                            label_font=label_font)
            #not all builds and platforms can start sessions:
            if OSX or WIN32:
                self.start_button.set_tooltip_text(
                    "Starting sessions is not supported on %s" %
                    platform_name(sys.platform))
                self.start_button.set_sensitive(False)
            elif not has_server:
                self.start_button.set_tooltip_text(
                    "This build of Xpra does not support starting sessions")
                self.start_button.set_sensitive(False)
            self.widgets.append(self.start_button)
        assert len(self.widgets) % 2 == 0
        table = Gtk.Table(len(self.widgets) // 2, 2, True)
        for i, widget in enumerate(self.widgets):
            table.attach(widget,
                         i % 2,
                         i % 2 + 1,
                         i // 2,
                         i // 2 + 1,
                         xpadding=10,
                         ypadding=10)
        self.vbox.add(table)
        self.vbox.show_all()
        self.set_size_request(640, 100 + 100 * len(self.widgets) // 2)

        def focus_in(window, event):
            log("focus_in(%s, %s)", window, event)

        def focus_out(window, event):
            log("focus_out(%s, %s)", window, event)
            self.reset_cursors()

        self.connect("focus-in-event", focus_in)
        self.connect("focus-out-event", focus_out)