Revert "Feat/run console commands"

Add run_console_command function

resolve #55

src/meshctrl/session.py

@@ -184,7 +184,7 @@ class Session(object):
     async def _listen_data_task(self, websocket):
         async for message in websocket:
             await self._eventer.emit("raw", message)
-            # Meshcentral does pong wrong and breaks our parsing, so fix it here. This is fixed now, but we want compatibility with old versions.
+            # Meshcentral does pong wrong and breaks our parsing, so fix it here.
             if message == '{action:"pong"}':
                 message = '{"action":"pong"}'
 
@@ -1473,7 +1473,7 @@ class Session(object):
                     return nid
 
         result = {n: {"complete": False, "result": [], "command": command} for n in nodeids}
-        async def _console():
+        async def _():
             async for event in self.events({"action": "msg", "type": "console"}):
                 node = match_nodeid(event["nodeid"], nodeids)
                 if node:
@@ -1485,58 +1485,34 @@ class Session(object):
                     elif (event["value"].startswith("Run commands")):
                         continue
                     result[node]["result"].append(event["value"])
-
-        # We create this task AFTER getting the first message, but I don't feel like implementing this twice, so we'll pass in the first message and have it parsed immediately
-        async def _reply(responseid, start_data=None):
-            # Returns True when all results are in, Falsey otherwise
-            def _parse_event(event):
-                node = match_nodeid(event["nodeid"], nodeids)
-                if node:
-                    result.setdefault(node, {})["complete"] = True
-                    result[node]["result"].append(event["result"])
-                    if all(_["complete"] for key, _ in result.items()):
-                        return True
-
-            if start_data is not None:
-                if _parse_event(start_data):
-                    return
-            async for event in self.events({"action": "msg", "type": "runcommands", "responseid": responseid}):
-                if _parse_event(event):
-                    break
-
-        async def __(command, tg, tasks):
+        async def __(command):
             data = await self._send_command(command, "run_command", timeout=timeout)
 
-            if data.get("type", None) != "runcommands" and data.get("result", "ok").lower() != "ok":
+            if data.get("result", "ok").lower() != "ok":
                 raise exceptions.ServerError(data["result"])
-            elif data.get("type", None) != "runcommands" and data.get("result", "ok").lower() == "ok":
-                expect_response = False
-                console_task = tg.create_task(asyncio.wait_for(_console(), timeout=timeout))
-                if not ignore_output:
-                    userid = (await self.user_info())["_id"]
-                    for n in nodeids:
-                        device_info = await self.device_info(n, timeout=timeout)
-                        try:
-                            permissions = device_info.mesh.links.get(userid, {}).get("rights",constants.DeviceRights.norights)\
-                            # This should work for device rights, but it only seems to work for mesh rights. Not sure why, but I can't get the events to show up when the user only has individual device rights
-                            # |device_info.get("links", {}).get(userid, {}).get("rights", constants.DeviceRights.norights)
-                            # If we don't have agentconsole rights, we won't be able te read the output, so fill in blanks on this node
-                            if not permissions&constants.DeviceRights.agentconsole:
-                                result[n]["complete"] = True
-                            else:
-                                expect_response = True
-                        except AttributeError:
-                            result[n]["complete"] = True
-                if expect_response:
-                    tasks.append(console_task)
-                else:
-                    console_task.cancel()
-            elif data.get("type", None) == "runcommands" and not ignore_output:
-                tasks.append(tg.create_task(asyncio.wait_for(_reply(data["responseid"], start_data=data), timeout=timeout)))
+        
+        expect_response = False
+        if not ignore_output:
+            userid = (await self.user_info())["_id"]
+            for n in nodeids:
+                device_info = await self.device_info(n, timeout=timeout)
+                try:
+                    permissions = device_info.mesh.links.get(userid, {}).get("rights",constants.DeviceRights.norights)\
+                    # This should work for device rights, but it only seems to work for mesh rights. Not sure why, but I can't get the events to show up when the user only has individual device rights
+                    # |device_info.get("links", {}).get(userid, {}).get("rights", constants.DeviceRights.norights)
+                    # If we don't have agentconsole rights, we won't be able te read the output, so fill in blanks on this node
+                    if not permissions&constants.DeviceRights.agentconsole:
+                        result[n]["complete"] = True
+                    else:
+                        expect_response = True
+                except AttributeError:
+                    result[n]["complete"] = True
 
         tasks = []
         async with asyncio.TaskGroup() as tg:
-            tasks.append(tg.create_task(__({ "action": 'runcommands', "nodeids": nodeids, "type": (2 if powershell else 0), "cmds": command, "runAsUser": runAsUser, "reply": not ignore_output}, tg, tasks)))
+            if expect_response:
+                tasks.append(tg.create_task(asyncio.wait_for(_(), timeout=timeout)))
+            tasks.append(tg.create_task(__({ "action": 'runcommands', "nodeids": nodeids, "type": (2 if powershell else 0), "cmds": command, "runAsUser": runAsUser })))
 
         return {n: v | {"result": "".join(v["result"])} for n,v in result.items()}
 

tests/environment/client.dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.13
+FROM python:3.12
 WORKDIR /usr/local/app
 
 # Install the application dependencies

tests/environment/meshcentral.dockerfile

@@ -1,8 +1,8 @@
-FROM ghcr.io/ylianst/meshcentral:1.1.50
+FROM ghcr.io/ylianst/meshcentral:latest
 RUN apk add curl
 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
