def test_networkstate(self):
from xpra.server.source.networkstate_mixin import NetworkStateMixin
self._test_mixin_class(NetworkStateMixin)
x = NetworkStateMixin()
x.init_from(None, None)
x.init_state()
x.protocol = None
#x.ping()
x.check_ping_echo_timeout(0, 0)
def get_info(self):
info = {
"protocol": "xpra",
"connection_time": int(self.connection_time),
"elapsed_time": int(monotonic_time() - self.connection_time),
"counter": self.counter,
"hello-sent": self.hello_sent,
"bandwidth-limit": {
"setting": self.bandwidth_limit or 0,
"actual": self.soft_bandwidth_limit or 0,
}
}
p = self.protocol
if p:
info.update({
"connection": p.get_info(),
})
info.update(self.get_features_info())
merge_dicts(info, FilePrintMixin.get_info(self))
merge_dicts(info, AudioMixin.get_info(self))
merge_dicts(info, MMAP_Connection.get_info(self))
merge_dicts(info, NetworkStateMixin.get_info(self))
merge_dicts(info, ClientInfoMixin.get_info(self))
merge_dicts(info, WindowsMixin.get_info(self))
merge_dicts(info, EncodingsMixin.get_info(self))
merge_dicts(info, AVSyncMixin.get_info(self))
merge_dicts(info, ClientDisplayMixin.get_info(self))
merge_dicts(info, IdleMixin.get_info(self))
merge_dicts(info, ClipboardConnection.get_info(self))
return info
def test_networkstate(self):
with OSEnvContext():
os.environ["XPRA_PING_TIMEOUT"] = "1"
from xpra.server.mixins.networkstate_server import NetworkStateServer, MAX_BANDWIDTH_LIMIT, log, bandwidthlog
from xpra.server.source.networkstate_mixin import NetworkStateMixin
assert NetworkStateMixin.is_needed(typedict())
opts = AdHocStruct()
opts.pings = 1
opts.bandwidth_limit = "1Gbps"
#the limit for all clients:
capped_at = 1 * 1000 * 1000 * 1000 #=="1Gbps"
with silence_info(log):
self._test_mixin_class(NetworkStateServer, opts, {},
NetworkStateMixin)
self.assertEqual(capped_at,
self.mixin.get_info().get("bandwidth-limit"))
self.handle_packet(("ping", 10))
self.handle_packet(("ping", -1000))
self.handle_packet(("ping_echo", 10, 500, 500, 600, 10))
for v in (None, "foo", 1, 2.0, [], (), set()):
try:
self.handle_packet(("connection-data", v))
except TypeError:
pass
else:
raise Exception(
"should not allow %s (%s) as connection-data" %
(v, type(v)))
self.handle_packet(("connection-data", {}))
for v in (None, "foo", 2.0, [], (), set()):
try:
self.handle_packet(("bandwidth-limit", v))
except TypeError:
pass
else:
raise Exception(
"should not allow %s (%s) as connection-data" %
(v, type(v)))
with silence_info(bandwidthlog):
self.handle_packet(("bandwidth-limit", 10 * 1024 * 1024))
def get_limit():
return self.source.get_info().get("bandwidth-limit",
{}).get("setting", 0)
self.assertEqual(10 * 1024 * 1024, get_limit())
with silence_info(bandwidthlog):
self.handle_packet(
("bandwidth-limit", MAX_BANDWIDTH_LIMIT + 1))
self.assertEqual(min(capped_at, MAX_BANDWIDTH_LIMIT), get_limit())
#test source:
timeouts = []
def timeout(*args):
timeouts.append(args)
self.source.disconnect = timeout
assert self.source.get_caps()
self.source.ping()
self.source.check_ping_echo_timeout(0, 0)
#give time for the timeout to fire:
self.glib.timeout_add(2000, self.main_loop.quit)
self.main_loop.run()
def __init__(self, protocol, disconnect_cb, session_name, idle_add,
timeout_add, source_remove, setting_changed, idle_timeout,
socket_dir, unix_socket_paths, log_disconnect, dbus_control,
get_transient_for, get_focus, get_cursor_data_cb,
get_window_id, window_filters, file_transfer, supports_mmap,
mmap_filename, min_mmap_size, bandwidth_limit, av_sync,
core_encodings, encodings, default_encoding, scaling_control,
webcam_enabled, webcam_device, webcam_encodings,
sound_properties, sound_source_plugin, supports_speaker,
supports_microphone, speaker_codecs, microphone_codecs,
default_quality, default_min_quality, default_speed,
default_min_speed):
log("ServerSource%s",
(protocol, disconnect_cb, session_name, idle_add, timeout_add,
source_remove, setting_changed, idle_timeout, socket_dir,
unix_socket_paths, log_disconnect, dbus_control,
get_transient_for, get_focus, get_window_id, window_filters,
file_transfer, supports_mmap, mmap_filename, min_mmap_size,
bandwidth_limit, av_sync, core_encodings, encodings,
default_encoding, scaling_control, webcam_enabled, webcam_device,
webcam_encodings, sound_properties, sound_source_plugin,
supports_speaker, supports_microphone, speaker_codecs,
microphone_codecs, default_quality, default_min_quality,
default_speed, default_min_speed))
global counter
self.counter = counter.increase()
self.protocol = protocol
self.connection_time = monotonic_time()
self.close_event = Event()
self.session_name = session_name
AudioMixin.__init__(self, sound_properties, sound_source_plugin,
supports_speaker, supports_microphone,
speaker_codecs, microphone_codecs)
MMAP_Connection.__init__(self, supports_mmap, mmap_filename,
min_mmap_size)
ClipboardConnection.__init__(self)
FilePrintMixin.__init__(self, file_transfer)
NetworkStateMixin.__init__(self)
ClientInfoMixin.__init__(self)
DBUS_Mixin.__init__(self, dbus_control)
WindowsMixin.__init__(self, get_transient_for, get_focus,
get_cursor_data_cb, get_window_id,
window_filters)
EncodingsMixin.__init__(self, core_encodings, encodings,
default_encoding, scaling_control,
default_quality, default_min_quality,
default_speed, default_min_speed)
IdleMixin.__init__(self, idle_timeout)
InputMixin.__init__(self)
AVSyncMixin.__init__(self, av_sync)
ClientDisplayMixin.__init__(self)
WebcamMixin.__init__(self, webcam_enabled, webcam_device,
webcam_encodings)
self.ordinary_packets = []
self.disconnect = disconnect_cb
self.socket_dir = socket_dir
self.unix_socket_paths = unix_socket_paths
self.log_disconnect = log_disconnect
self.idle_add = idle_add
self.timeout_add = timeout_add
self.source_remove = source_remove
self.setting_changed = setting_changed
# network constraints:
self.server_bandwidth_limit = bandwidth_limit
#these statistics are shared by all WindowSource instances:
self.statistics = GlobalPerformanceStatistics()
self.init()
# ready for processing:
protocol.set_packet_source(self.next_packet)