def __init__(self): log("ProxyServer.__init__()") ServerCore.__init__(self) self._max_connections = MAX_CONCURRENT_CONNECTIONS self._start_sessions = False self.session_type = "proxy" self.main_loop = None #proxy servers may have to connect to remote servers, #or even start them, so allow more time before timing out: self._accept_timeout += 10 self.pings = 0 self.video_encoders = () self._start_sessions = False #keep track of the proxy process instances #the display they're on and the message queue we can # use to communicate with them self.instances = {} #connections used exclusively for requests: self._requests = set() self.idle_add = glib.idle_add self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove self._socket_timeout = PROXY_SOCKET_TIMEOUT self._ws_timeout = PROXY_WS_TIMEOUT register_SIGUSR_signals(glib.idle_add)
def start(self): if not self.pipeline: log.error("cannot start") return register_SIGUSR_signals(self.idle_add) log("SoundPipeline.start() codec=%s", self.codec) self.idle_emit("new-stream", self.codec) self.update_state("active") self.pipeline.set_state(gst.State.PLAYING) if self.stream_compressor: self.info["stream-compressor"] = self.stream_compressor self.emit_info() #we may never get the stream start, synthesize codec event so we get logging: parts = self.codec.split("+") self.timeout_add(1000, self.new_codec_description, parts[0]) if len(parts) > 1 and parts[1] != self.stream_compressor: self.timeout_add(1000, self.new_container_description, parts[1]) elif self.container_format: self.timeout_add(1000, self.new_container_description, self.container_format) if self.stream_compressor: def logsc(): self.gstloginfo("using stream compression %s", self.stream_compressor) self.timeout_add(1000, logsc) log("SoundPipeline.start() done")
def signal_quit(self, signum, _frame=None): log.info("") log.info("proxy process pid %s got signal %s, exiting", os.getpid(), SIGNAMES.get(signum, signum)) signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) self.stop(None, SIGNAMES.get(signum, signum)) #from now on, we can't rely on the main loop: register_SIGUSR_signals()
def run(self): register_SIGUSR_signals(self.idle_add) client_protocol_class = get_client_protocol_class(self.client_conn.socktype) server_protocol_class = get_server_protocol_class(self.server_conn.socktype) self.client_protocol = client_protocol_class(self, self.client_conn, self.process_client_packet, self.get_client_packet) self.client_protocol.restore_state(self.client_state) self.server_protocol = server_protocol_class(self, self.server_conn, self.process_server_packet, self.get_server_packet) self.log_start() log("ProxyProcessProcess.run() pid=%s, uid=%s, gid=%s", os.getpid(), getuid(), getgid()) set_proc_title("Xpra Proxy Instance for %s" % self.server_conn) if POSIX and (getuid()!=self.uid or getgid()!=self.gid): #do we need a valid XDG_RUNTIME_DIR for the socket-dir? username = get_username_for_uid(self.uid) socket_dir = osexpand(self.socket_dir, username, self.uid, self.gid) if not os.path.exists(socket_dir): log("the socket directory '%s' does not exist, checking for $XDG_RUNTIME_DIR path", socket_dir) for prefix in ("/run/user/", "/var/run/user/"): if socket_dir.startswith(prefix): from xpra.scripts.server import create_runtime_dir xrd = os.path.join(prefix, str(self.uid)) #ie: /run/user/99 log("creating XDG_RUNTIME_DIR=%s for uid=%i, gid=%i", xrd, self.uid, self.gid) create_runtime_dir(xrd, self.uid, self.gid) break #change uid or gid: setuidgid(self.uid, self.gid) if self.env_options: #TODO: whitelist env update? os.environ.update(self.env_options) signal.signal(signal.SIGTERM, self.signal_quit) signal.signal(signal.SIGINT, self.signal_quit) log("registered signal handler %s", self.signal_quit) start_thread(self.server_message_queue, "server message queue") if not self.create_control_socket(): return self.control_socket_thread = start_thread(self.control_socket_loop, "control", daemon=True) self.main_queue = Queue() ProxyInstance.run(self) try: QueueScheduler.run(self) except KeyboardInterrupt as e: self.stop(None, str(e)) finally: log("ProxyProcess.run() ending %s", os.getpid())
def install_signal_handlers(self): def os_signal(signum, _frame=None): try: sys.stderr.write("\n") sys.stderr.flush() log.info("client got signal %s", SIGNAMES.get(signum, signum)) except Exception: pass self.handle_app_signal(signum) signal.signal(signal.SIGINT, os_signal) signal.signal(signal.SIGTERM, os_signal) register_SIGUSR_signals(self.idle_add)
def glib_init(self): #this will take care of calling threads_init if needed: from gi.repository import GLib register_SIGUSR_signals(GLib.idle_add)
def glib_init(self): #this will take care of calling threads_init if needed: from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() register_SIGUSR_signals(glib.idle_add)
def install_signal_handlers(self, callback): register_os_signals(callback) register_SIGUSR_signals(glib.idle_add)