-ENTRYPOINT ["python3", "/opt/meshcentral/scripts/create_users.py"]
+CMD ["python3", "/opt/meshcentral/scripts/create_users.py"]

tests/environment/scripts/meshcentral/create_users.py

@@ -7,9 +7,9 @@ thisdir = os.path.abspath(os.path.dirname(__file__))
 with open(os.path.join(thisdir, "users.json")) as infile:
     users = json.load(infile)
 for username, password in users.items():
-    print(subprocess.check_output(["node", "/opt/meshcentral/meshcentral", "--createaccount", username, "--pass", password, "--name", username]))
+    subprocess.check_output(["node", "/opt/meshcentral/meshcentral", "--createaccount", username, "--pass", password, "--name", username])
 
 
-print(subprocess.check_output(["node", "/opt/meshcentral/meshcentral", "--adminaccount", "admin"]))
+subprocess.check_output(["node", "/opt/meshcentral/meshcentral", "--adminaccount", "admin"])
 
-subprocess.call(["bash", "/opt/meshcentral/entrypoint.sh"])
+subprocess.call(["bash", "/opt/meshcentral/startup.sh"])

tests/test_sanity.py

@@ -9,7 +9,16 @@ import requests
 
 async def test_sanity(env):
     async with meshctrl.Session(env.mcurl, user="unprivileged", password=env.users["unprivileged"], ignore_ssl=True) as s:
+        got_pong = asyncio.Event()
+        async def _():
+            async for raw in s.raw_messages():
+                if raw == '{action:"pong"}':
+                    got_pong.set()
+                    break
+        ping_task = None
         async with asyncio.TaskGroup() as tg:
+            tg.create_task(asyncio.wait_for(_(), timeout=5))
+            tg.create_task(asyncio.wait_for(got_pong.wait(), timeout=5))
             ping_task = tg.create_task(s.ping(timeout=10))
         print("\ninfo ping: {}\n".format(ping_task.result()))
         print("\ninfo user_info: {}\n".format(await s.user_info()))

tests/test_session.py

@@ -251,15 +251,7 @@ async def test_mesh_device(env):
             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 missing device
-            try:
-                await admin_session.run_command([agent.nodeid, "notanid"], "ls", timeout=10)
-            except* (meshctrl.exceptions.ServerError, ValueError):
-                pass
-            else:
-                raise Exception("Run command on a device that doesn't exist did not raise an exception")
-
-            # Test run commands with individual device permissions
+            # Test run commands with ndividual device permissions
             try:
                 await unprivileged_session.run_command(agent.nodeid, "ls", timeout=10)
             except* (meshctrl.exceptions.ServerError, ValueError):
@@ -274,7 +266,7 @@ async def test_mesh_device(env):
             else:
                 raise Exception("Unprivileged user has access to device it should not")
 
-            assert (await admin_session.add_users_to_device((await unprivileged_session.user_info())["_id"], agent.nodeid, meshctrl.constants.DeviceRights.norights)), "Failed to add user to device"
+            assert (await admin_session.add_users_to_device((await unprivileged_session.user_info())["_id"], agent.nodeid, meshctrl.constants.MeshRights.norights)), "Failed to add user to device"
 
             try:
                 await unprivileged_session.run_command(agent.nodeid, "ls", ignore_output=True, timeout=10)
@@ -292,14 +284,12 @@ async def test_mesh_device(env):
 
             assert r.links[(await unprivileged_session.user_info())["_id"]]["rights"] == meshctrl.constants.DeviceRights.norights, "Unprivileged user has too many rights!"
 
-            assert (await admin_session.add_users_to_device([(await unprivileged_session.user_info())["_id"]], agent.nodeid, meshctrl.constants.DeviceRights.fullrights)), "Failed to modify user's permissions"
+            assert (await admin_session.add_users_to_device([(await unprivileged_session.user_info())["_id"]], agent.nodeid, meshctrl.constants.DeviceRights.remotecontrol|meshctrl.constants.DeviceRights.agentconsole|meshctrl.constants.DeviceRights.remotecommands)), "Failed to modify user's permissions"
 
-            assert (await unprivileged_session.device_info(agent.nodeid, timeout=10)).links[(await unprivileged_session.user_info())["_id"]]["rights"] == meshctrl.constants.DeviceRights.fullrights, "Adding permissions did not update unprivileged user."
+            assert (await unprivileged_session.device_info(agent.nodeid, timeout=10)).links[(await unprivileged_session.user_info())["_id"]]["rights"] == meshctrl.constants.DeviceRights.remotecontrol|meshctrl.constants.DeviceRights.agentconsole|meshctrl.constants.DeviceRights.remotecommands, "Adding permissions did not update unprivileged user."
 
-            # For now, this expects no response. If we ever figure out why the server isn't sending console information to us when it should, fix this.
+            # 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.
             # assert "meshagent" in (await unprivileged_session.run_command(agent.nodeid, "ls", timeout=10))[agent.nodeid]["result"], "ls gave incorrect data"
-            # Meshcentral has a 10 second cache on user perms.
-            #await asyncio.sleep(15)
             await unprivileged_session.run_command(agent.nodeid, "ls", timeout=10)
 
             assert await admin_session.move_to_device_group(agent.nodeid, mesh2.meshid, timeout=5), "Failed to move mesh to new device group"
@@ -313,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)