A bit of work towards supporting multiple backends + set the user age…

…nt's version properly

src/backends/librespeed.py

@@ -0,0 +1,114 @@
+import time
+import io
+import os
+import asyncio
+import aiohttp
+
+from urllib.parse import urljoin
+
+DOWNLOAD_SIZE = 100
+UPLOAD_SIZE = 20
+
+garbage = os.urandom(UPLOAD_SIZE * 1000 * 1000)
+
+class GarbageReader(io.IOBase):
+ def __init__(self, read_callback=None):
+ self.__read_callback = read_callback
+ super().__init__()
+ self.length = len(garbage)
+ self.pos = 0
+
+ def seekable(self):
+ return True
+
+ def writable(self):
+ return False
+
+ def readable(self):
+ return True
+
+ def tell(self):
+ return self.pos
+
+ def read(self, size=None):
+ if not size:
+ size = self.length - self.tell()
+
+ old_pos = self.tell()
+ self.pos = old_pos + size
+
+ if self.__read_callback:
+ self.__read_callback(size)
+
+ return garbage[old_pos:self.pos]
+
+class LibrespeedServer:
+ def __init__(self, name, server, pingURL, dlURL, ulURL, **_):
+ if not (server.startswith("https:") or server.startswith("http:")):
+ server = "https:" + server
+
+ self.name = name
+ self.server = server
+ self.pingURL = urljoin(server + "/", pingURL)
+ self.downloadURL = urljoin(server + "/", dlURL)
+ self.uploadURL = urljoin(server + "/", ulURL)
+
+class LibrespeedBackend:
+ def __init__(self, user_agent):
+ self.headers = {
+ "Accept-Encoding": "identity",
+ "User-Agent": user_agent,
+ }
+
+ async def get_servers(self):
+ async def check_server(server):
+ async with aiohttp.ClientSession() as session:
+ try:
+ start = time.time()
+ async with session.get(server.pingURL, timeout=aiohttp.ClientTimeout(total=0.75)) as _:
+ server.ping = time.time() - start # TODO: Don't mutate.
+ except (aiohttp.ClientError, asyncio.TimeoutError):
+ server.ping = -1
+
+ async with aiohttp.ClientSession() as session:
+ async with session.get("https://librespeed.org/backend-servers/servers.php") as response:
+ servers = await response.json()
+ servers = list(map(lambda x: LibrespeedServer(**x), servers)) 
+
+ await asyncio.gather(*[check_server(s) for s in servers])
+
+ servers = list(filter(lambda s: s.ping != -1, servers))
+
+ servers.sort(key=lambda s: s.ping)
+
+ return servers
+
+ async def ping(self, server):
+ async with aiohttp.ClientSession() as session:
+ pings = []
+ jitters = []
+ for i in range(10):
+ start = time.time()
+ async with session.get(server.pingURL, headers=self.headers) as _:
+ pings.append(time.time() - start)
+
+ if i != 0:
+ jitters.append(abs(pings[i] - pings[i - 1]))
+ return sum(pings) / len(pings) * 1000, sum(jitters) / len(jitters) * 1000
+
+ async def download(self, server, total):
+ async with aiohttp.ClientSession() as session:
+ while True:
+ async with session.get(server.downloadURL + "?ckSize=" + str(DOWNLOAD_SIZE), headers=self.headers) as response:
+ async for data in response.content.iter_any():
+ total[0] += len(data)
+
+ async def upload(self, server, total):
+ def callback(size):
+ total[0] += size
+
+ async with aiohttp.ClientSession() as session:
+ while True:
+ reader = GarbageReader(callback)
+ async with session.post(server.uploadURL, headers=self.headers, data=reader) as response:
+ await response.read()

src/main.py

@@ -11,13 +11,14 @@
 
 from .window import SpeedtestWindow
 from .gauge import Gauge # This class isn't used there but it the widget needs to be registered
-from .speedtest import get_servers
+from .backends.librespeed import LibrespeedBackend
 from .speedtest_worker import SpeedtestWorker
 
 class SpeedtestApplication(Adw.Application):
  def __init__(self, version):
  super().__init__(application_id="xyz.ketok.Speedtest", flags=Gio.ApplicationFlags.DEFAULT_FLAGS)
 
+ self.backend = LibrespeedBackend(f"KetokSpeedtest/{version}")
  self.servers = None
  self.win = None
  self.version = version
@@ -46,7 +47,7 @@ def fetch_servers(self):
  self.servers = []
  while len(self.servers) == 0: # A proper fix would probably be better but this works too
  print("Trying to fetch servers...")
- self.servers = event_loop.run_until_complete(get_servers())
+ self.servers = event_loop.run_until_complete(self.backend.get_servers())
 
  event_loop.close()
 
@@ -79,7 +80,7 @@ def on_start_action(self, widget, _):
  self.win.test_view.reset()
  self.win.test_view.server = server.name
 
- self.worker = SpeedtestWorker(self.win, server)
+ self.worker = SpeedtestWorker(self.backend, self.win, server)
  self.worker.start()
 
  def on_back_action(self, widget, _):

src/meson.build

@@ -42,9 +42,13 @@ configure_file(
 speedtest_sources = [
  'main.py',
  'window.py',
- 'speedtest.py',
  'gauge.py',
  'speedtest_worker.py',
 ]
 
+backends_sources = [
+ 'backends/librespeed.py',
+]
+
 install_data(speedtest_sources, install_dir: moduledir)
+install_data(backends_sources, install_dir: join_paths(moduledir, 'backends'))

src/speedtest_worker.py

@@ -4,18 +4,17 @@
 
 from gi.repository import GLib
 
-from .speedtest import ping, download, upload
-
 DURATION = 15
 DL_STREAMS = 6
 UP_STREAMS = 3
 OVERHEAD_COMPENSATION = 1.06
 
 class SpeedtestWorker(threading.Thread):
- def __init__(self, win, server):
+ def __init__(self, backend, win, server):
  super().__init__(name="SpeedtestWorker", daemon=True)
 
  self.stop_event = threading.Event()
+ self.backend = backend
  self.win = win
  self.server = server
 
@@ -47,23 +46,23 @@ async def do_run(self):
  try:
  view = self.win.test_view
 
- _ping, jitter = await ping(self.server)
+ ping, jitter = await self.backend.ping(self.server)
 
- GLib.idle_add(view.update_ping, _ping, jitter)
+ GLib.idle_add(view.update_ping, ping, jitter)
 
  GLib.idle_add(view.progress.remove_css_class, "up")
  GLib.idle_add(view.progress.add_css_class, "dl")
  GLib.idle_add(view.download.add_css_class, "active")
  timeout = GLib.timeout_add(1000 / 30, lambda: self.update(view.download, False))
- await self.perform_test(download, DL_STREAMS)
+ await self.perform_test(self.backend.download, DL_STREAMS)
  GLib.idle_add(view.download.remove_css_class, "active")
  GLib.source_remove(timeout)
 
  GLib.idle_add(view.progress.remove_css_class, "dl")
  GLib.idle_add(view.progress.add_css_class, "up")
  GLib.idle_add(view.upload.add_css_class, "active")
  timeout = GLib.timeout_add(1000 / 30, lambda: self.update(view.upload, True))
- await self.perform_test(upload, UP_STREAMS)
+ await self.perform_test(self.backend.upload, UP_STREAMS)
  GLib.idle_add(view.upload.remove_css_class, "active")
  GLib.source_remove(timeout)
  except Exception as e: