Updated to work with websockets 15 proxy handling

Hotfix/1.1.2

Fixes #35 

Update Cryptography version to fix SSL vulnerability.

.readthedocs.yml

@@ -19,7 +19,7 @@ formats:
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.11"
+    python: "3.13"
 
 python:
   install:

CHANGELOG.rst

@@ -2,7 +2,34 @@
 Changelog
 =========
 
-Version 0.1
-===========
+version 1.1.2
+=============
+Bugs:
+	* Fixed semver for requirements. New version of websockets broke this library.
 
-Create
+Security:
+	* Updated cryptogaphy to ~44.0.1 to fix ssl vulnerability.
+
+Version 1.1.1
+=============
+Bugs:
+	* Fixed bug when running device_info when user has access to multiple meshes
+
+Version 1.1.0
+=============
+Features:
+	* Added overrides for meshcentral files for testing purposes
+	* Added `users` field to `device` object
+
+Bugs:
+	* Fixed connection errors not raising immediately
+	* Fixed run_commands parsing return from multiple devices incorrectly
+	* Fixed listening to raw not removing its listener correctly
+	* Fixed javascript timecodes not being handled in gnu environments
+	* Changed some fstring formatting that locked the library into python >3.13
+
+
+Version 1.0.0
+=============
+
+First release

README.rst

@@ -38,7 +38,7 @@ Library for remotely interacting with a
 Installation
 ------------
 
-pip install meshctrl
+pip install libmeshctrl
 
 Usage
 -----

docs/requirements.txt

@@ -5,8 +5,8 @@ sphinx>=3.2.1
 sphinx-jinja2-compat>=0.1.1
 sphinx-toolbox>=2.16.0
 # sphinx_rtd_theme
-cffi==1.17.1
-cryptography==43.0.3
-pycparser==2.22
-websockets==13.1
+cffi~=1.17.1
+cryptography~=44.0.1
+pycparser~=2.22
+websockets~=15.0.0
 enum_tools

setup.cfg

@@ -24,7 +24,7 @@ platforms = any
 # Add here all kinds of additional classifiers as defined under
 # https://pypi.org/classifiers/
 classifiers =
-    Development Status :: 4 - Beta
+    Development Status :: 5 - Production/Stable
     Programming Language :: Python
 
 
@@ -44,9 +44,9 @@ python_requires = >=3.8
 # For more information, check out https://semver.org/.
 install_requires =
     importlib-metadata
-    cryptography>=43.0.3
-    websockets>=13.1
-    python-socks[asyncio]
+    cryptography~=44.0.1
+    websockets~=15.0.0
+    python-socks[asyncio]~=2.5.3
 
 
 [options.packages.find]

src/meshctrl/device.py

@@ -12,6 +12,7 @@ class Device(object):
         name (str|None): Device name as it is shown on the meshcentral server
         description (str|None): Device description as it is shown on the meshcentral server. Also accepted as desc.
         tags (list[str]|None): tags associated with device.
+        users (list[str]|None): latest known usernames which have logged in.
         created_at (datetime.Datetime|int|None): Time at which device mas created. Also accepted as agct.
         computer_name (str|None): Device name as reported from the agent. This may be different from name. Also accepted as rname.
         icon (~meshctrl.constants.Icon): Icon displayed on the website
@@ -38,6 +39,7 @@ class Device(object):
         name (str|None): Device name as it is shown on the meshcentral server
         description (str|None): Device description as it is shown on the meshcentral server.
         tags (list[str]): tags associated with device.
+        users (list[str]): latest known usernames which have logged in.
         computer_name (str|None): Device name as reported from the agent. This may be different from name. Also accepted as rname.
         icon (~meshctrl.constants.Icon): Icon displayed on the website
         mesh (~meshctrl.mesh.Mesh|None): Mesh object under which this device exists. Is None for individual device access.
