Fixed connection errors not raising immediately

Fix #15

.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,7 @@
 Changelog
 =========
 
-Version 0.1
+Version 1.0.0
 ===========
 
-Create
+First release

README.rst

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

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
 
 

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"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)})"
+               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,
+                "http": self._session._proxy,
-                "https_proxy": 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:
+            if self._ssl_context is not None:
-                ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+                options["ssl"] = self._ssl_context
-                ssl_context.check_hostname = False
-                ssl_context.verify_mode = ssl.CERT_NONE
-                options = { "ssl": ssl_context }
 
             headers = websockets.datastructures.Headers()
 
@@ -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
+            await asyncio.gather(*[tunnel.close() for name, tunnel in self._file_tunnels.items()])
-        except asyncio.CancelledError:
+        finally:
-            pass
+            self._main_loop_task.cancel()
+            try:
+                await self._main_loop_task
+            except asyncio.CancelledError:
+                pass
 
     @util._check_socket
     async def __aenter__(self):
@@ -1819,7 +1824,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 +1844,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 +1898,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 +1928,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:
+            if self._session._ssl_context is not None:
-                options = { "ssl": self._ssl_context }
+                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)
 
@@ -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

@@ -140,17 +140,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:
+            await asyncio.wait_for(self.initialized.wait(), 10)
-                tg.create_task(asyncio.wait_for(self.initialized.wait(), 10))
+            await _check_errs(self)
-                tg.create_task(asyncio.wait_for(self._socket_open.wait(), 10))
+            await asyncio.wait_for(self._socket_open.wait(), 10)
         finally:
-            if not self.alive and self._main_loop_error is not None:
+            await _check_errs(self)
-                raise self._main_loop_error
-            elif not self.alive and self.initialized.is_set():
-                raise exceptions.SocketError("Socket Closed")
             return await f(self, *args, **kwargs)
     return wrapper
 

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):
@@ -77,6 +79,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:
@@ -278,7 +291,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 +421,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)