Ticket #1022: client-listen-v2.patch

xpra/client/client_base.py

@@ -536 +536 @@
         register_SIGUSR_signals(glib.idle_add)
 
     def run(self):
-        self._protocol.start()
+        if self._protocol:
+            self._protocol.start()
 
     def quit(self, exit_code=0):
         raise Exception("override me!")

xpra/client/gtk_base/gtk_client_window_base.py

@@ -1982 +1982 @@
 
 
     def do_unmap_event(self, event):
-        eventslog("do_unmap_event(%s)", event)
+        eventslog.error("do_unmap_event(%s)", event)
         self._unfocus()
         if not self._override_redirect:
             self.send("unmap-window", self._id, False)

xpra/client/mixins/network_state.py

@@ -265 +265 @@
         self.send_deflate_level()
 
     def send_deflate_level(self):
-        self._protocol.set_compression_level(self.compression_level)
-        self.send("set_deflate", self.compression_level)
+        if self._protocol:
+            self._protocol.set_compression_level(self.compression_level)
+            self.send("set_deflate", self.compression_level)
 
 
     def send_bandwidth_limit(self):

xpra/client/tray_base.py

@@ -83 +83 @@
         name = basename or self.default_icon_filename
         f = get_icon_filename(name, self.default_icon_extension)
         if not f:
+            import traceback
+            traceback.print_stack()
             log.error("Error: cannot find icon '%s'", name)
         return f
 

xpra/platform/dotxpra.py

@@ -9 +9 @@
 import socket
 import errno
 import stat
+import time
 
-from xpra.os_util import get_util_logger, osexpand, umask_context
+from xpra.os_util import get_util_logger, osexpand, umask_context, monotonic_time
 from xpra.platform.dotxpra_common import PREFIX, LIVE, DEAD, UNKNOWN, INACCESSIBLE
 from xpra.platform import platform_import
 
@@ -75 +76 @@
     def get_server_state(self, sockpath, timeout=5):
         if not os.path.exists(sockpath):
             return DotXpra.DEAD
-        sock = socket.socket(socket.AF_UNIX)
-        sock.settimeout(timeout)
+        state = DotXpra.UNKNOWN
         try:
-            sock.connect(sockpath)
-            return DotXpra.LIVE
-        except socket.error as e:
-            debug("get_server_state: connect(%s)=%s (timeout=%s)", sockpath, e, timeout)
-            err = e.args[0]
-            if err==errno.EACCES:
-                return DotXpra.INACCESSIBLE
-            if err==errno.ECONNREFUSED:
-                #could be the server is starting up
-                debug("ECONNREFUSED")
-                return DotXpra.UNKNOWN
-            if err==errno.EWOULDBLOCK:
-                debug("EWOULDBLOCK")
-                return DotXpra.DEAD
-            if err==errno.ENOENT:
-                debug("ENOENT")
-                return DotXpra.DEAD
-            return self.UNKNOWN
+            start = monotonic_time()
+            while monotonic_time()-start<timeout:
+                try:
+                    sock = socket.socket(socket.AF_UNIX)
+                    sock.settimeout(timeout)
+                    sock.connect(sockpath)
+                    return DotXpra.LIVE
+                except socket.error as e:
+                    debug("get_server_state: connect(%s)=%s (timeout=%s)", sockpath, e, timeout)
+                    err = e.args[0]
+                    if err==errno.EACCES:
+                        return DotXpra.INACCESSIBLE
+                    if err==errno.ECONNREFUSED:
+                        #could be the server is starting up
+                        debug("ECONNREFUSED")
+                        state = DotXpra.UNKNOWN
+                        time.sleep(0.1)
+                        continue
+                    if err==errno.EWOULDBLOCK:
+                        debug("EWOULDBLOCK")
+                        state = DotXpra.DEAD
+                        time.sleep(0.1)
+                        continue
+                    if err==errno.ENOENT:
+                        debug("ENOENT")
+                        state = DotXpra.DEAD
+                        time.sleep(0.1)
+                        continue
+                    return self.UNKNOWN
+            return state
         finally:
             try:
                 sock.close()

xpra/scripts/main.py

@@ -147 +147 @@
 
 def configure_logging(options, mode):
     if mode in (
-        "showconfig", "info", "id", "attach", "launcher", "stop", "print",
+        "showconfig", "info", "id", "attach", "listen", "launcher", "stop", "print",
         "control", "list", "list-mdns", "sessions", "mdns-gui", "bug-report",
         "opengl", "opengl-probe", "test-connect",
         ):
@@ -171 +171 @@
     setloghandler(logging.StreamHandler(to))
     if mode in (
         "start", "start-desktop", "upgrade", "upgrade-desktop",
-        "attach", "shadow", "proxy",
+        "attach", "listen", "shadow", "proxy",
         "_sound_record", "_sound_play",
         "stop", "print", "showconfig",
         "request-start", "request-start-desktop", "request-shadow",
@@ -178 +178 @@
         "_dialog", "_pass",
         ):
         if "help" in options.speaker_codec or "help" in options.microphone_codec:
-            codec_help = show_sound_codec_help(mode!="attach", options.speaker_codec, options.microphone_codec)
+            server_mode = mode not in ("attach", "listen")
+            codec_help = show_sound_codec_help(server_mode, options.speaker_codec, options.microphone_codec)
             raise InitInfo("\n".join(codec_help))
         fmt = LOG_FORMAT
         if mode in ("stop", "showconfig"):
@@ -312 +313 @@
         #sound commands don't want to set the name
         #(they do it later to prevent glib import conflicts)
         #"attach" does it when it received the session name from the server
-        if mode not in ("attach", "start", "start-desktop", "upgrade", "upgrade-desktop", "proxy", "shadow"):
+        if mode not in ("attach", "listen", "start", "start-desktop", "upgrade", "upgrade-desktop", "proxy", "shadow"):
             from xpra.platform import set_name
             set_name("Xpra", "Xpra %s" % mode.strip("_"))
 
     if mode in (
         "start", "start-desktop",
-        "shadow", "attach",
+        "shadow", "attach", "listen",
         "request-start", "request-start-desktop", "request-shadow",
         ):
         options.encodings = validated_encodings(options.encodings)
@@ -427 +428 @@
                 add_when_ready(attach_client)
             return run_server(error_cb, options, mode, script_file, args, current_display)
         elif mode in (
-            "attach", "detach",
+            "attach", "listen", "detach",
             "screenshot", "version", "info", "id",
             "control", "_monitor", "top", "print",
             "connect-test", "request-start", "request-start-desktop", "request-shadow",
@@ -1560 +1561 @@
             app.start_child_new_commands = []
             app.start_new_commands = []
         try:
-            conn, display_desc = connect()
+            if mode=="listen":
+                if extra_args:
+                    raise InitException("cannot specify extra arguments with 'listen' mode")
+                display_desc = {}
+                from xpra.platform import get_username
+                from xpra.net.socket_util import (
+                    get_network_logger, setup_local_sockets,
+                    create_sockets, add_listen_socket, accept_connection,
+                    )
+                netlog = get_network_logger()
+                sockets = create_sockets(opts, error_cb)
+                #we don't have a display,
+                #so we can't automatically create sockets:
+                if "auto" in opts.bind:
+                    opts.bind.remove("auto")
+                local_sockets = setup_local_sockets(opts.bind,
+                                                    opts.socket_dir, opts.socket_dirs,
+                                                    None, False,
+                                                    opts.mmap_group, opts.socket_permissions,
+                                                    get_username(), getuid, getgid)
+                sockets += local_sockets
+                saved_send_hello = app.send_hello
+                def new_connection(socktype, sock, *args):
+                    app.send_hello = saved_send_hello
+                    netlog.warn("new_connection%s", (socktype, sock, args))
+                    conn = accept_connection(socktype, sock)
+                    netlog.warn("accept_connection(%s, %s)=%s", socktype, sock, conn)
+                    app.setup_connection(conn)
+                    netlog.warn("saved_send_hello=%s", saved_send_hello)
+                    protocol = app._protocol
+                    protocol.start()
+                    app.send_hello()
+                saved_server_connection_established = app.server_connection_established
+                def server_connection_established():
+                    #TODO: close the other sockets and stop listening for new connections
+                    app.send_deflate_level()
+                    netlog.error("server_connection_established")
+                    return saved_server_connection_established()
+                app.server_connection_established = server_connection_established
+                for socktype, sock, info, cleanup_socket in sockets:
+                    add_listen_socket(socktype, sock, info, new_connection)
+                def noop(*_args):
+                    pass
+                app.send_hello = noop
+                conn = None
+            else:
+                conn, display_desc = connect()
             #UGLY warning: connect will parse the display string,
             #which may change the username and password..
             app.username = opts.username
@@ -1567 +1614 @@
             app.password = opts.password
             app.display = opts.display
             app.display_desc = display_desc
-            app.setup_connection(conn)
+            if conn:
+                app.setup_connection(conn)
         except Exception as e:
             may_notify = getattr(app, "may_notify", None)
             if may_notify:
@@ -2315 +2363 @@
         try:
             stat_info = os.stat(sockpath)
             if stat_info.st_uid==getuid():
-                os.unlink(sockpath)
+                #os.unlink(sockpath)
                 sys.stdout.write(" (cleaned up)")
+                import traceback
+                traceback.print_stack()
         except OSError as e:
             sys.stdout.write(" (delete failed: %s)" % e)
     sys.stdout.write("\n")

xpra/server/mixins/audio_server.py

@@ -234 +234 @@
                 log.warn(" the private pulseaudio directory containing it will not be removed")
             else:
                 pulse = os.path.join(self.pulseaudio_private_dir, "pulse")
+                #maybe remove this:
+                #dbus_socket = os.path.join(pulse, "dbus-1")
                 native = os.path.join(pulse, "native")
                 path = None
                 try:
@@ -253 +255 @@
                             soundlog.error(" found %i file%s in '%s':", len(files), engs(files), path)
                             for f in files:
                                 soundlog.error(" - '%s'", f)
+                                from subprocess import Popen, PIPE
+                                import sys
+                                Popen(["ls", "-laZ", os.path.join(path, f)], stdout=sys.stdout, stderr=sys.stderr)
+                                Popen(["lsof", os.path.join(path, f)], stdout=sys.stdout, stderr=sys.stderr)
                     except OSError:
                         pass