@@ -54,11 +56,11 @@ class Device(object):
         links (dict[str, ~meshctrl.types.UserLink]|None): Collection of links for the device
         details (dict[str, dict]): Extra details about the device. These are not well defined, but are filled by calling :py:meth:`~meshctrl.session.Session.list_devices` with `details=True`.
     '''
-    def __init__(self, nodeid, session, agent=None, 
+    def __init__(self, nodeid, session, agent=None,
                        name=None, desc=None, description=None,
-                       tags=None,
+                       tags=None, users=None,
                        agct=None, created_at=None, 
-                       rname=None, computer_name=None, icon=constants.Icon.desktop, 
+                       rname=None, computer_name=None, icon=constants.Icon.desktop,
                        mesh=None, mtype=None, meshtype=None, groupname=None, meshname=None,
                        domain=None, host=None, ip=None, conn=None, connected=None,
                        pwr=None, powered_on=None,
@@ -90,13 +92,14 @@ class Device(object):
         self.description = description if description is not None else desc
         self.os_description = os_description if os_description is not None else osdesc
         self.tags = tags if tags is not None else []
+        self.users = users if users is not None else []
         self.details = details if details is not None else {}
 
         created_at = created_at if created_at is not None else agct
         if not isinstance(created_at, datetime.datetime) and created_at is not None:
             try:
                 created_at = datetime.datetime.fromtimestamp(created_at)
-            except OSError:
+            except (OSError, ValueError):
                 # Meshcentral returns in miliseconds, while fromtimestamp, and most of python, expects the argument in seconds. Try seconds frist, then translate from ms if it fails.
                 # This doesn't work for really early timestamps, but I don't expect that to be a problem here.
                 created_at = datetime.datetime.fromtimestamp(created_at/1000.0)
@@ -106,7 +109,7 @@ class Device(object):
         if not isinstance(lastconnect, datetime.datetime) and lastconnect is not None:
             try:
                 lastconnect = datetime.datetime.fromtimestamp(lastconnect)
-            except OSError:
+            except (OSError, ValueError):
                 # Meshcentral returns in miliseconds, while fromtimestamp, and most of python, expects the argument in seconds. Try seconds frist, then translate from ms if it fails.
                 # This doesn't work for really early timestamps, but I don't expect that to be a problem here.
                 lastconnect = datetime.datetime.fromtimestamp(lastconnect/1000.0)
@@ -129,7 +132,7 @@ class Device(object):
         Returns:
             bool: True on success, raise otherwise
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.ServerError`: Error text from server if there is a failure
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
@@ -147,7 +150,7 @@ class Device(object):
         Returns:
             bool: True on success, raise otherwise
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.ServerError`: Error text from server if there is a failure
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
@@ -166,7 +169,7 @@ class Device(object):
         Returns:
             bool: True on success, raise otherwise
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.ServerError`: Error text from server if there is a failure
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
@@ -183,7 +186,7 @@ class Device(object):
         Returns:
             ~meshctrl.device.Device: Object representing the state of the device. This will be a new device, it will not update this device.
 
-        Raises:    
+        Raises:
             ValueError: `Invalid device id` if device is not found
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
@@ -205,7 +208,7 @@ class Device(object):
         Returns:
             bool: True if successful, raise otherwise
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.ServerError`: Error text from server if there is a failure
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
@@ -227,7 +230,7 @@ class Device(object):
         Returns:
             ~meshctrl.types.RunCommandResponse: Output of command
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.ServerError`: Error text from server if there is a failure
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             ValueError: `Invalid device id` if device is not found
@@ -268,7 +271,7 @@ class Device(object):
         Returns:
             bool: True if successful
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
          '''
@@ -286,7 +289,7 @@ class Device(object):
         Returns:
             bool: True if successful
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
          '''
@@ -302,7 +305,7 @@ class Device(object):
         Returns:
             bool: True if successful
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
         '''
