def close(self):
debug("close() closed=%s", self._closed)
if self._closed:
return
self._closed = True
self.scheduler.idle_add(self._process_packet_cb, self, [Protocol.CONNECTION_LOST])
if self._conn:
try:
self._conn.close()
if self._log_stats is None and self._conn.input_bytecount == 0 and self._conn.output_bytecount == 0:
# no data sent or received, skip logging of stats:
self._log_stats = False
if self._log_stats:
log.info(
"connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount),
std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount),
std_unit_dec(self._conn.output_bytecount),
)
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_queue_threads()
self.scheduler.idle_add(self.clean)
def close(self):
log("Protocol.close() closed=%s, connection=%s", self._closed,
self._conn)
if self._closed:
return
self._closed = True
self.idle_add(self._process_packet_cb, self,
[Protocol.CONNECTION_LOST])
c = self._conn
if c:
try:
log("Protocol.close() calling %s", c.close)
c.close()
if self._log_stats is None and self._conn.input_bytecount == 0 and self._conn.output_bytecount == 0:
#no data sent or received, skip logging of stats:
self._log_stats = False
if self._log_stats:
from xpra.simple_stats import std_unit, std_unit_dec
log.info(
"connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount),
std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount),
std_unit_dec(self._conn.output_bytecount))
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_queue_threads()
self.idle_add(self.clean)
log("Protocol.close() done")
def close(self):
log("Protocol.close() closed=%s, connection=%s", self._closed, self._conn)
if self._closed:
return
self._closed = True
self.idle_add(self._process_packet_cb, self, [Protocol.CONNECTION_LOST])
c = self._conn
if c:
try:
log("Protocol.close() calling %s", c.close)
c.close()
if self._log_stats is None and self._conn.input_bytecount==0 and self._conn.output_bytecount==0:
#no data sent or received, skip logging of stats:
self._log_stats = False
if self._log_stats:
from xpra.simple_stats import std_unit, std_unit_dec
log.info("connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount), std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount), std_unit_dec(self._conn.output_bytecount)
)
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_queue_threads()
self.idle_add(self.clean)
log("Protocol.close() done")
def populate_connection(self):
def settimedeltastr(label, from_time):
delta = datetime.timedelta(seconds=(int(time.time()) -
int(from_time)))
label.set_text(str(delta))
if self.client.server_load:
self.server_load_label.set_text(" ".join(
[str(x / 1000.0) for x in self.client.server_load]))
if self.client.server_start_time > 0:
settimedeltastr(self.session_started_label,
self.client.server_start_time)
else:
self.session_started_label.set_text("unknown")
settimedeltastr(self.session_connected_label, self.client.start_time)
p = self.client._protocol
c = p._conn
self.input_packets_label.set_text(std_unit_dec(p.input_packetcount))
self.input_bytes_label.set_text(std_unit_dec(c.input_bytecount))
self.output_packets_label.set_text(std_unit_dec(p.output_packetcount))
self.output_bytes_label.set_text(std_unit_dec(c.output_bytecount))
def get_sound_info(supported, prop):
if not supported:
return {"state": "disabled"}
if prop is None:
return {"state": "inactive"}
return prop.get_info()
def set_sound_info(label, details, supported, prop):
p = get_sound_info(supported, prop)
label.set_text(p.get("state", ""))
if details:
d = p.get("queue.used_pct", -1)
if d >= 0:
details.set_text(" (buffer: %s%%)" % str(d).rjust(3))
else:
details.set_text("")
set_sound_info(self.speaker_label, self.speaker_details,
self.client.speaker_enabled, self.client.sound_sink)
set_sound_info(self.microphone_label, None,
self.client.microphone_enabled,
self.client.sound_source)
self.connection_type_label.set_text(c.info)
self.compression_label.set_text(str(p._compression_level))
suffix = ""
if c.info.lower() == "ssh":
suffix = " (%s)" % c.info
self.input_encryption_label.set_text((p.cipher_in_name or "None") +
suffix)
self.output_encryption_label.set_text((p.cipher_out_name or "None") +
suffix)
return True
def populate_connection(self):
def settimedeltastr(label, from_time):
delta = datetime.timedelta(seconds=(int(time.time()) - int(from_time)))
label.set_text(str(delta))
if self.client.server_load:
self.server_load_label.set_text(" ".join([str(x / 1000.0) for x in self.client.server_load]))
if self.client.server_start_time > 0:
settimedeltastr(self.session_started_label, self.client.server_start_time)
else:
self.session_started_label.set_text("unknown")
settimedeltastr(self.session_connected_label, self.client.start_time)
p = self.client._protocol
c = p._conn
self.input_packets_label.set_text(std_unit_dec(p.input_packetcount))
self.input_bytes_label.set_text(std_unit_dec(c.input_bytecount))
self.output_packets_label.set_text(std_unit_dec(p.output_packetcount))
self.output_bytes_label.set_text(std_unit_dec(c.output_bytecount))
def get_sound_info(supported, prop):
if not supported:
return {"state": "disabled"}
if prop is None:
return {"state": "inactive"}
return prop.get_info()
def set_sound_info(label, details, supported, prop):
p = get_sound_info(supported, prop)
label.set_text(p.get("state", ""))
if details:
d = p.get("queue.used_pct", -1)
if d >= 0:
details.set_text(" (buffer: %s%%)" % str(d).rjust(3))
else:
details.set_text("")
set_sound_info(self.speaker_label, self.speaker_details, self.client.speaker_enabled, self.client.sound_sink)
set_sound_info(self.microphone_label, None, self.client.microphone_enabled, self.client.sound_source)
self.connection_type_label.set_text(c.info)
self.compression_label.set_text(str(p._compression_level))
suffix = ""
if c.info.lower() == "ssh":
suffix = " (%s)" % c.info
self.input_encryption_label.set_text((p.cipher_in_name or "None") + suffix)
self.output_encryption_label.set_text((p.cipher_out_name or "None") + suffix)
return True
def populate_table(self):
if self.table:
self.alignment.remove(self.table)
#remove expired requests:
now = monotonic_time()
self.requests = [x for x in self.requests if x[-1] > now]
self.expire_labels = {}
tb = TableBuilder(rows=1, columns=4, row_spacings=15)
#generate a new table:
self.table = tb.get_table()
if not self.requests:
tb.add_row(gtk.Label("No requests pending"))
else:
headers = [
gtk.Label("URL / Filename"),
gtk.Label(""),
gtk.Label("Expires in"),
gtk.Label("Action")
]
tb.add_row(*headers)
for cb_answer, send_id, dtype, url, filesize, printit, openit, expires in self.requests:
details = u""
if dtype == b"file" and filesize > 0:
details = u"%sB" % std_unit_dec(filesize)
expires_label = gtk.Label()
self.expire_labels[expires_label] = expires
buttons = self.action_buttons(cb_answer, send_id, dtype,
printit, openit)
items = (gtk.Label(bytestostr(url)), gtk.Label(details),
expires_label, buttons)
tb.add_row(*items)
self.update_expires_label()
self.alignment.add(self.table)
self.table.show_all()
def populate_form(self):
btn = link_btn("https://github.com/Xpra-org/xpra/blob/master/docs/Network/README.md",
label="Open Network Documentation", icon_name=None)
self.vbox.pack_start(btn, expand=True, fill=False, padding=20)
tb = self.table()
#"https://github.com/Xpra-org/xpra/blob/master/docs/Network/Multicast-DNS.md")
self.radio_cb_auto(tb, "Session Sharing", "sharing")
self.radio_cb_auto(tb, "Session Lock", "lock", "Prevent sessions from being taken over by new clients")
self.sep(tb)
self.bool_cb(tb, "Multicast DNS", "mdns", "Publish the session via mDNS")
self.bool_cb(tb, "Bandwidth Detection", "bandwidth-detection", "Automatically detect runtime bandwidth limits")
bwoptions = {
"auto" : "Auto",
}
for bwlimit in BANDWIDTH_MENU_OPTIONS:
if bwlimit<=0:
s = "None"
elif bwlimit>=10*1000*1000:
s = "%iMbps" % (bwlimit//(1000*1000))
else:
s = "%sbps" % std_unit_dec(bwlimit)
bwoptions[bwlimit] = s
self.combo(tb, "Bandwidth Limit", "bandwidth-limit", bwoptions)
#ssl options
#ssh=paramiko | plink
#exit-ssh
#Remote Logging
#open-files
#open-url
#file-size-limit
self.vbox.show_all()
def close(self):
if self._closed:
return
self._closed = True
scheduler.idle_add(self._process_packet_cb, self, [Protocol.CONNECTION_LOST])
if self._conn:
try:
self._conn.close()
log.info("connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount), std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount), std_unit_dec(self._conn.output_bytecount)
)
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_io_threads()
scheduler.idle_add(self.clean)
def close(self):
if self._closed:
return
self._closed = True
scheduler.idle_add(self._process_packet_cb, self,
[Protocol.CONNECTION_LOST])
if self._conn:
try:
self._conn.close()
log.info(
"connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount),
std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount),
std_unit_dec(self._conn.output_bytecount))
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_io_threads()
scheduler.idle_add(self.clean)
def close(self):
debug("close() closed=%s", self._closed)
if self._closed:
return
self._closed = True
self.scheduler.idle_add(self._process_packet_cb, self, [Protocol.CONNECTION_LOST])
if self._conn:
try:
self._conn.close()
if self._log_stats is None and self._conn.input_bytecount==0 and self._conn.output_bytecount==0:
#no data sent or received, skip logging of stats:
self._log_stats = False
if self._log_stats:
log.info("connection closed after %s packets received (%s bytes) and %s packets sent (%s bytes)",
std_unit(self.input_packetcount), std_unit_dec(self._conn.input_bytecount),
std_unit(self.output_packetcount), std_unit_dec(self._conn.output_bytecount)
)
except:
log.error("error closing %s", self._conn, exc_info=True)
self._conn = None
self.terminate_queue_threads()
self.scheduler.idle_add(self.clean)
def populate_table(self):
if self.table:
self.alignment.remove(self.table)
#remove expired requests:
now = monotonic_time()
self.requests = [x for x in self.requests if x[-1] > now]
self.expire_labels = {}
tb = TableBuilder(rows=1, columns=4, row_spacings=15)
def l(s=""):
return gtk.Label(s)
#generate a new table:
self.table = tb.get_table()
if not self.requests:
tb.add_row(l("No requests pending"))
else:
headers = [
l("URL / Filename"),
l(""),
l("Expires in"),
l("Action")
]
tb.add_row(*headers)
for cb_answer, send_id, dtype, url, filesize, printit, openit, expires in self.requests:
details = u""
if dtype == b"file" and filesize > 0:
details = u"%sB" % std_unit_dec(filesize)
expires_label = l()
self.expire_labels[expires_label] = expires
buttons = self.action_buttons(cb_answer, send_id, dtype,
printit, openit)
s = bytestostr(url)
main_label = l(s)
if dtype == b"url" and s.find("?") > 0 and len(s) > 48:
parts = s.split("?", 1)
main_label.set_label(parts[0] + "?..")
main_label.set_tooltip_text(s)
main_label.set_line_wrap(True)
try:
main_label.set_line_wrap_mode(pango.WrapMode.WORD_CHAR)
except AttributeError:
main_label.set_line_wrap_mode(pango.WRAP_WORD_CHAR)
main_label.set_size_request(URI_MAX_WIDTH, -1)
items = (main_label, l(details), expires_label, buttons)
tb.add_row(*items)
self.update_expires_label()
self.alignment.add(self.table)
self.table.show_all()
def populate_connection(self):
def settimedeltastr(label, from_time):
delta = datetime.timedelta(seconds=(int(time.time())-int(from_time)))
label.set_text(str(delta))
if self.client.server_load:
self.server_load_label.set_text(" ".join([str(x/1000.0) for x in self.client.server_load]))
if self.client.server_start_time>0:
settimedeltastr(self.session_started_label, self.client.server_start_time)
else:
self.session_started_label.set_text("unknown")
settimedeltastr(self.session_connected_label, self.client.start_time)
p = self.client._protocol
if p is None:
#no longer connected!
return False
c = p._conn
self.input_packets_label.set_text(std_unit_dec(p.input_packetcount))
self.input_bytes_label.set_text(std_unit_dec(c.input_bytecount))
self.output_packets_label.set_text(std_unit_dec(p.output_packetcount))
self.output_bytes_label.set_text(std_unit_dec(c.output_bytecount))
def get_sound_info(supported, prop):
if not supported:
return {"state" : "disabled"}
if prop is None:
return {"state" : "inactive"}
return prop.get_info()
def set_sound_info(label, details, supported, prop):
p = get_sound_info(supported, prop)
label.set_text(p.get("state", ""))
if details:
d = p.get("queue.used", -1)
if d>=0:
details.set_text(" (buffer: %sms)" % str(d).rjust(3))
else:
details.set_text("")
set_sound_info(self.speaker_label, self.speaker_details, self.client.speaker_enabled, self.client.sound_sink)
set_sound_info(self.microphone_label, None, self.client.microphone_enabled, self.client.sound_source)
self.connection_type_label.set_text(c.info)
protocol_info = p.get_info()
encoder = protocol_info.get("encoder", "bug")
compressor = protocol_info.get("compressor", "none")
level = protocol_info.get("compression_level", 0)
compression_str = encoder + " + "+compressor
if level>0:
compression_str += " (level %s)" % level
self.compression_label.set_text(compression_str)
def enclabel(label, cipher):
if not cipher:
info = "None"
else:
info = str(cipher)
if c.info.lower()=="ssh":
info += " (%s)" % c.info
if get_network_caps().get("pycrypto.fastmath", False):
info += " (fastmath available)"
label.set_text(info)
enclabel(self.input_encryption_label, p.cipher_in_name)
enclabel(self.output_encryption_label, p.cipher_out_name)
return True
def pixelstr(v):
if v<0:
return "n/a"
return std_unit_dec(v)
def populate_connection(self):
def settimedeltastr(label, from_time):
delta = datetime.timedelta(seconds=(int(time.time())-int(from_time)))
label.set_text(str(delta))
if self.client.server_load:
self.server_load_label.set_text(" ".join([str(x/1000.0) for x in self.client.server_load]))
if self.client.server_start_time>0:
settimedeltastr(self.session_started_label, self.client.server_start_time)
else:
self.session_started_label.set_text("unknown")
settimedeltastr(self.session_connected_label, self.client.start_time)
p = self.client._protocol
if p is None:
#no longer connected!
return False
c = p._conn
self.input_packets_label.set_text(std_unit_dec(p.input_packetcount))
self.input_bytes_label.set_text(std_unit_dec(c.input_bytecount))
self.output_packets_label.set_text(std_unit_dec(p.output_packetcount))
self.output_bytes_label.set_text(std_unit_dec(c.output_bytecount))
def get_sound_info(supported, prop):
if not supported:
return {"state" : "disabled"}
if prop is None:
return {"state" : "inactive"}
return prop.get_info()
def set_sound_info(label, details, supported, prop):
p = get_sound_info(supported, prop)
label.set_text(p.get("state", ""))
if details:
d = p.get("queue.used_pct", -1)
if d>=0:
details.set_text(" (buffer: %s%%)" % str(d).rjust(3))
else:
details.set_text("")
set_sound_info(self.speaker_label, self.speaker_details, self.client.speaker_enabled, self.client.sound_sink)
set_sound_info(self.microphone_label, None, self.client.microphone_enabled, self.client.sound_source)
self.connection_type_label.set_text(c.info)
protocol_info = p.get_info()
encoder = protocol_info.get("encoder", "bug")
compressor = protocol_info.get("compressor", "none")
level = protocol_info.get("compression_level", 0)
compression_str = encoder + " + "+compressor
if level>0:
compression_str += " (level %s)" % level
self.compression_label.set_text(compression_str)
def enclabel(label, cipher):
if not cipher:
info = "None"
else:
info = str(cipher)
if c.info.lower()=="ssh":
info += " (%s)" % c.info
if get_network_caps().get("pycrypto.fastmath", False):
info += " (fastmath available)"
label.set_text(info)
enclabel(self.input_encryption_label, p.cipher_in_name)
enclabel(self.output_encryption_label, p.cipher_out_name)
return True
def pixelstr(v):
if v<0:
return "n/a"
return std_unit_dec(v)
