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)