@@ -317,7 +320,7 @@ class Device(object):
         Returns:
             bool: True if successful
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
         '''
@@ -340,10 +343,10 @@ class Device(object):
     def __str__(self):
         return f"<Device: nodeid={self.nodeid} name={self.name} description={self.description} computer_name={self.computer_name} icon={self.icon} "\
                f"mesh={self.mesh} meshtype={self.meshtype} meshname={self.meshname} domain={self.domain} host={self.host} ip={self.ip} "\
-               f"tags={self.tags} details={self.details} created_at={self.created_at} lastaddr={self.lastaddr} lastconnect={self.lastconnect} "\
+               f"tags={self.tags} users={self.users} details={self.details} created_at={self.created_at} lastaddr={self.lastaddr} lastconnect={self.lastconnect} "\
                f"connected={self.connected} powered_on={self.powered_on} os_description={self.os_description} links={self.links} _extra_props={self._extra_props}>"
     def __repr__(self):
         return f"Device(nodeid={repr(self.nodeid)}, session={repr(self._session)}, name={repr(self.name)}, description={repr(self.description)}, computer_name={repr(self.computer_name)}, icon={repr(self.icon)}, "\
                f"mesh={repr(self.mesh)}, meshtype={repr(self.meshtype)}, meshname={repr(self.meshname)}, domain={repr(self.domain)}, host={repr(self.host)}, ip={repr(self.ip)}, "\
-               f"tags={repr(self.tags)}, details={repr(self.details)} created_at={repr(self.created_at)} lastaddr={repr(self.lastaddr)} lastconnect={repr(self.lastconnect)} "\
-               f"connected={repr(self.connected)}, powered_on={repr(self.powered_on)}, os_description={repr(self.os_description)}, links={repr(self.links)}, **{repr(self._extra_props)})"
+               f"tags={repr(self.tags)}, users={repr(self.users)}, details={repr(self.details)} created_at={repr(self.created_at)} lastaddr={repr(self.lastaddr)} lastconnect={repr(self.lastconnect)} "\
+               f"connected={repr(self.connected)}, powered_on={repr(self.powered_on)}, os_description={repr(self.os_description)}, links={repr(self.links)}, **{repr(self._extra_props)})"

src/meshctrl/exceptions.py

@@ -2,7 +2,9 @@ class MeshCtrlError(Exception):
     """
     Base class for Meshctrl errors
     """
-    pass
+    def __init__(self, message, *args, **kwargs):
+        self.message = message
+        super().__init__(message, *args, **kwargs)
 
 class ServerError(MeshCtrlError):
     """
@@ -25,6 +27,7 @@ class FileTransferError(MeshCtrlError):
     """
     def __init__(self, message, stats):
         self.stats = stats
+        super().__init__(message)
 
 class FileTransferCancelled(FileTransferError):
     """

src/meshctrl/files.py

@@ -4,9 +4,27 @@ from . import exceptions
 from . import util
 import asyncio
 import json
-import urllib
+import importlib
+import importlib.util
 import shutil
 
+# import urllib
+# import urllib.request
+import urllib.parse
+old_parse = urllib.parse
+# Default proxy handler uses OS defined no_proxy in order to be helpful. This is unhelpful for our usecase. Monkey patch out proxy getting functions, but don't effect the user's urllib instance.
+spec = importlib.util.find_spec('urllib')
+urllib = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(urllib)
+spec = importlib.util.find_spec('urllib.request')
+urllib.request = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(urllib.request)
+urllib.parse = old_parse
+urllib.request.getproxies_environment = lambda: {}
+urllib.request.getproxies_registry = lambda: {}
+urllib.request.getproxies_macosx_sysconf = lambda: {}
+urllib.request.getproxies = lambda: {}
+
 class Files(tunnel.Tunnel):
     def __init__(self, session, node):
         super().__init__(session, node.nodeid, constants.Protocol.FILES)
@@ -23,11 +41,12 @@ class Files(tunnel.Tunnel):
         if self._session._proxy is not None:
             # We don't know which protocol the user is going to use, but we only need support one at a time, so just assume both
             proxies = {
-                "http_proxy": self._session._proxy,
-                "https_proxy": self._session._proxy
+                "http": self._session._proxy,
+                "https": self._session._proxy,
+                "no": ""
             }
         self._proxy_handler = urllib.request.ProxyHandler(proxies=proxies)
-        self._http_opener = urllib.request.build_opener(self._proxy_handler, urllib.request.HTTPSHandler(context=self._ssl_context))
+        self._http_opener = urllib.request.build_opener(self._proxy_handler, urllib.request.HTTPSHandler(context=self._session._ssl_context))
 
 
     def _get_request_id(self):

src/meshctrl/mesh.py

@@ -31,7 +31,7 @@ class Mesh(object):
         domain (str|None): Domain on server to which device is connected.
         links (dict[str, ~meshctrl.types.UserLink]|None): Collection of links for the device group
     '''
-    def __init__(self, meshid, session, creation=None, created_at=None, name=None, 
+    def __init__(self, meshid, session, creation=None, created_at=None, name=None,
                        mtype=None, meshtype=None, creatorid=None, desc=None, description=None,
                        domain=None, creatorname=None, links=None, **kwargs):
         self.meshid = meshid
@@ -46,7 +46,7 @@ class Mesh(object):
         if not isinstance(created_at, datetime.datetime) and created_at is not None:
             try:
                 created_at = datetime.datetime.fromtimestamp(created_at)
-            except OSError:
+            except (OSError, ValueError):
                 # Meshcentral returns in miliseconds, while fromtimestamp, and most of python, expects the argument in seconds. Try seconds frist, then translate from ms if it fails.
                 # This doesn't work for really early timestamps, but I don't expect that to be a problem here.
                 created_at = datetime.datetime.fromtimestamp(created_at/1000.0)
@@ -83,7 +83,7 @@ class Mesh(object):
         Returns:
             dict[str, ~meshctrl.types.AddUsersToDeviceGroupResponse]: Object showing which were added correctly and which were not, along with their result messages. str is userid to map response.
 
-        Raises:    
+        Raises:
             :py:class:`~meshctrl.exceptions.SocketError`: Info about socket closure
             asyncio.TimeoutError: Command timed out
         '''
@@ -96,4 +96,4 @@ class Mesh(object):
     def __repr__(self):
         return f"Mesh(meshid={repr(self.meshid)}, session={repr(self._session)}, name={repr(self.name)},  description={repr(self.description)}, created_at={repr(self.created_at)}, "\
                f"meshtype={repr(self.meshtype)}, domain={repr(self.domain)}, "\
-               f"created_at={repr(self.created_at)}, creatorid={repr(self.creatorid)}, creatorname={repr(self.creatorname)}, links={repr(self.links)}, **{repr(self._extra_props)})"
+               f"created_at={repr(self.created_at)}, creatorid={repr(self.creatorid)}, creatorname={repr(self.creatorname)}, links={repr(self.links)}, **{repr(self._extra_props)})"

src/meshctrl/session.py

@@ -124,15 +124,17 @@ class Session(object):
         self._message_queue = asyncio.Queue()
         self._send_task = None
         self._listen_task = None
+        self._ssl_context = None
+        if self._ignore_ssl:
+            self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            self._ssl_context.check_hostname = False
+            self._ssl_context.verify_mode = ssl.CERT_NONE
 
     async def _main_loop(self):
         try:
             options = {}
-            if self._ignore_ssl:
-                ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-                ssl_context.check_hostname = False
-                ssl_context.verify_mode = ssl.CERT_NONE
-                options = { "ssl": ssl_context }
+            if self._ssl_context is not None:
+                options["ssl"] = self._ssl_context
 
             headers = websockets.datastructures.Headers()
 
@@ -142,7 +144,7 @@ class Session(object):
 
 
             options["additional_headers"] = headers
-            async for websocket in util.proxy_connect(self.url, proxy_url=self._proxy, process_exception=util._process_websocket_exception, **options):
+            async for websocket in websockets.asyncio.client.connect(self.url, proxy=self._proxy, process_exception=util._process_websocket_exception, **options):
                 self.alive = True
                 self._socket_open.set()
                 try:
@@ -215,11 +217,14 @@ class Session(object):
         return self._command_id
 
     async def close(self):
-        self._main_loop_task.cancel()
         try:
-            await self._main_loop_task
-        except asyncio.CancelledError:
-            pass
+            await asyncio.gather(*[tunnel.close() for name, tunnel in self._file_tunnels.items()])
+        finally:
+            self._main_loop_task.cancel()
+            try:
+                await self._main_loop_task
+            except asyncio.CancelledError:
+                pass
 
     @util._check_socket
     async def __aenter__(self):
@@ -528,7 +533,7 @@ class Session(object):
                 data = await event_queue.get()
                 yield data
         finally:
-            self._eventer.off("server_event", _)
+            self._eventer.off("raw", _)
 
     async def events(self, filter=None):
         '''
@@ -1358,10 +1363,10 @@ class Session(object):
                         node["meshid"] = meshid
                         if _mesh is not None:
                             node["mesh"] = _mesh
-                sysinfo["node"] = node
-                sysinfo["nodeid"] = nodeid
-                del sysinfo["result"]
-                del sysinfo["noinfo"]
+                        break
+                else:
+                    continue
+                break
         if node is None:
             raise ValueError("Invalid device id")
         if lastconnect is not None:
@@ -1458,6 +1463,7 @@ class Session(object):
                         result.setdefault(node, {})["complete"] = True
                         if all(_["complete"] for key, _ in result.items()):
                             break
+                        continue
                     elif (event["value"].startswith("Run commands")):
                         continue
                     result[node]["result"].append(event["value"])
@@ -1819,7 +1825,7 @@ class Session(object):
 
     async def upload(self, node, source, target, unique_file_tunnel=False, timeout=None):
         '''
-        Upload a stream to a device. This creates an _File and destroys it every call. If you need to upload multiple files, use {@link Session#file_explorer} instead.
+        Upload a stream to a device.
 
         Args:
             node (~meshctrl.device.Device|str): Device or id of device to which to upload the file. If it is a device, it must have a ~meshctrl.mesh.Mesh device associated with it (the default). If it is a string, the device will be fetched prior to tunnel creation.
@@ -1839,7 +1845,7 @@ class Session(object):
             node = await self.device_info(node)
         if unique_file_tunnel:
             async with self.file_explorer(node) as files:
-                return await files.upload(source, target)
+                return await files.upload(source, target, timeout=timeout)
         else:
             files = await self._cached_file_explorer(node, node.nodeid)
             return await files.upload(source, target, timeout=timeout)
@@ -1893,12 +1899,12 @@ class Session(object):
         start = target.tell()
         if unique_file_tunnel:
             async with self.file_explorer(node) as files:
-                await files.download(source, target)
+                await files.download(source, target, skip_http_attempt=skip_http_attempt, skip_ws_attempt=skip_ws_attempt, timeout=timeout)
                 target.seek(start)
                 return target
         else:
             files = await self._cached_file_explorer(node, node.nodeid)
-            await files.download(source, target, timeout=timeout)
+            await files.download(source, target, skip_http_attempt=skip_http_attempt, skip_ws_attempt=skip_ws_attempt, timeout=timeout)
             target.seek(start)
             return target
 
@@ -1923,7 +1929,7 @@ class Session(object):
             None
          '''
         with open(filepath, "wb") as f:
-            await self.download(node, source, f, unique_file_tunnel, timeout=timeout)
+            await self.download(node, source, f, skip_http_attempt=skip_http_attempt, skip_ws_attempt=skip_ws_attempt, unique_file_tunnel=unique_file_tunnel, timeout=timeout)
 
     async def _cached_file_explorer(self, node, _id):
         if (_id not in self._file_tunnels or not self._file_tunnels[_id].alive):

src/meshctrl/tunnel.py

@@ -27,11 +27,6 @@ class Tunnel(object):
         self._message_queue = asyncio.Queue()
         self._send_task = None
         self._listen_task = None
-        self._ssl_context = None
-        if self._session._ignore_ssl:
-            self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-            self._ssl_context.check_hostname = False
-            self._ssl_context.verify_mode = ssl.CERT_NONE
 
     async def close(self):
         self._main_loop_task.cancel()
@@ -53,11 +48,11 @@ class Tunnel(object):
             self._authcookie = await self._session._send_command_no_response_id({ "action":"authcookie" })
 
             options = {}
-            if self._ssl_context is not None:
-                options = { "ssl": self._ssl_context }
+            if self._session._ssl_context is not None:
+                options["ssl"] = self._session._ssl_context
 
             if (len(self.node_id.split('/')) != 3):
-                self.node_id = f"node/{self._session._currentDomain or ""}/{self.node_id}"
+                self.node_id = f"node/{self._session._currentDomain or ''}/{self.node_id}"
 
             self._tunnel_id = util._get_random_hex(6)
 
@@ -72,7 +67,7 @@ class Tunnel(object):
             self.url = self._session.url.replace('/control.ashx', '/meshrelay.ashx?browser=1&p=' + str(self._protocol) + '&nodeid=' + self.node_id + '&id=' + self._tunnel_id + '&auth=' + self._authcookie["cookie"])
 
 
-            async for websocket in util.proxy_connect(self.url, proxy_url=self._session._proxy, process_exception=util._process_websocket_exception, **options):
+            async for websocket in websockets.asyncio.client.connect(self.url, proxy=self._session._proxy, process_exception=util._process_websocket_exception, **options):
                 self.alive = True
                 self._socket_open.set()
                 try:
@@ -82,7 +77,6 @@ class Tunnel(object):
                 except* websockets.ConnectionClosed as e:
                     self._socket_open.clear()
                     if not self.auto_reconnect:
-                        self.alive = False
                         raise
         except* Exception as eg:
             self.alive = False
@@ -97,4 +91,4 @@ class Tunnel(object):
             await websocket.send(message)
 
     async def _listen_data_task(self, websocket):
-        raise NotImplementedError("Listen data not implemented")
+        raise NotImplementedError("Listen data not implemented")

src/meshctrl/util.py

@@ -11,7 +11,6 @@ import ssl
 import functools
 import urllib
 import python_socks
-from python_socks.async_.asyncio import Proxy
 from . import exceptions
 
 def _encode_cookie(o, key):
@@ -140,17 +139,20 @@ def compare_dict(dict1, dict2):
         return False
 
 def _check_socket(f):
+    async def _check_errs(self):
+        if not self.alive and self._main_loop_error is not None:
+            raise self._main_loop_error
+        elif not self.alive and self.initialized.is_set():
+            raise exceptions.SocketError("Socket Closed")
+
     @functools.wraps(f)
     async def wrapper(self, *args, **kwargs):
         try:
-            async with asyncio.TaskGroup() as tg:
-                tg.create_task(asyncio.wait_for(self.initialized.wait(), 10))
-                tg.create_task(asyncio.wait_for(self._socket_open.wait(), 10))
+            await asyncio.wait_for(self.initialized.wait(), 10)
+            await _check_errs(self)
+            await asyncio.wait_for(self._socket_open.wait(), 10)
         finally:
-            if not self.alive and self._main_loop_error is not None:
-                raise self._main_loop_error
-            elif not self.alive and self.initialized.is_set():
-                raise exceptions.SocketError("Socket Closed")
+            await _check_errs(self)
             return await f(self, *args, **kwargs)
     return wrapper
 
@@ -161,17 +163,7 @@ def _process_websocket_exception(exc):
         return exc
     if isinstance(exc, python_socks._errors.ProxyError):
         return None
-    return tmp
-
-class proxy_connect(websockets.asyncio.client.connect):
-    def __init__(self,*args, proxy_url=None, **kwargs):
-        self.proxy = None
-        if proxy_url is not None:
-            self.proxy = Proxy.from_url(proxy_url)
-        super().__init__(*args, **kwargs)
-
-    async def create_connection(self, *args, **kwargs):
-        if self.proxy is not None:
-            parsed = urllib.parse.urlparse(self.uri)
-            self.connection_kwargs["sock"] = await self.proxy.connect(dest_host=parsed.hostname, dest_port=parsed.port)
-        return await super().create_connection(*args, **kwargs)
+    # Proxy errors show up like this now, and it's default to error out. Handle explicitly.
+    if isinstance(exc, websockets.exceptions.InvalidProxyMessage):
+        return None
+    return tmp

tests/environment/__init__.py

@@ -62,7 +62,7 @@ class TestEnvironment(object):
             return self
         # Destroy the env in case it wasn't killed correctly last time.
         subprocess.check_call(["docker", "compose", "down"], stdout=subprocess.DEVNULL, cwd=thisdir)
-        self._subp = _docker_process = subprocess.Popen(["docker", "compose", "up", "--build", "--force-recreate", "--no-deps"], stdout=subprocess.DEVNULL, cwd=thisdir)
+        self._subp = _docker_process = subprocess.Popen(["docker", "compose", "up", "--build", "--force-recreate", "--no-deps"], cwd=thisdir)
         if not self._wait_for_meshcentral():
             self.__exit__(None, None, None)
             raise Exception("Failed to create docker instance")

tests/environment/config/meshcentral/overrides/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

tests/environment/meshcentral.dockerfile

@@ -4,4 +4,5 @@ RUN apk add python3
 WORKDIR /opt/meshcentral/
 COPY ./scripts/meshcentral ./scripts
 COPY ./config/meshcentral/data /opt/meshcentral/meshcentral-data
+COPY ./config/meshcentral/overrides /opt/meshcentral/meshcentral
 CMD ["python3", "/opt/meshcentral/scripts/create_users.py"]

tests/requirements.txt

@@ -1,6 +1,6 @@
 requests
 pytest-asyncio
 cffi==1.17.1
-cryptography==43.0.3
+cryptography~=44.0.1
 pycparser==2.22
-websockets==13.1
+websockets~=15.0.0

tests/test_files.py

@@ -53,6 +53,18 @@ async def test_commands(env):
         finally:
             assert (await admin_session.remove_device_group(mesh.meshid, timeout=10)), "Failed to remove device group"
 
+async def test_os_proxy_bypass():
+    os.environ["no_proxy"] = "*"
+    import urllib
+    import urllib.request
+    os_proxies = urllib.request.getproxies()
+    meshctrl_proxies = meshctrl.files.urllib.request.getproxies()
+    print(f"os_proxies: {os_proxies}")
+    print(f"meshctrl_proxies: {meshctrl_proxies}")
+    assert meshctrl_proxies.get("no", None) == None, "Meshctrl is using system proxies"
+    assert os_proxies.get("no", None) == "*", "System is using meshctrl proxies"
+    assert os_proxies != meshctrl_proxies, "Override didn't work"
+
 async def test_upload_download(env):
     async with meshctrl.Session("wss://" + env.dockerurl, user="admin", password=env.users["admin"], ignore_ssl=True, proxy=env.proxyurl) as admin_session:
         mesh = await admin_session.add_device_group("test", description="This is a test group", amtonly=False, features=0, consent=0, timeout=10)
@@ -70,7 +82,7 @@ async def test_upload_download(env):
                     else:
                         break
 
-                randdata = random.randbytes(2000000)
+                randdata = random.randbytes(20000000)
                 upfilestream = io.BytesIO(randdata)
                 downfilestream = io.BytesIO()
 
@@ -99,7 +111,7 @@ async def test_upload_download(env):
                     start = time.perf_counter()
                     r = await files.download(f"{pwd}/test", downfilestream, skip_ws_attempt=True, timeout=5)
                     print("\ninfo files_download: {}\n".format(r))
-                    assert r["result"] == True, "Domnload failed"
+                    assert r["result"] == True, "Download failed"
                     assert r["size"] == len(randdata), "Downloaded wrong number of bytes"
                     print(f"http download time: {time.perf_counter()-start}")
 
@@ -110,7 +122,7 @@ async def test_upload_download(env):
                     start = time.perf_counter()
                     r = await files.download(f"{pwd}/test", downfilestream, skip_http_attempt=True, timeout=5)
                     print("\ninfo files_download: {}\n".format(r))
-                    assert r["result"] == True, "Domnload failed"
+                    assert r["result"] == True, "Download failed"
                     assert r["size"] == len(randdata), "Downloaded wrong number of bytes"
                     print(f"ws download time: {time.perf_counter()-start}")
 

tests/test_session.py

@@ -5,6 +5,8 @@ import meshctrl
 import requests
 import random
 import io
+import traceback
+import time
 thisdir = os.path.dirname(os.path.realpath(__file__))
 
 async def test_admin(env):
@@ -44,9 +46,11 @@ async def test_auto_reconnect(env):
         for i in range(3):
             try:
                 await admin_session.ping(timeout=10)
-            except:
-                continue
-            break
+            except* Exception as e:
+                print("".join(traceback.format_exception(e)))
+                pass
+            else:
+                break
         else:
             raise Exception("Failed to reconnect")
 
@@ -55,6 +59,7 @@ async def test_auto_reconnect(env):
             try:
                 await admin_session.ping(timeout=10)
             except* Exception as e:
+                print("".join(traceback.format_exception(e)))
                 pass
             else:
                 break
@@ -77,6 +82,17 @@ async def test_users(env):
         pass
     else:
         raise Exception("Connected with no password")
+
+    start = time.time()
+    try:
+        async with meshctrl.Session(env.mcurl, user="admin", password="The wrong password", ignore_ssl=True) as admin_session:
+            pass
+    except* meshctrl.exceptions.ServerError as eg:
+        assert str(eg.exceptions[0]) == "Invalid Auth" or eg.exceptions[0].message == "Invalid Auth", "Didn't get invalid auth message"
+        assert time.time() - start < 10, "Invalid auth wasn't raised until after timeout"
+        pass
+    else:
+        raise Exception("Connected with bad password")
     async with meshctrl.Session(env.mcurl+"/", user="admin", password=env.users["admin"], ignore_ssl=True) as admin_session,\
                meshctrl.Session(env.mcurl, user="privileged", password=env.users["privileged"], ignore_ssl=True) as privileged_session,\
                meshctrl.Session(env.mcurl, user="unprivileged", password=env.users["unprivileged"], ignore_ssl=True) as unprivileged_session:
@@ -187,21 +203,24 @@ async def test_mesh_device(env):
 
         assert r[0].description == "New description", "Description either failed to change, or was changed by a user without permission to do so"
 
-        with env.create_agent(mesh.short_meshid) as agent:
+        # There once was a bug that occured whenever running run_commands with multiple meshes. We need to add devices to both meshes to be sure that bug is squashed.
+        with env.create_agent(mesh.short_meshid) as agent,\
+             env.create_agent(mesh.short_meshid) as agent2,\
+             env.create_agent(mesh2.short_meshid) as agent3:
             # Test agent added to device group being propagated correctly
             # Create agent isn't so good at waiting for the agent to show in the sessions. Give it a couple seconds to appear.
             for i in range(3):
                 try:
                     r = await admin_session.list_devices(timeout=10)
                     print("\ninfo list_devices: {}\n".format(r))
-                    assert len(r) == 1, "Incorrect number of agents connected"
+                    assert len(r) == 3, "Incorrect number of agents connected"
                 except:
                     if i == 2:
                         raise
                     await asyncio.sleep(1)
                 else:
                     break
-            assert len(await privileged_session.list_devices(timeout=10)) == 1, "Incorrect number of agents connected"
+            assert len(await privileged_session.list_devices(timeout=10)) == 2, "Incorrect number of agents connected"
             assert len(await unprivileged_session.list_devices(timeout=10)) == 0, "Unprivileged account has access to agent it should not"
 
             r = await admin_session.list_devices(details=True, timeout=10)
@@ -213,6 +232,9 @@ async def test_mesh_device(env):
             r = await admin_session.list_devices(meshid=mesh.meshid, timeout=10)
             print("\ninfo list_devices_meshid: {}\n".format(r))
 
+            r = await admin_session.device_info(agent.nodeid, timeout=10)
+            print("\ninfo admin_device_info: {}\n".format(r))
+
             # Test editing device info propagating correctly
             assert await admin_session.edit_device(agent.nodeid, name="new_name", description="New Description", tags="device", consent=meshctrl.constants.ConsentFlags.all, timeout=10), "Failed to edit device info"
 
@@ -221,9 +243,12 @@ async def test_mesh_device(env):
             assert await admin_session.edit_device(agent.nodeid, consent=meshctrl.constants.ConsentFlags.none, timeout=10), "Failed to edit device info"
 
             # Test run_commands
-            r = await admin_session.run_command(agent.nodeid, "ls", timeout=10)
+            r = await admin_session.run_command([agent.nodeid, agent2.nodeid], "ls", timeout=10)
             print("\ninfo run_command: {}\n".format(r))
             assert "meshagent" in r[agent.nodeid]["result"], "ls gave incorrect data"
+            assert "meshagent" in r[agent2.nodeid]["result"], "ls gave incorrect data"
+            assert "Run commands completed." not in r[agent.nodeid]["result"], "Didn't parse run command ending correctly"
+            assert "Run commands completed." not in r[agent2.nodeid]["result"], "Didn't parse run command ending correctly"
             assert "meshagent" in (await privileged_session.run_command(agent.nodeid, "ls", timeout=10))[agent.nodeid]["result"], "ls gave incorrect data"
 
             # Test run commands with ndividual device permissions
@@ -252,7 +277,7 @@ async def test_mesh_device(env):
 
             # Test getting individual device info
             r = await unprivileged_session.device_info(agent.nodeid, timeout=10)
-            print("\ninfo device_info: {}\n".format(r))
+            print("\ninfo unprivileged_device_info: {}\n".format(r))
 
             # This device info includes the mesh ID of the device, even though the user doesn't have acces to that mesh. That's odd.
             # assert r.meshid is None, "Individual device is exposing its meshid"
@@ -278,7 +303,7 @@ async def test_mesh_device(env):
 
             assert await admin_session.move_to_device_group([agent.nodeid], mesh.name, isname=True, timeout=5), "Failed to move mesh to new device group by name"
 
-            # For now, this expects no response. If we ever figure out why the server isn't sending console information te us when it should, fix this.
+            # For now, this expe namects no response. If we ever figure out why the server isn't sending console information te us when it should, fix this.
             # assert "meshagent" in (await unprivileged_session.run_command(agent.nodeid, "ls", timeout=10))[agent.nodeid]["result"], "ls gave incorrect data"
             try:
                 await unprivileged_session.run_command(agent.nodeid, "ls", timeout=10)
@@ -408,7 +433,7 @@ async def test_session_files(env):
                         break
                 pwd = (await admin_session.run_command(agent.nodeid, "pwd", timeout=10))[agent.nodeid]["result"].strip()
 
-                randdata = random.randbytes(2000000)
+                randdata = random.randbytes(20000000)
                 upfilestream = io.BytesIO(randdata)
                 downfilestream = io.BytesIO()
                 os.makedirs(os.path.join(thisdir, "data"), exist_ok=True)