Release 0.2.9

Get mesh version for settings.py

.dockerignore

@@ -0,0 +1,5 @@
+.git
+.cache
+**/*.env
+**/env
+**/node_modules

.github/workflows/docker-build-push.yml

@@ -0,0 +1,88 @@
+name: Publish Tactical Docker Images
+on:
+  push:
+    tags:
+      - "v*.*.*"
+jobs:
+  docker:
+    name: Build and Push Docker Images
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+        
+      - name: Get Github Tag
+        id: prep
+        run: |
+          echo ::set-output name=version::${GITHUB_REF#refs/tags/v}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+        
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+        
+      - name: Login to DockerHub
+        uses: docker/login-action@v1 
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+        
+      - name: Build and Push Tactical Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical:${{ steps.prep.outputs.version }},tacticalrmm/tactical:latest
+          
+      - name: Build and Push Tactical MeshCentral Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical-meshcentral/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical-meshcentral:${{ steps.prep.outputs.version }},tacticalrmm/tactical-meshcentral:latest
+          
+      - name: Build and Push Tactical NATS Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical-nats/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical-nats:${{ steps.prep.outputs.version }},tacticalrmm/tactical-nats:latest
+          
+      - name: Build and Push Tactical Salt Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical-salt/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical-salt:${{ steps.prep.outputs.version }},tacticalrmm/tactical-salt:latest
+          
+      - name: Build and Push Tactical Frontend Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical-frontend/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical-frontend:${{ steps.prep.outputs.version }},tacticalrmm/tactical-frontend:latest
+          
+      - name: Build and Push Tactical Nginx Image
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          pull: true
+          file: ./docker/containers/tactical-nginx/dockerfile
+          platforms: linux/amd64
+          tags: tacticalrmm/tactical-nginx:${{ steps.prep.outputs.version }},tacticalrmm/tactical-nginx:latest

.gitignore

@@ -34,6 +34,7 @@ app.ini
 create_services.py
 gen_random.py
 sync_salt_modules.py
+change_times.py
 rmm-*.exe
 rmm-*.ps1
 api/tacticalrmm/accounts/management/commands/*.json
@@ -41,3 +42,6 @@ api/tacticalrmm/accounts/management/commands/random_data.py
 versioninfo.go
 resource.syso
 htmlcov/
+docker-compose.dev.yml
+docs/.vuepress/dist
+nats-rmm.conf

.travis.yml

@@ -1,43 +0,0 @@
-dist: focal
-
-matrix:
-  include:
-    - language: node_js
-      node_js: "12"
-      before_install:
-        - cd web
-      install:
-        - npm install
-      script:
-        - npm run test:unit
-
-    - language: python
-      python: "3.8"
-      services:
-        - redis
-
-      addons:
-        postgresql: "13"
-        apt:
-          packages:
-            - postgresql-13
-
-      before_script:
-        - psql -c 'CREATE DATABASE travisci;' -U postgres
-        - psql -c "CREATE USER travisci WITH PASSWORD 'travisSuperSekret6645';" -U postgres
-        - psql -c 'GRANT ALL PRIVILEGES ON DATABASE travisci TO travisci;' -U postgres
-        - psql -c 'ALTER USER travisci CREATEDB;' -U postgres
-
-      before_install:
-        - cd api/tacticalrmm
-
-      install:
-        - pip install --no-cache-dir --upgrade pip
-        - pip install --no-cache-dir setuptools==49.6.0 wheel==0.35.1
-        - pip install --no-cache-dir -r requirements.txt -r requirements-test.txt
-
-      script:
-        - coverage run manage.py test -v 2
-
-      after_success:
-        - coveralls

.vscode/settings.json

@@ -2,7 +2,7 @@
     "python.pythonPath": "api/tacticalrmm/env/bin/python",
     "python.languageServer": "Pylance",
     "python.analysis.extraPaths": [
-        "api/tacticalrmm"
+        "api/tacticalrmm",
     ],
     "python.analysis.typeCheckingMode": "basic",
     "python.formatting.provider": "black",

README.md

@@ -1,6 +1,5 @@
 # Tactical RMM
 
-[![Build Status](https://travis-ci.com/wh1te909/tacticalrmm.svg?branch=develop)](https://travis-ci.com/wh1te909/tacticalrmm)
 [![Build Status](https://dev.azure.com/dcparsi/Tactical%20RMM/_apis/build/status/wh1te909.tacticalrmm?branchName=develop)](https://dev.azure.com/dcparsi/Tactical%20RMM/_build/latest?definitionId=4&branchName=develop)
 [![Coverage Status](https://coveralls.io/repos/github/wh1te909/tacticalrmm/badge.png?branch=develop&kill_cache=1)](https://coveralls.io/github/wh1te909/tacticalrmm?branch=develop)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
@@ -64,6 +63,7 @@ sudo ufw allow ssh
 sudo ufw allow http
 sudo ufw allow https
 sudo ufw allow proto tcp from any to any port 4505,4506
+sudo ufw allow proto tcp from any to any port 4222
 sudo ufw enable && sudo ufw reload
 ```
 
@@ -78,7 +78,7 @@ Create A record ```mesh.tacticalrmm.com``` for meshcentral
 Download the install script and run it
 
 ```
-wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/install.sh
+wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/install.sh
 chmod +x install.sh
 ./install.sh
 ```
@@ -92,17 +92,17 @@ chmod +x install.sh
 From the app's dashboard, choose Agents > Install Agent to generate an installer.
 
 ## Updating
-Download and run [update.sh](./update.sh) ([Raw](https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/update.sh))
+Download and run [update.sh](https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/update.sh)
 ```
-wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/update.sh
+wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/update.sh
 chmod +x update.sh
 ./update.sh
 ```
 
 ## Backup
-Download [backup.sh](./backup.sh) ([Raw](https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/backup.sh))
+Download [backup.sh](https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/backup.sh)
 ```
-wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/backup.sh
+wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/backup.sh
 ```
 Change the postgres username and password at the top of the file (you can find them in `/rmm/api/tacticalrmm/tacticalrmm/local_settings.py` under the DATABASES section)
 
@@ -121,7 +121,7 @@ Copy backup file to new server
 
 Download the restore script, and edit the postgres username/password at the top of the file. Same instructions as above in the backup steps.
 ```
-wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/develop/restore.sh
+wget https://raw.githubusercontent.com/wh1te909/tacticalrmm/master/restore.sh
 ```
 
 Run the restore script, passing it the backup tar file as the first argument
@@ -129,14 +129,3 @@ Run the restore script, passing it the backup tar file as the first argument
 chmod +x restore.sh
 ./restore.sh rmm-backup-xxxxxxx.tar
 ```
-
-## Using another ssl certificate
-During the install you can opt out of using the Let's Encrypt certificate. If you do this the script will create a self-signed certificate, so that https continues to work. You can replace the certificates in /certs/example.com/(privkey.pem | pubkey.pem) with your own. 
-
-If you are migrating from Let's Encrypt to another certificate provider, you can create the /certs directory and copy your certificates there. It is recommended to do this because this directory will be backed up with the backup script provided. Then modify the nginx configurations to use your new certificates
-
-The cert that is generated is a wildcard certificate and is used in the nginx configurations: rmm.conf, api.conf, and mesh.conf. If you can't generate wildcard certificates you can create a cert for each subdomain and configure each nginx configuration file to use its own certificate. Then restart nginx:
-
-```
-sudo systemctl restart nginx
-```

api/tacticalrmm/.coveragerc

@@ -20,6 +20,5 @@ omit =
     */urls.py
     */tests.py
     */test.py
-    api/*.py
     checks/utils.py
     

api/tacticalrmm/accounts/migrations/0006_user_agent.py

@@ -0,0 +1,26 @@
+# Generated by Django 3.1.2 on 2020-11-10 20:24
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("agents", "0024_auto_20201101_2319"),
+        ("accounts", "0005_auto_20201002_1303"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="user",
+            name="agent",
+            field=models.OneToOneField(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="user",
+                to="agents.agent",
+            ),
+        ),
+    ]

api/tacticalrmm/accounts/migrations/0007_update_agent_primary_key.py

@@ -0,0 +1,25 @@
+# Generated by Django 3.1.2 on 2020-11-01 22:54
+
+from django.db import migrations
+
+
+def link_agents_to_users(apps, schema_editor):
+    Agent = apps.get_model("agents", "Agent")
+    User = apps.get_model("accounts", "User")
+    for agent in Agent.objects.all():
+        user = User.objects.filter(username=agent.agent_id).first()
+
+        if user:
+            user.agent = agent
+            user.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("accounts", "0006_user_agent"),
+    ]
+
+    operations = [
+        migrations.RunPython(link_agents_to_users, migrations.RunPython.noop),
+    ]

api/tacticalrmm/accounts/migrations/0008_user_dark_mode.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.3 on 2020-11-12 00:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('accounts', '0007_update_agent_primary_key'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='user',
+            name='dark_mode',
+            field=models.BooleanField(default=True),
+        ),
+    ]

api/tacticalrmm/accounts/models.py

@@ -7,6 +7,15 @@ from logs.models import BaseAuditModel
 class User(AbstractUser, BaseAuditModel):
     is_active = models.BooleanField(default=True)
     totp_key = models.CharField(max_length=50, null=True, blank=True)
+    dark_mode = models.BooleanField(default=True)
+
+    agent = models.OneToOneField(
+        "agents.Agent",
+        related_name="user",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
 
     @staticmethod
     def serialize(user):

api/tacticalrmm/accounts/tests.py

@@ -195,6 +195,14 @@ class TestUserAction(TacticalTestCase):
 
         self.check_not_authenticated("put", url)
 
+    def test_darkmode(self):
+        url = "/accounts/users/ui/"
+        data = {"dark_mode": False}
+        r = self.client.patch(url, data, format="json")
+        self.assertEqual(r.status_code, 200)
+
+        self.check_not_authenticated("patch", url)
+
 
 class TestTOTPSetup(TacticalTestCase):
     def setUp(self):

api/tacticalrmm/accounts/urls.py

@@ -7,4 +7,5 @@ urlpatterns = [
     path("users/reset/", views.UserActions.as_view()),
     path("users/reset_totp/", views.UserActions.as_view()),
     path("users/setup_totp/", views.TOTPSetup.as_view()),
+    path("users/ui/", views.UserUI.as_view()),
 ]

api/tacticalrmm/accounts/views.py

@@ -74,8 +74,7 @@ class LoginView(KnoxLoginView):
 
 class GetAddUsers(APIView):
     def get(self, request):
-        agents = Agent.objects.values_list("agent_id", flat=True)
-        users = User.objects.exclude(username__in=agents)
+        users = User.objects.filter(agent=None)
 
         return Response(UserSerializer(users, many=True).data)
 
@@ -157,3 +156,11 @@ class TOTPSetup(APIView):
             return Response(TOTPSetupSerializer(user).data)
 
         return Response("totp token already set")
+
+
+class UserUI(APIView):
+    def patch(self, request):
+        user = request.user
+        user.dark_mode = request.data["dark_mode"]
+        user.save(update_fields=["dark_mode"])
+        return Response("ok")

api/tacticalrmm/agents/baker_recipes.py

@@ -1,14 +1,35 @@
-from .models import Agent
+import random
+import string
+import os
+import json
+
 from model_bakery.recipe import Recipe, seq
 from itertools import cycle
 from django.utils import timezone as djangotime
+from django.conf import settings
+
+from .models import Agent
+
+
+def generate_agent_id(hostname):
+    rand = "".join(random.choice(string.ascii_letters) for _ in range(35))
+    return f"{rand}-{hostname}"
+
+
+def get_wmi_data():
+    with open(
+        os.path.join(settings.BASE_DIR, "tacticalrmm/test_data/wmi_python_agent.json")
+    ) as f:
+        return json.load(f)
+
 
 agent = Recipe(
     Agent,
-    client="Default",
-    site="Default",
-    hostname=seq("TestHostname"),
+    hostname="DESKTOP-TEST123",
+    version="1.1.1",
     monitoring_type=cycle(["workstation", "server"]),
+    salt_id=generate_agent_id("DESKTOP-TEST123"),
+    agent_id="71AHC-AA813-HH1BC-AAHH5-00013|DESKTOP-TEST123",
 )
 
 server_agent = agent.extend(
@@ -49,3 +70,5 @@ agent_with_services = agent.extend(
         },
     ],
 )
+
+agent_with_wmi = agent.extend(wmi=get_wmi_data())

api/tacticalrmm/agents/migrations/0021_agent_site_link.py

@@ -0,0 +1,20 @@
+# Generated by Django 3.1.2 on 2020-11-01 22:53
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('clients', '0006_deployment'),
+        ('agents', '0020_auto_20201025_2129'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='agent',
+            name='site_link',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='agents', to='clients.site'),
+        ),
+    ]

api/tacticalrmm/agents/migrations/0022_update_site_primary_key.py

@@ -0,0 +1,31 @@
+# Generated by Django 3.1.2 on 2020-11-01 22:54
+
+from django.db import migrations
+
+
+def link_sites_to_agents(apps, schema_editor):
+    Agent = apps.get_model("agents", "Agent")
+    Site = apps.get_model("clients", "Site")
+    for agent in Agent.objects.all():
+        site = Site.objects.get(client__client=agent.client, site=agent.site)
+        agent.site_link = site
+        agent.save()
+
+
+def reverse(apps, schema_editor):
+    Agent = apps.get_model("agents", "Agent")
+    for agent in Agent.objects.all():
+        agent.site = agent.site_link.site
+        agent.client = agent.site_link.client.client
+        agent.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("agents", "0021_agent_site_link"),
+    ]
+
+    operations = [
+        migrations.RunPython(link_sites_to_agents, reverse),
+    ]

api/tacticalrmm/agents/migrations/0023_auto_20201101_2312.py

@@ -0,0 +1,21 @@
+# Generated by Django 3.1.2 on 2020-11-01 23:12
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('agents', '0022_update_site_primary_key'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='agent',
+            name='client',
+        ),
+        migrations.RemoveField(
+            model_name='agent',
+            name='site',
+        ),
+    ]

api/tacticalrmm/agents/migrations/0024_auto_20201101_2319.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.2 on 2020-11-01 23:19
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('agents', '0023_auto_20201101_2312'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='agent',
+            old_name='site_link',
+            new_name='site',
+        ),
+    ]

api/tacticalrmm/agents/migrations/0025_auto_20201122_0407.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.3 on 2020-11-22 04:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('agents', '0024_auto_20201101_2319'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='recoveryaction',
+            name='mode',
+            field=models.CharField(choices=[('salt', 'Salt'), ('mesh', 'Mesh'), ('command', 'Command'), ('rpc', 'Nats RPC')], default='mesh', max_length=50),
+        ),
+    ]

api/tacticalrmm/agents/migrations/0026_auto_20201125_2334.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.3 on 2020-11-25 23:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('agents', '0025_auto_20201122_0407'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='recoveryaction',
+            name='mode',
+            field=models.CharField(choices=[('salt', 'Salt'), ('mesh', 'Mesh'), ('command', 'Command'), ('rpc', 'Nats RPC'), ('checkrunner', 'Checkrunner')], default='mesh', max_length=50),
+        ),
+    ]

api/tacticalrmm/agents/models.py

@@ -1,5 +1,4 @@
 import requests
-import datetime as dt
 import time
 import base64
 from Crypto.Cipher import AES
@@ -7,13 +6,14 @@ from Crypto.Random import get_random_bytes
 from Crypto.Hash import SHA3_384
 from Crypto.Util.Padding import pad
 import validators
-import random
+import msgpack
 import re
-import string
 from collections import Counter
 from loguru import logger
 from packaging import version as pyver
 from distutils.version import LooseVersion
+from nats.aio.client import Client as NATS
+from nats.aio.errors import ErrTimeout
 
 from django.db import models
 from django.conf import settings
@@ -44,9 +44,7 @@ class Agent(BaseAuditModel):
     boot_time = models.FloatField(null=True, blank=True)
     logged_in_username = models.CharField(null=True, blank=True, max_length=255)
     last_logged_in_user = models.CharField(null=True, blank=True, max_length=255)
-    client = models.CharField(max_length=200)
     antivirus = models.CharField(default="n/a", max_length=255)  # deprecated
-    site = models.CharField(max_length=150)
     monitoring_type = models.CharField(max_length=30)
     description = models.CharField(null=True, blank=True, max_length=255)
     mesh_node_id = models.CharField(null=True, blank=True, max_length=255)
@@ -62,6 +60,13 @@ class Agent(BaseAuditModel):
         max_length=255, choices=TZ_CHOICES, null=True, blank=True
     )
     maintenance_mode = models.BooleanField(default=False)
+    site = models.ForeignKey(
+        "clients.Site",
+        related_name="agents",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
     policy = models.ForeignKey(
         "automation.Policy",
         related_name="agents",
@@ -73,6 +78,18 @@ class Agent(BaseAuditModel):
     def __str__(self):
         return self.hostname
 
+    @property
+    def client(self):
+        return self.site.client
+
+    @property
+    def has_nats(self):
+        return pyver.parse(self.version) >= pyver.parse("1.1.0")
+
+    @property
+    def has_gotasks(self):
+        return pyver.parse(self.version) >= pyver.parse("1.1.1")
+
     @property
     def timezone(self):
         # return the default timezone unless the timezone is explicity set per agent
@@ -86,27 +103,35 @@ class Agent(BaseAuditModel):
     @property
     def arch(self):
         if self.operating_system is not None:
-            if "64bit" in self.operating_system:
+            if "64 bit" in self.operating_system or "64bit" in self.operating_system:
                 return "64"
-            elif "32bit" in self.operating_system:
+            elif "32 bit" in self.operating_system or "32bit" in self.operating_system:
                 return "32"
-        return "64"
+        return None
 
     @property
     def winagent_dl(self):
-        return settings.DL_64 if self.arch == "64" else settings.DL_32
+        if self.arch == "64":
+            return settings.DL_64
+        elif self.arch == "32":
+            return settings.DL_32
+        return None
 
     @property
     def winsalt_dl(self):
-        return settings.SALT_64 if self.arch == "64" else settings.SALT_32
+        if self.arch == "64":
+            return settings.SALT_64
+        elif self.arch == "32":
+            return settings.SALT_32
+        return None
 
     @property
     def win_inno_exe(self):
-        return (
-            f"winagent-v{settings.LATEST_AGENT_VER}.exe"
-            if self.arch == "64"
-            else f"winagent-v{settings.LATEST_AGENT_VER}-x86.exe"
-        )
+        if self.arch == "64":
+            return f"winagent-v{settings.LATEST_AGENT_VER}.exe"
+        elif self.arch == "32":
+            return f"winagent-v{settings.LATEST_AGENT_VER}-x86.exe"
+        return None
 
     @property
     def status(self):
@@ -125,11 +150,7 @@ class Agent(BaseAuditModel):
 
     @property
     def has_patches_pending(self):
-
-        if self.winupdates.filter(action="approve").filter(installed=False).exists():
-            return True
-        else:
-            return False
+        return self.winupdates.filter(action="approve").filter(installed=False).exists()
 
     @property
     def checks(self):
@@ -273,11 +294,9 @@ class Agent(BaseAuditModel):
 
     # returns agent policy merged with a client or site specific policy
     def get_patch_policy(self):
-        from clients.models import Client, Site
 
         # check if site has a patch policy and if so use it
-        client = Client.objects.get(client=self.client)
-        site = Site.objects.get(client=client, site=self.site)
+        site = self.site
         core_settings = CoreSettings.objects.first()
         patch_policy = None
         agent_policy = self.winupdatepolicy.get()
@@ -418,6 +437,37 @@ class Agent(BaseAuditModel):
         except Exception:
             return "err"
 
+    async def nats_cmd(self, data, timeout=30, wait=True):
+        nc = NATS()
+        options = {
+            "servers": f"tls://{settings.ALLOWED_HOSTS[0]}:4222",
+            "user": "tacticalrmm",
+            "password": settings.SECRET_KEY,
+            "connect_timeout": 3,
+            "max_reconnect_attempts": 2,
+        }
+        try:
+            await nc.connect(**options)
+        except:
+            return "natsdown"
+
+        if wait:
+            try:
+                msg = await nc.request(
+                    self.agent_id, msgpack.dumps(data), timeout=timeout
+                )
+            except ErrTimeout:
+                ret = "timeout"
+            else:
+                ret = msgpack.loads(msg.data)
+
+            await nc.close()
+            return ret
+        else:
+            await nc.publish(self.agent_id, msgpack.dumps(data))
+            await nc.flush()
+            await nc.close()
+
     def salt_api_cmd(self, **kwargs):
 
         # salt should always timeout first before the requests' timeout
@@ -496,6 +546,7 @@ class Agent(BaseAuditModel):
 
         ret = AgentEditSerializer(agent).data
         del ret["all_timezones"]
+        del ret["client"]
         return ret
 
     @staticmethod
@@ -524,64 +575,6 @@ class Agent(BaseAuditModel):
 
         return resp
 
-    def schedule_reboot(self, obj):
-
-        start_date = dt.datetime.strftime(obj, "%Y-%m-%d")
-        start_time = dt.datetime.strftime(obj, "%H:%M")
-
-        # let windows task scheduler automatically delete the task after it runs
-        end_obj = obj + dt.timedelta(minutes=15)
-        end_date = dt.datetime.strftime(end_obj, "%Y-%m-%d")
-        end_time = dt.datetime.strftime(end_obj, "%H:%M")
-
-        task_name = "TacticalRMM_SchedReboot_" + "".join(
-            random.choice(string.ascii_letters) for _ in range(10)
-        )
-
-        r = self.salt_api_cmd(
-            timeout=15,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Windows\\System32\\shutdown.exe"',
-                'arguments="/r /t 5 /f"',
-                "trigger_type=Once",
-                f'start_date="{start_date}"',
-                f'start_time="{start_time}"',
-                f'end_date="{end_date}"',
-                f'end_time="{end_time}"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-                "delete_after=Immediately",
-            ],
-        )
-
-        if r == "error" or (isinstance(r, bool) and not r):
-            return "failed"
-        elif r == "timeout":
-            return "timeout"
-        elif isinstance(r, bool) and r:
-            from logs.models import PendingAction
-
-            details = {
-                "taskname": task_name,
-                "time": str(obj),
-            }
-            PendingAction(agent=self, action_type="schedreboot", details=details).save()
-
-            nice_time = dt.datetime.strftime(obj, "%B %d, %Y at %I:%M %p")
-            return {"msg": {"time": nice_time, "agent": self.hostname}}
-        else:
-            return "failed"
-
-    def not_supported(self, version_added):
-        if pyver.parse(self.version) < pyver.parse(version_added):
-            return True
-
-        return False
-
     def delete_superseded_updates(self):
         try:
             pks = []  # list of pks to delete
@@ -659,10 +652,10 @@ class AgentOutage(models.Model):
 
         CORE = CoreSettings.objects.first()
         CORE.send_mail(
-            f"{self.agent.client}, {self.agent.site}, {self.agent.hostname} - data overdue",
+            f"{self.agent.client.name}, {self.agent.site.name}, {self.agent.hostname} - data overdue",
             (
-                f"Data has not been received from client {self.agent.client}, "
-                f"site {self.agent.site}, "
+                f"Data has not been received from client {self.agent.client.name}, "
+                f"site {self.agent.site.name}, "
                 f"agent {self.agent.hostname} "
                 "within the expected time."
             ),
@@ -673,10 +666,10 @@ class AgentOutage(models.Model):
 
         CORE = CoreSettings.objects.first()
         CORE.send_mail(
-            f"{self.agent.client}, {self.agent.site}, {self.agent.hostname} - data received",
+            f"{self.agent.client.name}, {self.agent.site.name}, {self.agent.hostname} - data received",
             (
-                f"Data has been received from client {self.agent.client}, "
-                f"site {self.agent.site}, "
+                f"Data has been received from client {self.agent.client.name}, "
+                f"site {self.agent.site.name}, "
                 f"agent {self.agent.hostname} "
                 "after an interruption in data transmission."
             ),
@@ -687,7 +680,7 @@ class AgentOutage(models.Model):
 
         CORE = CoreSettings.objects.first()
         CORE.send_sms(
-            f"{self.agent.client}, {self.agent.site}, {self.agent.hostname} - data overdue"
+            f"{self.agent.client.name}, {self.agent.site.name}, {self.agent.hostname} - data overdue"
         )
 
     def send_recovery_sms(self):
@@ -695,7 +688,7 @@ class AgentOutage(models.Model):
 
         CORE = CoreSettings.objects.first()
         CORE.send_sms(
-            f"{self.agent.client}, {self.agent.site}, {self.agent.hostname} - data received"
+            f"{self.agent.client.name}, {self.agent.site.name}, {self.agent.hostname} - data received"
         )
 
     def __str__(self):
@@ -706,6 +699,8 @@ RECOVERY_CHOICES = [
     ("salt", "Salt"),
     ("mesh", "Mesh"),
     ("command", "Command"),
+    ("rpc", "Nats RPC"),
+    ("checkrunner", "Checkrunner"),
 ]
 
 

api/tacticalrmm/agents/serializers.py

@@ -1,10 +1,12 @@
 import pytz
 
 from rest_framework import serializers
+from rest_framework.fields import ReadOnlyField
 
 from .models import Agent, Note
 
 from winupdate.serializers import WinUpdatePolicySerializer
+from clients.serializers import ClientSerializer
 
 
 class AgentSerializer(serializers.ModelSerializer):
@@ -19,6 +21,8 @@ class AgentSerializer(serializers.ModelSerializer):
     checks = serializers.ReadOnlyField()
     timezone = serializers.ReadOnlyField()
     all_timezones = serializers.SerializerMethodField()
+    client_name = serializers.ReadOnlyField(source="client.name")
+    site_name = serializers.ReadOnlyField(source="site.name")
 
     def get_all_timezones(self, obj):
         return pytz.all_timezones
@@ -32,9 +36,15 @@ class AgentSerializer(serializers.ModelSerializer):
 
 class AgentTableSerializer(serializers.ModelSerializer):
     patches_pending = serializers.ReadOnlyField(source="has_patches_pending")
+    pending_actions = serializers.SerializerMethodField()
     status = serializers.ReadOnlyField()
     checks = serializers.ReadOnlyField()
     last_seen = serializers.SerializerMethodField()
+    client_name = serializers.ReadOnlyField(source="client.name")
+    site_name = serializers.ReadOnlyField(source="site.name")
+
+    def get_pending_actions(self, obj):
+        return obj.pendingactions.filter(status="pending").count()
 
     def get_last_seen(self, obj):
         if obj.time_zone is not None:
@@ -50,12 +60,13 @@ class AgentTableSerializer(serializers.ModelSerializer):
             "id",
             "hostname",
             "agent_id",
-            "client",
-            "site",
+            "site_name",
+            "client_name",
             "monitoring_type",
             "description",
             "needs_reboot",
             "patches_pending",
+            "pending_actions",
             "status",
             "overdue_text_alert",
             "overdue_email_alert",
@@ -66,11 +77,13 @@ class AgentTableSerializer(serializers.ModelSerializer):
             "last_logged_in_user",
             "maintenance_mode",
         ]
+        depth = 2
 
 
 class AgentEditSerializer(serializers.ModelSerializer):
     winupdatepolicy = WinUpdatePolicySerializer(many=True, read_only=True)
     all_timezones = serializers.SerializerMethodField()
+    client = ClientSerializer(read_only=True)
 
     def get_all_timezones(self, obj):
         return pytz.all_timezones
@@ -107,6 +120,9 @@ class WinAgentSerializer(serializers.ModelSerializer):
 
 
 class AgentHostnameSerializer(serializers.ModelSerializer):
+    client = serializers.ReadOnlyField(source="client.name")
+    site = serializers.ReadOnlyField(source="site.name")
+
     class Meta:
         model = Agent
         fields = (

api/tacticalrmm/agents/tasks.py

@@ -1,16 +1,16 @@
+import asyncio
 from loguru import logger
 from time import sleep
 import random
 import requests
 from packaging import version as pyver
 
-
 from django.conf import settings
 
-
 from tacticalrmm.celery import app
 from agents.models import Agent, AgentOutage
 from core.models import CoreSettings
+from logs.models import PendingAction
 
 logger.configure(**settings.LOG_CONFIG)
 
@@ -30,6 +30,14 @@ def send_agent_update_task(pks, version):
     for chunk in chunks:
         for pk in chunk:
             agent = Agent.objects.get(pk=pk)
+
+            # skip if we can't determine the arch
+            if agent.arch is None:
+                logger.warning(
+                    f"Unable to determine arch on {agent.salt_id}. Skipping."
+                )
+                continue
+
             # golang agent only backwards compatible with py agent 0.11.2
             # force an upgrade to the latest python agent if version < 0.11.2
             if pyver.parse(agent.version) < pyver.parse("0.11.2"):
@@ -42,20 +50,48 @@ def send_agent_update_task(pks, version):
             else:
                 url = agent.winagent_dl
                 inno = agent.win_inno_exe
-            r = agent.salt_api_async(
-                func="win_agent.do_agent_update_v2",
-                kwargs={
-                    "inno": inno,
-                    "url": url,
-                },
-            )
-        sleep(10)
+
+            if agent.has_nats:
+                if agent.pendingactions.filter(
+                    action_type="agentupdate", status="pending"
+                ).exists():
+                    action = agent.pendingactions.filter(
+                        action_type="agentupdate", status="pending"
+                    ).last()
+                    if pyver.parse(action.details["version"]) < pyver.parse(
+                        settings.LATEST_AGENT_VER
+                    ):
+                        action.delete()
+                    else:
+                        continue
+
+                PendingAction.objects.create(
+                    agent=agent,
+                    action_type="agentupdate",
+                    details={
+                        "url": agent.winagent_dl,
+                        "version": settings.LATEST_AGENT_VER,
+                        "inno": agent.win_inno_exe,
+                    },
+                )
+            # TODO
+            # Salt is deprecated, remove this once salt is gone
+            else:
+                r = agent.salt_api_async(
+                    func="win_agent.do_agent_update_v2",
+                    kwargs={
+                        "inno": inno,
+                        "url": url,
+                    },
+                )
+        sleep(5)
 
 
 @app.task
 def auto_self_agent_update_task():
     core = CoreSettings.objects.first()
     if not core.agent_auto_update:
+        logger.info("Agent auto update is disabled. Skipping.")
         return
 
     q = Agent.objects.only("pk", "version")
@@ -70,6 +106,14 @@ def auto_self_agent_update_task():
     for chunk in chunks:
         for pk in chunk:
             agent = Agent.objects.get(pk=pk)
+
+            # skip if we can't determine the arch
+            if agent.arch is None:
+                logger.warning(
+                    f"Unable to determine arch on {agent.salt_id}. Skipping."
+                )
+                continue
+
             # golang agent only backwards compatible with py agent 0.11.2
             # force an upgrade to the latest python agent if version < 0.11.2
             if pyver.parse(agent.version) < pyver.parse("0.11.2"):
@@ -82,40 +126,53 @@ def auto_self_agent_update_task():
             else:
                 url = agent.winagent_dl
                 inno = agent.win_inno_exe
-            r = agent.salt_api_async(
-                func="win_agent.do_agent_update_v2",
-                kwargs={
-                    "inno": inno,
-                    "url": url,
-                },
-            )
-        sleep(10)
+
+            if agent.has_nats:
+                if agent.pendingactions.filter(
+                    action_type="agentupdate", status="pending"
+                ).exists():
+                    action = agent.pendingactions.filter(
+                        action_type="agentupdate", status="pending"
+                    ).last()
+                    if pyver.parse(action.details["version"]) < pyver.parse(
+                        settings.LATEST_AGENT_VER
+                    ):
+                        action.delete()
+                    else:
+                        continue
+
+                PendingAction.objects.create(
+                    agent=agent,
+                    action_type="agentupdate",
+                    details={
+                        "url": agent.winagent_dl,
+                        "version": settings.LATEST_AGENT_VER,
+                        "inno": agent.win_inno_exe,
+                    },
+                )
+            # TODO
+            # Salt is deprecated, remove this once salt is gone
+            else:
+                r = agent.salt_api_async(
+                    func="win_agent.do_agent_update_v2",
+                    kwargs={
+                        "inno": inno,
+                        "url": url,
+                    },
+                )
+        sleep(5)
 
 
 @app.task
-def update_salt_minion_task():
-    q = Agent.objects.all()
-    agents = [
-        i.pk
-        for i in q
-        if pyver.parse(i.version) >= pyver.parse("0.11.0")
-        and pyver.parse(i.salt_ver) < pyver.parse(settings.LATEST_SALT_VER)
+def sync_sysinfo_task():
+    agents = Agent.objects.all()
+    online = [
+        i
+        for i in agents
+        if pyver.parse(i.version) >= pyver.parse("1.1.3") and i.status == "online"
     ]
-
-    chunks = (agents[i : i + 50] for i in range(0, len(agents), 50))
-
-    for chunk in chunks:
-        for pk in chunk:
-            agent = Agent.objects.get(pk=pk)
-            r = agent.salt_api_async(func="win_agent.update_salt")
-        sleep(20)
-
-
-@app.task
-def get_wmi_detail_task(pk):
-    agent = Agent.objects.get(pk=pk)
-    r = agent.salt_api_async(timeout=30, func="win_agent.local_sys_info")
-    return "ok"
+    for agent in online:
+        asyncio.run(agent.nats_cmd({"func": "sync"}, wait=False))
 
 
 @app.task
@@ -134,7 +191,7 @@ def sync_salt_modules_task(pk):
 def batch_sync_modules_task():
     # sync modules, split into chunks of 50 agents to not overload salt
     agents = Agent.objects.all()
-    online = [i.salt_id for i in agents if i.status == "online"]
+    online = [i.salt_id for i in agents]
     chunks = (online[i : i + 50] for i in range(0, len(online), 50))
     for chunk in chunks:
         Agent.salt_batch_async(minions=chunk, func="saltutil.sync_modules")
@@ -142,57 +199,43 @@ def batch_sync_modules_task():
 
 
 @app.task
-def batch_sysinfo_task():
-    # update system info using WMI
-    agents = Agent.objects.all()
-    online = [
-        i.salt_id
-        for i in agents
-        if not i.not_supported("0.11.0") and i.status == "online"
-    ]
-    chunks = (online[i : i + 30] for i in range(0, len(online), 30))
-    for chunk in chunks:
-        Agent.salt_batch_async(minions=chunk, func="win_agent.local_sys_info")
-        sleep(10)
-
-
-@app.task
-def uninstall_agent_task(salt_id):
+def uninstall_agent_task(salt_id, has_nats):
     attempts = 0
     error = False
 
-    while 1:
-        try:
+    if not has_nats:
+        while 1:
+            try:
 
-            r = requests.post(
-                f"http://{settings.SALT_HOST}:8123/run",
-                json=[
-                    {
-                        "client": "local",
-                        "tgt": salt_id,
-                        "fun": "win_agent.uninstall_agent",
-                        "timeout": 8,
-                        "username": settings.SALT_USERNAME,
-                        "password": settings.SALT_PASSWORD,
-                        "eauth": "pam",
-                    }
-                ],
-                timeout=10,
-            )
-            ret = r.json()["return"][0][salt_id]
-        except Exception:
-            attempts += 1
-        else:
-            if ret != "ok":
+                r = requests.post(
+                    f"http://{settings.SALT_HOST}:8123/run",
+                    json=[
+                        {
+                            "client": "local",
+                            "tgt": salt_id,
+                            "fun": "win_agent.uninstall_agent",
+                            "timeout": 8,
+                            "username": settings.SALT_USERNAME,
+                            "password": settings.SALT_PASSWORD,
+                            "eauth": "pam",
+                        }
+                    ],
+                    timeout=10,
+                )
+                ret = r.json()["return"][0][salt_id]
+            except Exception:
                 attempts += 1
             else:
-                attempts = 0
+                if ret != "ok":
+                    attempts += 1
+                else:
+                    attempts = 0
 
-        if attempts >= 10:
-            error = True
-            break
-        elif attempts == 0:
-            break
+            if attempts >= 10:
+                error = True
+                break
+            elif attempts == 0:
+                break
 
     if error:
         logger.error(f"{salt_id} uninstall failed")
@@ -258,19 +301,22 @@ def agent_recovery_sms_task(pk):
 
 @app.task
 def agent_outages_task():
-    agents = Agent.objects.only("pk")
+    agents = Agent.objects.only(
+        "pk", "last_seen", "overdue_time", "overdue_email_alert", "overdue_text_alert"
+    )
 
     for agent in agents:
-        if agent.status == "overdue":
-            outages = AgentOutage.objects.filter(agent=agent)
-            if outages and outages.last().is_active:
-                continue
+        if agent.overdue_email_alert or agent.overdue_text_alert:
+            if agent.status == "overdue":
+                outages = AgentOutage.objects.filter(agent=agent)
+                if outages and outages.last().is_active:
+                    continue
 
-            outage = AgentOutage(agent=agent)
-            outage.save()
+                outage = AgentOutage(agent=agent)
+                outage.save()
 
-            if agent.overdue_email_alert and not agent.maintenance_mode:
-                agent_outage_email_task.delay(pk=outage.pk)
+                if agent.overdue_email_alert and not agent.maintenance_mode:
+                    agent_outage_email_task.delay(pk=outage.pk)
 
-            if agent.overdue_text_alert and not agent.maintenance_mode:
-                agent_outage_sms_task.delay(pk=outage.pk)
+                if agent.overdue_text_alert and not agent.maintenance_mode:
+                    agent_outage_sms_task.delay(pk=outage.pk)

api/tacticalrmm/agents/tests.py

@@ -6,19 +6,39 @@ from model_bakery import baker
 from itertools import cycle
 
 from django.conf import settings
+from django.utils import timezone as djangotime
 
-from tacticalrmm.test import BaseTestCase, TacticalTestCase
+from tacticalrmm.test import TacticalTestCase
 from .serializers import AgentSerializer
 from winupdate.serializers import WinUpdatePolicySerializer
 from .models import Agent
+from .tasks import (
+    auto_self_agent_update_task,
+    sync_salt_modules_task,
+    batch_sync_modules_task,
+    OLD_64_PY_AGENT,
+    OLD_32_PY_AGENT,
+)
 from winupdate.models import WinUpdatePolicy
 
 
-class TestAgentViews(BaseTestCase):
+class TestAgentViews(TacticalTestCase):
+    def setUp(self):
+        self.authenticate()
+        self.setup_coresettings()
+
+        client = baker.make("clients.Client", name="Google")
+        site = baker.make("clients.Site", client=client, name="LA Office")
+        self.agent = baker.make_recipe(
+            "agents.online_agent", site=site, version="1.1.1"
+        )
+        baker.make_recipe("winupdate.winupdate_policy", agent=self.agent)
+
     def test_get_patch_policy(self):
         # make sure get_patch_policy doesn't error out when agent has policy with
         # an empty patch policy
-        self.agent.policy = self.policy
+        policy = baker.make("automation.Policy")
+        self.agent.policy = policy
         self.agent.save(update_fields=["policy"])
         _ = self.agent.get_patch_policy()
 
@@ -29,8 +49,8 @@ class TestAgentViews(BaseTestCase):
         self.agent.policy = None
         self.agent.save(update_fields=["policy"])
 
-        self.coresettings.server_policy = self.policy
-        self.coresettings.workstation_policy = self.policy
+        self.coresettings.server_policy = policy
+        self.coresettings.workstation_policy = policy
         self.coresettings.save(update_fields=["server_policy", "workstation_policy"])
         _ = self.agent.get_patch_policy()
 
@@ -58,29 +78,29 @@ class TestAgentViews(BaseTestCase):
 
         self.check_not_authenticated("post", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_ping(self, mock_ret):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_ping(self, nats_cmd):
         url = f"/agents/{self.agent.pk}/ping/"
 
-        mock_ret.return_value = "timeout"
+        nats_cmd.return_value = "timeout"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         ret = {"name": self.agent.hostname, "status": "offline"}
         self.assertEqual(r.json(), ret)
 
-        mock_ret.return_value = "error"
+        nats_cmd.return_value = "natsdown"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         ret = {"name": self.agent.hostname, "status": "offline"}
         self.assertEqual(r.json(), ret)
 
-        mock_ret.return_value = True
+        nats_cmd.return_value = "pong"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         ret = {"name": self.agent.hostname, "status": "online"}
         self.assertEqual(r.json(), ret)
 
-        mock_ret.return_value = False
+        nats_cmd.return_value = "asdasjdaksdasd"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         ret = {"name": self.agent.hostname, "status": "offline"}
@@ -88,33 +108,23 @@ class TestAgentViews(BaseTestCase):
 
         self.check_not_authenticated("get", url)
 
+    @patch("agents.models.Agent.nats_cmd")
     @patch("agents.tasks.uninstall_agent_task.delay")
-    def test_uninstall(self, mock_task):
+    @patch("agents.views.reload_nats")
+    def test_uninstall(self, reload_nats, mock_task, nats_cmd):
         url = "/agents/uninstall/"
         data = {"pk": self.agent.pk}
 
         r = self.client.delete(url, data, format="json")
         self.assertEqual(r.status_code, 200)
 
-        mock_task.assert_called_with(self.agent.salt_id)
+        nats_cmd.assert_called_with({"func": "uninstall"}, wait=False)
+        reload_nats.assert_called_once()
+        mock_task.assert_called_with(self.agent.salt_id, True)
 
         self.check_not_authenticated("delete", url)
 
-    @patch("agents.tasks.uninstall_agent_task.delay")
-    def test_uninstall_catch_no_user(self, mock_task):
-        url = "/agents/uninstall/"
-        data = {"pk": self.agent.pk}
-
-        self.agent_user.delete()
-
-        r = self.client.delete(url, data, format="json")
-        self.assertEqual(r.status_code, 200)
-
-        mock_task.assert_called_with(self.agent.salt_id)
-
-        self.check_not_authenticated("delete", url)
-
-    @patch("agents.models.Agent.salt_api_cmd")
+    @patch("agents.models.Agent.nats_cmd")
     def test_get_processes(self, mock_ret):
         url = f"/agents/{self.agent.pk}/getprocs/"
 
@@ -134,82 +144,61 @@ class TestAgentViews(BaseTestCase):
         r = self.client.get(url)
         self.assertEqual(r.status_code, 400)
 
-        mock_ret.return_value = "error"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_kill_proc(self, mock_ret):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_kill_proc(self, nats_cmd):
         url = f"/agents/{self.agent.pk}/8234/killproc/"
 
-        mock_ret.return_value = True
+        nats_cmd.return_value = "ok"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
 
-        mock_ret.return_value = False
+        nats_cmd.return_value = "timeout"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 400)
 
-        mock_ret.return_value = "timeout"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = "error"
+        nats_cmd.return_value = "process doesn't exist"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 400)
 
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
+    @patch("agents.models.Agent.nats_cmd")
     def test_get_event_log(self, mock_ret):
         url = f"/agents/{self.agent.pk}/geteventlog/Application/30/"
 
         with open(
-            os.path.join(settings.BASE_DIR, "tacticalrmm/test_data/eventlograw.json")
+            os.path.join(settings.BASE_DIR, "tacticalrmm/test_data/appeventlog.json")
         ) as f:
             mock_ret.return_value = json.load(f)
 
-        with open(
-            os.path.join(settings.BASE_DIR, "tacticalrmm/test_data/appeventlog.json")
-        ) as f:
-            decoded = json.load(f)
-
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        self.assertEqual(decoded, r.json())
 
         mock_ret.return_value = "timeout"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 400)
 
-        mock_ret.return_value = "error"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_power_action(self, mock_ret):
-        url = f"/agents/poweraction/"
+    @patch("agents.models.Agent.nats_cmd")
+    def test_reboot_now(self, nats_cmd):
+        url = f"/agents/reboot/"
 
-        data = {"pk": self.agent.pk, "action": "rebootnow"}
-        mock_ret.return_value = True
+        data = {"pk": self.agent.pk}
+        nats_cmd.return_value = "ok"
         r = self.client.post(url, data, format="json")
         self.assertEqual(r.status_code, 200)
+        nats_cmd.assert_called_with({"func": "rebootnow"}, timeout=10)
 
-        mock_ret.return_value = "error"
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = False
+        nats_cmd.return_value = "timeout"
         r = self.client.post(url, data, format="json")
         self.assertEqual(r.status_code, 400)
 
         self.check_not_authenticated("post", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
+    @patch("agents.models.Agent.nats_cmd")
     def test_send_raw_cmd(self, mock_ret):
         url = f"/agents/sendrawcmd/"
 
@@ -228,36 +217,39 @@ class TestAgentViews(BaseTestCase):
         r = self.client.post(url, data, format="json")
         self.assertEqual(r.status_code, 400)
 
-        mock_ret.return_value = False
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
-
         self.check_not_authenticated("post", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_reboot_later(self, mock_ret):
-        url = f"/agents/rebootlater/"
+    @patch("agents.models.Agent.nats_cmd")
+    def test_reboot_later(self, nats_cmd):
+        url = f"/agents/reboot/"
 
         data = {
             "pk": self.agent.pk,
             "datetime": "2025-08-29 18:41",
         }
 
-        mock_ret.return_value = True
-        r = self.client.post(url, data, format="json")
+        nats_cmd.return_value = "ok"
+        r = self.client.patch(url, data, format="json")
         self.assertEqual(r.status_code, 200)
         self.assertEqual(r.data["time"], "August 29, 2025 at 06:41 PM")
         self.assertEqual(r.data["agent"], self.agent.hostname)
 
-        mock_ret.return_value = "failed"
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
+        nats_data = {
+            "func": "schedtask",
+            "schedtaskpayload": {
+                "type": "schedreboot",
+                "trigger": "once",
+                "name": r.data["task_name"],
+                "year": 2025,
+                "month": "August",
+                "day": 29,
+                "hour": 18,
+                "min": 41,
+            },
+        }
+        nats_cmd.assert_called_with(nats_data, timeout=10)
 
-        mock_ret.return_value = "timeout"
-        r = self.client.post(url, data, format="json")
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = False
+        nats_cmd.return_value = "error creating task"
         r = self.client.post(url, data, format="json")
         self.assertEqual(r.status_code, 400)
 
@@ -265,21 +257,22 @@ class TestAgentViews(BaseTestCase):
             "pk": self.agent.pk,
             "datetime": "rm -rf /",
         }
-        r = self.client.post(url, data_invalid, format="json")
+        r = self.client.patch(url, data_invalid, format="json")
 
         self.assertEqual(r.status_code, 400)
         self.assertEqual(r.data, "Invalid date")
 
-        self.check_not_authenticated("post", url)
+        self.check_not_authenticated("patch", url)
 
     @patch("os.path.exists")
     @patch("subprocess.run")
     def test_install_agent(self, mock_subprocess, mock_file_exists):
         url = f"/agents/installagent/"
 
+        site = baker.make("clients.Site")
         data = {
-            "client": "Google",
-            "site": "LA Office",
+            "client": site.client.id,
+            "site": site.id,
             "arch": "64",
             "expires": 23,
             "installMethod": "exe",
@@ -381,12 +374,14 @@ class TestAgentViews(BaseTestCase):
         self.check_not_authenticated("get", url)
 
     def test_edit_agent(self):
+        # setup data
+        site = baker.make("clients.Site", name="Ny Office")
+
         url = "/agents/editagent/"
 
         edit = {
             "id": self.agent.pk,
-            "client": "Facebook",
-            "site": "NY Office",
+            "site": site.id,
             "monitoring_type": "workstation",
             "description": "asjdk234andasd",
             "overdue_time": 300,
@@ -416,7 +411,7 @@ class TestAgentViews(BaseTestCase):
 
         agent = Agent.objects.get(pk=self.agent.pk)
         data = AgentSerializer(agent).data
-        self.assertEqual(data["site"], "NY Office")
+        self.assertEqual(data["site"], site.id)
 
         policy = WinUpdatePolicy.objects.get(agent=self.agent)
         data = WinUpdatePolicySerializer(policy).data
@@ -437,9 +432,18 @@ class TestAgentViews(BaseTestCase):
         self.assertIn("&viewmode=13", r.data["file"])
         self.assertIn("&viewmode=12", r.data["terminal"])
         self.assertIn("&viewmode=11", r.data["control"])
-        self.assertIn("mstsc.html?login=", r.data["webrdp"])
+
+        self.assertIn("&gotonode=", r.data["file"])
+        self.assertIn("&gotonode=", r.data["terminal"])
+        self.assertIn("&gotonode=", r.data["control"])
+
+        self.assertIn("?login=", r.data["file"])
+        self.assertIn("?login=", r.data["terminal"])
+        self.assertIn("?login=", r.data["control"])
 
         self.assertEqual(self.agent.hostname, r.data["hostname"])
+        self.assertEqual(self.agent.client.name, r.data["client"])
+        self.assertEqual(self.agent.site.name, r.data["site"])
 
         self.assertEqual(r.status_code, 200)
 
@@ -450,28 +454,28 @@ class TestAgentViews(BaseTestCase):
         self.check_not_authenticated("get", url)
 
     def test_by_client(self):
-        url = "/agents/byclient/Google/"
+        url = f"/agents/byclient/{self.agent.client.id}/"
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         self.assertTrue(r.data)
 
-        url = f"/agents/byclient/Majh3 Akj34 ad/"
+        url = f"/agents/byclient/500/"
         r = self.client.get(url)
         self.assertFalse(r.data)  # returns empty list
 
         self.check_not_authenticated("get", url)
 
     def test_by_site(self):
-        url = f"/agents/bysite/Google/Main Office/"
+        url = f"/agents/bysite/{self.agent.site.id}/"
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         self.assertTrue(r.data)
 
-        url = f"/agents/bysite/Google/Ajdaksd Office/"
+        url = f"/agents/bysite/500/"
         r = self.client.get(url)
-        self.assertFalse(r.data)
+        self.assertEqual(r.data, [])
 
         self.check_not_authenticated("get", url)
 
@@ -535,12 +539,14 @@ class TestAgentViews(BaseTestCase):
         self.check_not_authenticated("get", url)
 
     @patch("winupdate.tasks.bulk_check_for_updates_task.delay")
+    @patch("scripts.tasks.handle_bulk_script_task.delay")
+    @patch("scripts.tasks.handle_bulk_command_task.delay")
     @patch("agents.models.Agent.salt_batch_async")
-    def test_bulk_cmd_script(self, mock_ret, mock_update):
+    def test_bulk_cmd_script(
+        self, salt_batch_async, bulk_command, bulk_script, mock_update
+    ):
         url = "/agents/bulk/"
 
-        mock_ret.return_value = "ok"
-
         payload = {
             "mode": "command",
             "target": "agents",
@@ -555,6 +561,7 @@ class TestAgentViews(BaseTestCase):
         }
 
         r = self.client.post(url, payload, format="json")
+        bulk_command.assert_called_with([self.agent.pk], "gpupdate /force", "cmd", 300)
         self.assertEqual(r.status_code, 200)
 
         payload = {
@@ -574,7 +581,7 @@ class TestAgentViews(BaseTestCase):
         payload = {
             "mode": "command",
             "target": "client",
-            "client": "Google",
+            "client": self.agent.client.id,
             "site": None,
             "agentPKs": [
                 self.agent.pk,
@@ -586,12 +593,13 @@ class TestAgentViews(BaseTestCase):
 
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
+        bulk_command.assert_called_with([self.agent.pk], "gpupdate /force", "cmd", 300)
 
         payload = {
             "mode": "command",
             "target": "client",
-            "client": "Google",
-            "site": "Main Office",
+            "client": self.agent.client.id,
+            "site": self.agent.site.id,
             "agentPKs": [
                 self.agent.pk,
             ],
@@ -602,28 +610,7 @@ class TestAgentViews(BaseTestCase):
 
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
-
-        payload = {
-            "mode": "command",
-            "target": "site",
-            "client": "A ASJDHkjASHDASD",
-            "site": "asdasdasdasda",
-            "agentPKs": [
-                self.agent.pk,
-            ],
-            "cmd": "gpupdate /force",
-            "timeout": 300,
-            "shell": "cmd",
-        }
-
-        r = self.client.post(url, payload, format="json")
-        self.assertEqual(r.status_code, 404)
-
-        mock_ret.return_value = "timeout"
-        payload["client"] = "Google"
-        payload["site"] = "Main Office"
-        r = self.client.post(url, payload, format="json")
-        self.assertEqual(r.status_code, 400)
+        bulk_command.assert_called_with([self.agent.pk], "gpupdate /force", "cmd", 300)
 
         payload = {
             "mode": "scan",
@@ -634,20 +621,20 @@ class TestAgentViews(BaseTestCase):
                 self.agent.pk,
             ],
         }
-        mock_ret.return_value = "ok"
         r = self.client.post(url, payload, format="json")
-        mock_update.assert_called_once()
+        mock_update.assert_called_with(minions=[self.agent.salt_id])
         self.assertEqual(r.status_code, 200)
 
         payload = {
             "mode": "install",
             "target": "client",
-            "client": "Google",
+            "client": self.agent.client.id,
             "site": None,
             "agentPKs": [
                 self.agent.pk,
             ],
         }
+        salt_batch_async.return_value = "ok"
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
 
@@ -663,41 +650,18 @@ class TestAgentViews(BaseTestCase):
 
         self.check_not_authenticated("post", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_restart_mesh(self, mock_ret):
-        url = f"/agents/{self.agent.pk}/restartmesh/"
-
-        mock_ret.return_value = "timeout"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = "error"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = False
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = True
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 200)
-
-        self.check_not_authenticated("get", url)
-
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_recover_mesh(self, mock_ret):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_recover_mesh(self, nats_cmd):
         url = f"/agents/{self.agent.pk}/recovermesh/"
-        mock_ret.return_value = True
+        nats_cmd.return_value = "ok"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
         self.assertIn(self.agent.hostname, r.data)
+        nats_cmd.assert_called_with(
+            {"func": "recover", "payload": {"mode": "mesh"}}, timeout=45
+        )
 
-        mock_ret.return_value = "timeout"
-        r = self.client.get(url)
-        self.assertEqual(r.status_code, 400)
-
-        mock_ret.return_value = "error"
+        nats_cmd.return_value = "timeout"
         r = self.client.get(url)
         self.assertEqual(r.status_code, 400)
 
@@ -746,13 +710,13 @@ class TestAgentViewsNew(TacticalTestCase):
 
     def test_agent_maintenance_mode(self):
         url = "/agents/maintenance/"
-        # create data
-        client = baker.make("clients.Client", client="Default")
-        site = baker.make("clients.Site", client=client, site="Site")
-        agent = baker.make_recipe("agents.agent", client=client.client, site=site.site)
+
+        # setup data
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.agent", site=site)
 
         # Test client toggle maintenance mode
-        data = {"type": "Client", "id": client.id, "action": True}
+        data = {"type": "Client", "id": site.client.id, "action": True}
 
         r = self.client.post(url, data, format="json")
         self.assertEqual(r.status_code, 200)
@@ -779,3 +743,149 @@ class TestAgentViewsNew(TacticalTestCase):
         self.assertEqual(r.status_code, 400)
 
         self.check_not_authenticated("post", url)
+
+
+class TestAgentTasks(TacticalTestCase):
+    def setUp(self):
+        self.authenticate()
+        self.setup_coresettings()
+
+    @patch("agents.models.Agent.salt_api_cmd")
+    def test_sync_salt_modules_task(self, salt_api_cmd):
+        self.agent = baker.make_recipe("agents.agent")
+        salt_api_cmd.return_value = {"return": [{f"{self.agent.salt_id}": []}]}
+        ret = sync_salt_modules_task.s(self.agent.pk).apply()
+        salt_api_cmd.assert_called_with(timeout=35, func="saltutil.sync_modules")
+        self.assertEqual(
+            ret.result, f"Successfully synced salt modules on {self.agent.hostname}"
+        )
+        self.assertEqual(ret.status, "SUCCESS")
+
+        salt_api_cmd.return_value = "timeout"
+        ret = sync_salt_modules_task.s(self.agent.pk).apply()
+        self.assertEqual(ret.result, f"Unable to sync modules {self.agent.salt_id}")
+
+        salt_api_cmd.return_value = "error"
+        ret = sync_salt_modules_task.s(self.agent.pk).apply()
+        self.assertEqual(ret.result, f"Unable to sync modules {self.agent.salt_id}")
+
+    @patch("agents.models.Agent.salt_batch_async", return_value=None)
+    @patch("agents.tasks.sleep", return_value=None)
+    def test_batch_sync_modules_task(self, mock_sleep, salt_batch_async):
+        # chunks of 50, should run 4 times
+        baker.make_recipe(
+            "agents.online_agent", last_seen=djangotime.now(), _quantity=60
+        )
+        baker.make_recipe(
+            "agents.overdue_agent",
+            last_seen=djangotime.now() - djangotime.timedelta(minutes=9),
+            _quantity=115,
+        )
+        ret = batch_sync_modules_task.s().apply()
+        self.assertEqual(salt_batch_async.call_count, 4)
+        self.assertEqual(ret.status, "SUCCESS")
+
+    @patch("agents.models.Agent.salt_api_async")
+    @patch("agents.tasks.sleep", return_value=None)
+    def test_auto_self_agent_update_task(self, mock_sleep, salt_api_async):
+        # test 64bit golang agent
+        self.agent64 = baker.make_recipe(
+            "agents.agent",
+            operating_system="Windows 10 Pro, 64 bit (build 19041.450)",
+            version="1.0.0",
+        )
+        salt_api_async.return_value = True
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_called_with(
+            func="win_agent.do_agent_update_v2",
+            kwargs={
+                "inno": f"winagent-v{settings.LATEST_AGENT_VER}.exe",
+                "url": settings.DL_64,
+            },
+        )
+        self.assertEqual(ret.status, "SUCCESS")
+        self.agent64.delete()
+        salt_api_async.reset_mock()
+
+        # test 32bit golang agent
+        self.agent32 = baker.make_recipe(
+            "agents.agent",
+            operating_system="Windows 7 Professional, 32 bit (build 7601.24544)",
+            version="1.0.0",
+        )
+        salt_api_async.return_value = True
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_called_with(
+            func="win_agent.do_agent_update_v2",
+            kwargs={
+                "inno": f"winagent-v{settings.LATEST_AGENT_VER}-x86.exe",
+                "url": settings.DL_32,
+            },
+        )
+        self.assertEqual(ret.status, "SUCCESS")
+        self.agent32.delete()
+        salt_api_async.reset_mock()
+
+        # test agent that has a null os field
+        self.agentNone = baker.make_recipe(
+            "agents.agent",
+            operating_system=None,
+            version="1.0.0",
+        )
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_not_called()
+        self.agentNone.delete()
+        salt_api_async.reset_mock()
+
+        # test auto update disabled in global settings
+        self.agent64 = baker.make_recipe(
+            "agents.agent",
+            operating_system="Windows 10 Pro, 64 bit (build 19041.450)",
+            version="1.0.0",
+        )
+        self.coresettings.agent_auto_update = False
+        self.coresettings.save(update_fields=["agent_auto_update"])
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_not_called()
+
+        # reset core settings
+        self.agent64.delete()
+        salt_api_async.reset_mock()
+        self.coresettings.agent_auto_update = True
+        self.coresettings.save(update_fields=["agent_auto_update"])
+
+        # test 64bit python agent
+        self.agent64py = baker.make_recipe(
+            "agents.agent",
+            operating_system="Windows 10 Pro, 64 bit (build 19041.450)",
+            version="0.11.1",
+        )
+        salt_api_async.return_value = True
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_called_with(
+            func="win_agent.do_agent_update_v2",
+            kwargs={
+                "inno": "winagent-v0.11.2.exe",
+                "url": OLD_64_PY_AGENT,
+            },
+        )
+        self.assertEqual(ret.status, "SUCCESS")
+        self.agent64py.delete()
+        salt_api_async.reset_mock()
+
+        # test 32bit python agent
+        self.agent32py = baker.make_recipe(
+            "agents.agent",
+            operating_system="Windows 7 Professional, 32 bit (build 7601.24544)",
+            version="0.11.1",
+        )
+        salt_api_async.return_value = True
+        ret = auto_self_agent_update_task.s().apply()
+        salt_api_async.assert_called_with(
+            func="win_agent.do_agent_update_v2",
+            kwargs={
+                "inno": "winagent-v0.11.2-x86.exe",
+                "url": OLD_32_PY_AGENT,
+            },
+        )
+        self.assertEqual(ret.status, "SUCCESS")

api/tacticalrmm/agents/urls.py

@@ -5,14 +5,13 @@ urlpatterns = [
     path("listagents/", views.AgentsTableList.as_view()),
     path("listagentsnodetail/", views.list_agents_no_detail),
     path("<int:pk>/agenteditdetails/", views.agent_edit_details),
-    path("byclient/<client>/", views.by_client),
-    path("bysite/<client>/<site>/", views.by_site),
+    path("byclient/<int:clientpk>/", views.by_client),
+    path("bysite/<int:sitepk>/", views.by_site),
     path("overdueaction/", views.overdue_action),
     path("sendrawcmd/", views.send_raw_cmd),
     path("<pk>/agentdetail/", views.agent_detail),
     path("<int:pk>/meshcentral/", views.meshcentral),
     path("<str:arch>/getmeshexe/", views.get_mesh_exe),
-    path("poweraction/", views.power_action),
     path("uninstall/", views.uninstall),
     path("editagent/", views.edit_agent),
     path("<pk>/geteventlog/<logtype>/<days>/", views.get_event_log),
@@ -20,16 +19,16 @@ urlpatterns = [
     path("updateagents/", views.update_agents),
     path("<pk>/getprocs/", views.get_processes),
     path("<pk>/<pid>/killproc/", views.kill_proc),
-    path("rebootlater/", views.reboot_later),
+    path("reboot/", views.Reboot.as_view()),
     path("installagent/", views.install_agent),
     path("<int:pk>/ping/", views.ping),
     path("recover/", views.recover),
     path("runscript/", views.run_script),
-    path("<int:pk>/restartmesh/", views.restart_mesh),
     path("<int:pk>/recovermesh/", views.recover_mesh),
     path("<int:pk>/notes/", views.GetAddNotes.as_view()),
     path("<int:pk>/note/", views.GetEditDeleteNote.as_view()),
     path("bulk/", views.bulk),
     path("agent_counts/", views.agent_counts),
     path("maintenance/", views.agent_maintenance),
+    path("<int:pk>/wmi/", views.WMI.as_view()),
 ]

api/tacticalrmm/agents/views.py

@@ -1,10 +1,10 @@
+import asyncio
 from loguru import logger
 import os
 import subprocess
-import zlib
-import json
-import base64
 import pytz
+import random
+import string
 import datetime as dt
 from packaging import version as pyver
 
@@ -18,12 +18,9 @@ from rest_framework.response import Response
 from rest_framework import status, generics
 
 from .models import Agent, AgentOutage, RecoveryAction, Note
-from winupdate.models import WinUpdatePolicy
-from clients.models import Client, Site
-from accounts.models import User
 from core.models import CoreSettings
 from scripts.models import Script
-from logs.models import AuditLog
+from logs.models import AuditLog, PendingAction
 
 from .serializers import (
     AgentSerializer,
@@ -37,9 +34,9 @@ from winupdate.serializers import WinUpdatePolicySerializer
 
 from .tasks import uninstall_agent_task, send_agent_update_task
 from winupdate.tasks import bulk_check_for_updates_task
-from scripts.tasks import run_script_bg_task, run_bulk_script_task
+from scripts.tasks import handle_bulk_command_task, handle_bulk_script_task
 
-from tacticalrmm.utils import notify_error
+from tacticalrmm.utils import notify_error, reload_nats
 
 logger.configure(**settings.LOG_CONFIG)
 
@@ -66,50 +63,56 @@ def update_agents(request):
 @api_view()
 def ping(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(timeout=5, func="test.ping")
-
-    if r == "timeout" or r == "error":
-        return Response({"name": agent.hostname, "status": "offline"})
-
-    if isinstance(r, bool) and r:
-        return Response({"name": agent.hostname, "status": "online"})
+    status = "offline"
+    if agent.has_nats:
+        r = asyncio.run(agent.nats_cmd({"func": "ping"}, timeout=5))
+        if r == "pong":
+            status = "online"
     else:
-        return Response({"name": agent.hostname, "status": "offline"})
+        r = agent.salt_api_cmd(timeout=5, func="test.ping")
+        if isinstance(r, bool) and r:
+            status = "online"
+
+    return Response({"name": agent.hostname, "status": status})
 
 
 @api_view(["DELETE"])
 def uninstall(request):
     agent = get_object_or_404(Agent, pk=request.data["pk"])
-    # just in case agent-user gets deleted accidentaly from django-admin
-    # we can still remove the agent
-    try:
-        user = User.objects.get(username=agent.agent_id)
-        user.delete()
-    except Exception as e:
-        logger.warning(e)
+    if agent.has_nats:
+        asyncio.run(agent.nats_cmd({"func": "uninstall"}, wait=False))
 
     salt_id = agent.salt_id
     name = agent.hostname
+    has_nats = agent.has_nats
     agent.delete()
+    reload_nats()
 
-    uninstall_agent_task.delay(salt_id)
+    uninstall_agent_task.delay(salt_id, has_nats)
     return Response(f"{name} will now be uninstalled.")
 
 
 @api_view(["PATCH"])
 def edit_agent(request):
     agent = get_object_or_404(Agent, pk=request.data["id"])
+
+    old_site = agent.site.pk
     a_serializer = AgentSerializer(instance=agent, data=request.data, partial=True)
     a_serializer.is_valid(raise_exception=True)
     a_serializer.save()
 
-    policy = WinUpdatePolicy.objects.get(agent=agent)
+    policy = agent.winupdatepolicy.get()
     p_serializer = WinUpdatePolicySerializer(
         instance=policy, data=request.data["winupdatepolicy"][0]
     )
     p_serializer.is_valid(raise_exception=True)
     p_serializer.save()
 
+    # check if site changed and initiate generating correct policies
+    if old_site != request.data["site"]:
+        agent.generate_checks_from_policies(clear=True)
+        agent.generate_tasks_from_policies(clear=True)
+
     return Response("ok")
 
 
@@ -125,16 +128,9 @@ def meshcentral(request, pk):
     if token == "err":
         return notify_error("Invalid mesh token")
 
-    control = (
-        f"{core.mesh_site}/?login={token}&node={agent.mesh_node_id}&viewmode=11&hide=31"
-    )
-    terminal = (
-        f"{core.mesh_site}/?login={token}&node={agent.mesh_node_id}&viewmode=12&hide=31"
-    )
-    file = (
-        f"{core.mesh_site}/?login={token}&node={agent.mesh_node_id}&viewmode=13&hide=31"
-    )
-    webrdp = f"{core.mesh_site}/mstsc.html?login={token}&node={agent.mesh_node_id}"
+    control = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=11&hide=31"
+    terminal = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=12&hide=31"
+    file = f"{core.mesh_site}/?login={token}&gotonode={agent.mesh_node_id}&viewmode=13&hide=31"
 
     AuditLog.audit_mesh_session(username=request.user.username, hostname=agent.hostname)
 
@@ -143,8 +139,9 @@ def meshcentral(request, pk):
         "control": control,
         "terminal": terminal,
         "file": file,
-        "webrdp": webrdp,
         "status": agent.status,
+        "client": agent.client.name,
+        "site": agent.site.name,
     }
     return Response(ret)
 
@@ -158,12 +155,11 @@ def agent_detail(request, pk):
 @api_view()
 def get_processes(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(timeout=20, func="win_agent.get_procs")
-
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    r = asyncio.run(agent.nats_cmd(data={"func": "procs"}, timeout=5))
     if r == "timeout":
         return notify_error("Unable to contact the agent")
-    elif r == "error":
-        return notify_error("Something went wrong")
 
     return Response(r)
 
@@ -171,15 +167,17 @@ def get_processes(request, pk):
 @api_view()
 def kill_proc(request, pk, pid):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(timeout=25, func="ps.kill_pid", arg=int(pid))
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+
+    r = asyncio.run(
+        agent.nats_cmd({"func": "killproc", "procpid": int(pid)}, timeout=15)
+    )
 
     if r == "timeout":
         return notify_error("Unable to contact the agent")
-    elif r == "error":
-        return notify_error("Something went wrong")
-
-    if isinstance(r, bool) and not r:
-        return notify_error("Unable to kill the process")
+    elif r != "ok":
+        return notify_error(r)
 
     return Response("ok")
 
@@ -187,55 +185,41 @@ def kill_proc(request, pk, pid):
 @api_view()
 def get_event_log(request, pk, logtype, days):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(
-        timeout=30,
-        func="win_agent.get_eventlog",
-        arg=[logtype, int(days)],
-    )
-
-    if r == "timeout" or r == "error":
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    data = {
+        "func": "eventlog",
+        "timeout": 30,
+        "payload": {
+            "logname": logtype,
+            "days": str(days),
+        },
+    }
+    r = asyncio.run(agent.nats_cmd(data, timeout=32))
+    if r == "timeout":
         return notify_error("Unable to contact the agent")
 
-    return Response(json.loads(zlib.decompress(base64.b64decode(r["wineventlog"]))))
-
-
-@api_view(["POST"])
-def power_action(request):
-    pk = request.data["pk"]
-    action = request.data["action"]
-    agent = get_object_or_404(Agent, pk=pk)
-    if action == "rebootnow":
-        logger.info(f"{agent.hostname} was scheduled for immediate reboot")
-        r = agent.salt_api_cmd(
-            timeout=30,
-            func="system.reboot",
-            arg=3,
-            kwargs={"in_seconds": True},
-        )
-    if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
-        return notify_error("Unable to contact the agent")
-
-    return Response("ok")
+    return Response(r)
 
 
 @api_view(["POST"])
 def send_raw_cmd(request):
     agent = get_object_or_404(Agent, pk=request.data["pk"])
-
-    r = agent.salt_api_cmd(
-        timeout=request.data["timeout"],
-        func="cmd.run",
-        kwargs={
-            "cmd": request.data["cmd"],
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    timeout = int(request.data["timeout"])
+    data = {
+        "func": "rawcmd",
+        "timeout": timeout,
+        "payload": {
+            "command": request.data["cmd"],
             "shell": request.data["shell"],
-            "timeout": request.data["timeout"],
         },
-    )
+    }
+    r = asyncio.run(agent.nats_cmd(data, timeout=timeout + 2))
 
     if r == "timeout":
         return notify_error("Unable to contact the agent")
-    elif r == "error" or not r:
-        return notify_error("Something went wrong")
 
     AuditLog.audit_raw_command(
         username=request.user.username,
@@ -244,29 +228,31 @@ def send_raw_cmd(request):
         shell=request.data["shell"],
     )
 
-    logger.info(f"The command {request.data['cmd']} was sent on agent {agent.hostname}")
     return Response(r)
 
 
 class AgentsTableList(generics.ListAPIView):
-    queryset = Agent.objects.prefetch_related("agentchecks").only(
-        "pk",
-        "hostname",
-        "agent_id",
-        "client",
-        "site",
-        "monitoring_type",
-        "description",
-        "needs_reboot",
-        "overdue_text_alert",
-        "overdue_email_alert",
-        "overdue_time",
-        "last_seen",
-        "boot_time",
-        "logged_in_username",
-        "last_logged_in_user",
-        "time_zone",
-        "maintenance_mode",
+    queryset = (
+        Agent.objects.select_related("site")
+        .prefetch_related("agentchecks")
+        .only(
+            "pk",
+            "hostname",
+            "agent_id",
+            "site",
+            "monitoring_type",
+            "description",
+            "needs_reboot",
+            "overdue_text_alert",
+            "overdue_email_alert",
+            "overdue_time",
+            "last_seen",
+            "boot_time",
+            "logged_in_username",
+            "last_logged_in_user",
+            "time_zone",
+            "maintenance_mode",
+        )
     )
     serializer_class = AgentTableSerializer
 
@@ -281,7 +267,7 @@ class AgentsTableList(generics.ListAPIView):
 
 @api_view()
 def list_agents_no_detail(request):
-    agents = Agent.objects.all()
+    agents = Agent.objects.select_related("site").only("pk", "hostname", "site")
     return Response(AgentHostnameSerializer(agents, many=True).data)
 
 
@@ -292,15 +278,15 @@ def agent_edit_details(request, pk):
 
 
 @api_view()
-def by_client(request, client):
+def by_client(request, clientpk):
     agents = (
-        Agent.objects.filter(client=client)
+        Agent.objects.select_related("site")
+        .filter(site__client_id=clientpk)
         .prefetch_related("agentchecks")
         .only(
             "pk",
             "hostname",
             "agent_id",
-            "client",
             "site",
             "monitoring_type",
             "description",
@@ -321,15 +307,15 @@ def by_client(request, client):
 
 
 @api_view()
-def by_site(request, client, site):
+def by_site(request, sitepk):
     agents = (
-        Agent.objects.filter(client=client, site=site)
+        Agent.objects.filter(site_id=sitepk)
+        .select_related("site")
         .prefetch_related("agentchecks")
         .only(
             "pk",
             "hostname",
             "agent_id",
-            "client",
             "site",
             "monitoring_type",
             "description",
@@ -374,32 +360,71 @@ def overdue_action(request):
     return Response(agent.hostname)
 
 
-@api_view(["POST"])
-def reboot_later(request):
-    agent = get_object_or_404(Agent, pk=request.data["pk"])
-    date_time = request.data["datetime"]
+class Reboot(APIView):
+    # reboot now
+    def post(self, request):
+        agent = get_object_or_404(Agent, pk=request.data["pk"])
+        if not agent.has_nats:
+            return notify_error("Requires agent version 1.1.0 or greater")
 
-    try:
-        obj = dt.datetime.strptime(date_time, "%Y-%m-%d %H:%M")
-    except Exception:
-        return notify_error("Invalid date")
+        r = asyncio.run(agent.nats_cmd({"func": "rebootnow"}, timeout=10))
+        if r != "ok":
+            return notify_error("Unable to contact the agent")
 
-    r = agent.schedule_reboot(obj)
+        return Response("ok")
 
-    if r == "timeout":
-        return notify_error("Unable to contact the agent")
-    elif r == "failed":
-        return notify_error("Something went wrong")
+    # reboot later
+    def patch(self, request):
+        agent = get_object_or_404(Agent, pk=request.data["pk"])
+        if not agent.has_gotasks:
+            return notify_error("Requires agent version 1.1.1 or greater")
 
-    return Response(r["msg"])
+        try:
+            obj = dt.datetime.strptime(request.data["datetime"], "%Y-%m-%d %H:%M")
+        except Exception:
+            return notify_error("Invalid date")
+
+        task_name = "TacticalRMM_SchedReboot_" + "".join(
+            random.choice(string.ascii_letters) for _ in range(10)
+        )
+
+        nats_data = {
+            "func": "schedtask",
+            "schedtaskpayload": {
+                "type": "schedreboot",
+                "trigger": "once",
+                "name": task_name,
+                "year": int(dt.datetime.strftime(obj, "%Y")),
+                "month": dt.datetime.strftime(obj, "%B"),
+                "day": int(dt.datetime.strftime(obj, "%d")),
+                "hour": int(dt.datetime.strftime(obj, "%H")),
+                "min": int(dt.datetime.strftime(obj, "%M")),
+            },
+        }
+
+        if pyver.parse(agent.version) >= pyver.parse("1.1.2"):
+            nats_data["schedtaskpayload"]["deleteafter"] = True
+
+        r = asyncio.run(agent.nats_cmd(nats_data, timeout=10))
+        if r != "ok":
+            return notify_error(r)
+
+        details = {"taskname": task_name, "time": str(obj)}
+        PendingAction.objects.create(
+            agent=agent, action_type="schedreboot", details=details
+        )
+        nice_time = dt.datetime.strftime(obj, "%B %d, %Y at %I:%M %p")
+        return Response(
+            {"time": nice_time, "agent": agent.hostname, "task_name": task_name}
+        )
 
 
 @api_view(["POST"])
 def install_agent(request):
     from knox.models import AuthToken
 
-    client = get_object_or_404(Client, client=request.data["client"])
-    site = get_object_or_404(Site, client=client, site=request.data["site"])
+    client_id = request.data["client"]
+    site_id = request.data["site"]
     version = settings.LATEST_AGENT_VER
     arch = request.data["arch"]
 
@@ -454,8 +479,8 @@ def install_agent(request):
             "build",
             f"-ldflags=\"-X 'main.Inno={inno}'",
             f"-X 'main.Api={api}'",
-            f"-X 'main.Client={client.pk}'",
-            f"-X 'main.Site={site.pk}'",
+            f"-X 'main.Client={client_id}'",
+            f"-X 'main.Site={site_id}'",
             f"-X 'main.Atype={atype}'",
             f"-X 'main.Rdp={rdp}'",
             f"-X 'main.Ping={ping}'",
@@ -552,7 +577,7 @@ def install_agent(request):
             "&&",
             "timeout",
             "/t",
-            "20",
+            "10",
             "/nobreak",
             ">",
             "NUL",
@@ -563,9 +588,9 @@ def install_agent(request):
             "--api",
             request.data["api"],
             "--client-id",
-            client.pk,
+            client_id,
             "--site-id",
-            site.pk,
+            site_id,
             "--agent-type",
             request.data["agenttype"],
             "--auth",
@@ -597,8 +622,8 @@ def install_agent(request):
 
         replace_dict = {
             "innosetupchange": inno,
-            "clientchange": str(client.pk),
-            "sitechange": str(site.pk),
+            "clientchange": str(client_id),
+            "sitechange": str(site_id),
             "apichange": request.data["api"],
             "atypechange": request.data["agenttype"],
             "powerchange": str(request.data["power"]),
@@ -638,35 +663,60 @@ def install_agent(request):
 @api_view(["POST"])
 def recover(request):
     agent = get_object_or_404(Agent, pk=request.data["pk"])
+    mode = request.data["mode"]
 
     if pyver.parse(agent.version) <= pyver.parse("0.9.5"):
         return notify_error("Only available in agent version greater than 0.9.5")
 
+    if not agent.has_nats:
+        if mode == "tacagent" or mode == "checkrunner" or mode == "rpc":
+            return notify_error("Requires agent version 1.1.0 or greater")
+
+    # attempt a realtime recovery if supported, otherwise fall back to old recovery method
+    if agent.has_nats:
+        if (
+            mode == "tacagent"
+            or mode == "checkrunner"
+            or mode == "salt"
+            or mode == "mesh"
+        ):
+            data = {"func": "recover", "payload": {"mode": mode}}
+            r = asyncio.run(agent.nats_cmd(data, timeout=10))
+            if r == "ok":
+                return Response("Successfully completed recovery")
+
     if agent.recoveryactions.filter(last_run=None).exists():
         return notify_error(
             "A recovery action is currently pending. Please wait for the next agent check-in."
         )
 
-    if request.data["mode"] == "command" and not request.data["cmd"]:
+    if mode == "command" and not request.data["cmd"]:
         return notify_error("Command is required")
 
+    # if we've made it this far and realtime recovery didn't work,
+    # tacagent service is the fallback recovery so we obv can't use that to recover itself if it's down
+    if mode == "tacagent":
+        return notify_error(
+            "Requires RPC service to be functional. Please recover that first"
+        )
+
+    # we should only get here if all other methods fail
     RecoveryAction(
         agent=agent,
-        mode=request.data["mode"],
-        command=request.data["cmd"] if request.data["mode"] == "command" else None,
+        mode=mode,
+        command=request.data["cmd"] if mode == "command" else None,
     ).save()
 
-    return Response(f"Recovery will be attempted on the agent's next check-in")
+    return Response("Recovery will be attempted on the agent's next check-in")
 
 
 @api_view(["POST"])
 def run_script(request):
     agent = get_object_or_404(Agent, pk=request.data["pk"])
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
     script = get_object_or_404(Script, pk=request.data["scriptPK"])
-
     output = request.data["output"]
-    args = request.data["args"]
-
     req_timeout = int(request.data["timeout"]) + 3
 
     AuditLog.audit_script_run(
@@ -675,75 +725,33 @@ def run_script(request):
         script=script.name,
     )
 
+    data = {
+        "func": "runscript",
+        "timeout": request.data["timeout"],
+        "script_args": request.data["args"],
+        "payload": {
+            "code": script.code,
+            "shell": script.shell,
+        },
+    }
+
     if output == "wait":
-        r = agent.salt_api_cmd(
-            timeout=req_timeout,
-            func="win_agent.run_script",
-            kwargs={
-                "filepath": script.filepath,
-                "filename": script.filename,
-                "shell": script.shell,
-                "timeout": request.data["timeout"],
-                "args": args,
-            },
-        )
-
-        if isinstance(r, dict):
-            if r["stdout"]:
-                return Response(r["stdout"])
-            elif r["stderr"]:
-                return Response(r["stderr"])
-            else:
-                try:
-                    r["retcode"]
-                except KeyError:
-                    return notify_error("Something went wrong")
-
-                return Response(f"Return code: {r['retcode']}")
-
-        else:
-            if r == "timeout":
-                return notify_error("Unable to contact the agent")
-            elif r == "error":
-                return notify_error("Something went wrong")
-            else:
-                return notify_error(str(r))
-
+        r = asyncio.run(agent.nats_cmd(data, timeout=req_timeout))
+        return Response(r)
     else:
-        data = {
-            "agentpk": agent.pk,
-            "scriptpk": script.pk,
-            "timeout": request.data["timeout"],
-            "args": args,
-        }
-        run_script_bg_task.delay(data)
+        asyncio.run(agent.nats_cmd(data, wait=False))
         return Response(f"{script.name} will now be run on {agent.hostname}")
 
 
-@api_view()
-def restart_mesh(request, pk):
-    agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(func="service.restart", arg="mesh agent", timeout=30)
-    if r == "timeout" or r == "error":
-        return notify_error("Unable to contact the agent")
-    elif isinstance(r, bool) and r:
-        return Response(f"Restarted Mesh Agent on {agent.hostname}")
-    else:
-        return notify_error(f"Failed to restart the Mesh Agent on {agent.hostname}")
-
-
 @api_view()
 def recover_mesh(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(
-        timeout=60,
-        func="cmd.run",
-        kwargs={
-            "cmd": r'"C:\\Program Files\\TacticalAgent\\tacticalrmm.exe" -m recovermesh',
-            "timeout": 55,
-        },
-    )
-    if r == "timeout" or r == "error":
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+
+    data = {"func": "recover", "payload": {"mode": "mesh"}}
+    r = asyncio.run(agent.nats_cmd(data, timeout=45))
+    if r != "ok":
         return notify_error("Unable to contact the agent")
 
     return Response(f"Repaired mesh agent on {agent.hostname}")
@@ -807,76 +815,44 @@ def bulk(request):
         return notify_error("Must select at least 1 agent")
 
     if request.data["target"] == "client":
-        client = get_object_or_404(Client, client=request.data["client"])
-        agents = Agent.objects.filter(client=client.client)
+        q = Agent.objects.filter(site__client_id=request.data["client"])
     elif request.data["target"] == "site":
-        client = get_object_or_404(Client, client=request.data["client"])
-        site = (
-            Site.objects.filter(client=client).filter(site=request.data["site"]).get()
-        )
-        agents = Agent.objects.filter(client=client.client).filter(site=site.site)
+        q = Agent.objects.filter(site_id=request.data["site"])
     elif request.data["target"] == "agents":
-        agents = Agent.objects.filter(pk__in=request.data["agentPKs"])
+        q = Agent.objects.filter(pk__in=request.data["agentPKs"])
     elif request.data["target"] == "all":
-        agents = Agent.objects.all()
+        q = Agent.objects.all()
     else:
         return notify_error("Something went wrong")
 
-    minions = [agent.salt_id for agent in agents]
+    minions = [agent.salt_id for agent in q]
+    agents = [agent.pk for agent in q]
+
+    AuditLog.audit_bulk_action(request.user, request.data["mode"], request.data)
 
     if request.data["mode"] == "command":
-        r = Agent.salt_batch_async(
-            minions=minions,
-            func="cmd.run_bg",
-            kwargs={
-                "cmd": request.data["cmd"],
-                "shell": request.data["shell"],
-                "timeout": request.data["timeout"],
-            },
+        handle_bulk_command_task.delay(
+            agents, request.data["cmd"], request.data["shell"], request.data["timeout"]
         )
-        if r == "timeout":
-            return notify_error("Salt API not running")
-        return Response(f"Command will now be run on {len(minions)} agents")
+        return Response(f"Command will now be run on {len(agents)} agents")
 
     elif request.data["mode"] == "script":
         script = get_object_or_404(Script, pk=request.data["scriptPK"])
-
-        if script.shell == "python":
-            r = Agent.salt_batch_async(
-                minions=minions,
-                func="win_agent.run_script",
-                kwargs={
-                    "filepath": script.filepath,
-                    "filename": script.filename,
-                    "shell": script.shell,
-                    "timeout": request.data["timeout"],
-                    "args": request.data["args"],
-                    "bg": True,
-                },
-            )
-            if r == "timeout":
-                return notify_error("Salt API not running")
-        else:
-            data = {
-                "minions": minions,
-                "scriptpk": script.pk,
-                "timeout": request.data["timeout"],
-                "args": request.data["args"],
-            }
-            run_bulk_script_task.delay(data)
-
-        return Response(f"{script.name} will now be run on {len(minions)} agents")
+        handle_bulk_script_task.delay(
+            script.pk, agents, request.data["args"], request.data["timeout"]
+        )
+        return Response(f"{script.name} will now be run on {len(agents)} agents")
 
     elif request.data["mode"] == "install":
         r = Agent.salt_batch_async(minions=minions, func="win_agent.install_updates")
         if r == "timeout":
             return notify_error("Salt API not running")
         return Response(
-            f"Pending updates will now be installed on {len(minions)} agents"
+            f"Pending updates will now be installed on {len(agents)} agents"
         )
     elif request.data["mode"] == "scan":
         bulk_check_for_updates_task.delay(minions=minions)
-        return Response(f"Patch status scan will now run on {len(minions)} agents")
+        return Response(f"Patch status scan will now run on {len(agents)} agents")
 
     return notify_error("Something went wrong")
 
@@ -904,14 +880,12 @@ def agent_counts(request):
 @api_view(["POST"])
 def agent_maintenance(request):
     if request.data["type"] == "Client":
-        client = Client.objects.get(pk=request.data["id"])
-        Agent.objects.filter(client=client.client).update(
+        Agent.objects.filter(site__client_id=request.data["id"]).update(
             maintenance_mode=request.data["action"]
         )
 
     elif request.data["type"] == "Site":
-        site = Site.objects.get(pk=request.data["id"])
-        Agent.objects.filter(client=site.client.client, site=site.site).update(
+        Agent.objects.filter(site_id=request.data["id"]).update(
             maintenance_mode=request.data["action"]
         )
 
@@ -924,3 +898,15 @@ def agent_maintenance(request):
         return notify_error("Invalid data")
 
     return Response("ok")
+
+
+class WMI(APIView):
+    def get(self, request, pk):
+        agent = get_object_or_404(Agent, pk=pk)
+        if pyver.parse(agent.version) < pyver.parse("1.1.2"):
+            return notify_error("Requires agent version 1.1.2 or greater")
+
+        r = asyncio.run(agent.nats_cmd({"func": "sysinfo"}, timeout=20))
+        if r != "ok":
+            return notify_error("Unable to contact the agent")
+        return Response("ok")

api/tacticalrmm/api/apps.py

@@ -1,5 +0,0 @@
-from django.apps import AppConfig
-
-
-class ApiConfig(AppConfig):
-    name = "api"

api/tacticalrmm/api/urls.py

@@ -1,11 +0,0 @@
-from django.urls import path
-from . import views
-from apiv3 import views as v3_views
-
-urlpatterns = [
-    path("triggerpatchscan/", views.trigger_patch_scan),
-    path("<int:pk>/checkrunner/", views.CheckRunner.as_view()),
-    path("<int:pk>/taskrunner/", views.TaskRunner.as_view()),
-    path("<int:pk>/saltinfo/", views.SaltInfo.as_view()),
-    path("<int:pk>/meshinfo/", v3_views.MeshInfo.as_view()),
-]

api/tacticalrmm/api/views.py

@@ -1,149 +0,0 @@
-from loguru import logger
-
-from django.conf import settings
-from django.shortcuts import get_object_or_404
-from django.utils import timezone as djangotime
-
-from rest_framework.response import Response
-from rest_framework.views import APIView
-from rest_framework.authentication import TokenAuthentication
-from rest_framework.permissions import IsAuthenticated
-from rest_framework.decorators import (
-    api_view,
-    authentication_classes,
-    permission_classes,
-)
-
-from agents.models import Agent
-from checks.models import Check
-from autotasks.models import AutomatedTask
-
-from winupdate.tasks import check_for_updates_task
-
-from autotasks.serializers import TaskRunnerGetSerializer, TaskRunnerPatchSerializer
-from checks.serializers import CheckRunnerGetSerializer, CheckResultsSerializer
-
-
-logger.configure(**settings.LOG_CONFIG)
-
-
-@api_view(["PATCH"])
-@authentication_classes((TokenAuthentication,))
-@permission_classes((IsAuthenticated,))
-def trigger_patch_scan(request):
-    agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
-    reboot_policy = agent.get_patch_policy().reboot_after_install
-    reboot = False
-
-    if reboot_policy == "always":
-        reboot = True
-
-    if request.data["reboot"]:
-        if reboot_policy == "required":
-            reboot = True
-        elif reboot_policy == "never":
-            agent.needs_reboot = True
-            agent.save(update_fields=["needs_reboot"])
-
-    if reboot:
-        r = agent.salt_api_cmd(
-            timeout=15,
-            func="system.reboot",
-            arg=7,
-            kwargs={"in_seconds": True},
-        )
-
-        if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
-            check_for_updates_task.apply_async(
-                queue="wupdate", kwargs={"pk": agent.pk, "wait": False}
-            )
-        else:
-            logger.info(f"{agent.hostname} is rebooting after updates were installed.")
-    else:
-        check_for_updates_task.apply_async(
-            queue="wupdate", kwargs={"pk": agent.pk, "wait": False}
-        )
-
-    return Response("ok")
-
-
-class CheckRunner(APIView):
-    """
-    For windows agent
-    """
-
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [IsAuthenticated]
-
-    def get(self, request, pk):
-        agent = get_object_or_404(Agent, pk=pk)
-        checks = Check.objects.filter(agent__pk=pk, overriden_by_policy=False)
-
-        ret = {
-            "agent": agent.pk,
-            "check_interval": agent.check_interval,
-            "checks": CheckRunnerGetSerializer(checks, many=True).data,
-        }
-        return Response(ret)
-
-    def patch(self, request, pk):
-        check = get_object_or_404(Check, pk=pk)
-
-        if check.check_type != "cpuload" and check.check_type != "memory":
-            serializer = CheckResultsSerializer(
-                instance=check, data=request.data, partial=True
-            )
-            serializer.is_valid(raise_exception=True)
-            serializer.save(last_run=djangotime.now())
-
-        else:
-            check.last_run = djangotime.now()
-            check.save(update_fields=["last_run"])
-
-        check.handle_check(request.data)
-
-        return Response("ok")
-
-
-class TaskRunner(APIView):
-    """
-    For the windows python agent
-    """
-
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [IsAuthenticated]
-
-    def get(self, request, pk):
-
-        task = get_object_or_404(AutomatedTask, pk=pk)
-        return Response(TaskRunnerGetSerializer(task).data)
-
-    def patch(self, request, pk):
-        task = get_object_or_404(AutomatedTask, pk=pk)
-
-        serializer = TaskRunnerPatchSerializer(
-            instance=task, data=request.data, partial=True
-        )
-        serializer.is_valid(raise_exception=True)
-        serializer.save(last_run=djangotime.now())
-        return Response("ok")
-
-
-class SaltInfo(APIView):
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [IsAuthenticated]
-
-    def get(self, request, pk):
-        agent = get_object_or_404(Agent, pk=pk)
-        ret = {
-            "latestVer": settings.LATEST_SALT_VER,
-            "currentVer": agent.salt_ver,
-            "salt_id": agent.salt_id,
-        }
-        return Response(ret)
-
-    def patch(self, request, pk):
-        agent = get_object_or_404(Agent, pk=pk)
-        agent.salt_ver = request.data["ver"]
-        agent.save(update_fields=["salt_ver"])
-        return Response("ok")

api/tacticalrmm/apiv2/tests.py

@@ -1,17 +1,20 @@
 from tacticalrmm.test import TacticalTestCase
 from unittest.mock import patch
+from model_bakery import baker
+from itertools import cycle
 
 
 class TestAPIv2(TacticalTestCase):
     def setUp(self):
         self.authenticate()
         self.setup_coresettings()
-        self.agent_setup()
 
     @patch("agents.models.Agent.salt_api_cmd")
     def test_sync_modules(self, mock_ret):
+        # setup data
+        agent = baker.make_recipe("agents.agent")
         url = "/api/v2/saltminion/"
-        payload = {"agent_id": self.agent.agent_id}
+        payload = {"agent_id": agent.agent_id}
 
         mock_ret.return_value = "error"
         r = self.client.patch(url, payload, format="json")

api/tacticalrmm/apiv3/tests.py

@@ -2,11 +2,18 @@ import os
 import json
 
 from django.conf import settings
-from tacticalrmm.test import BaseTestCase
+from tacticalrmm.test import TacticalTestCase
 from unittest.mock import patch
+from model_bakery import baker
+from itertools import cycle
 
 
-class TestAPIv3(BaseTestCase):
+class TestAPIv3(TacticalTestCase):
+    def setUp(self):
+        self.authenticate()
+        self.setup_coresettings()
+        self.agent = baker.make_recipe("agents.agent")
+
     def test_get_checks(self):
         url = f"/api/v3/{self.agent.agent_id}/checkrunner/"
 
@@ -38,15 +45,11 @@ class TestAPIv3(BaseTestCase):
 
     def test_get_mesh_info(self):
         url = f"/api/v3/{self.agent.pk}/meshinfo/"
-        url2 = f"/api/v1/{self.agent.pk}/meshinfo/"
 
         r = self.client.get(url)
         self.assertEqual(r.status_code, 200)
-        r = self.client.get(url2)
-        self.assertEqual(r.status_code, 200)
 
         self.check_not_authenticated("get", url)
-        self.check_not_authenticated("get", url2)
 
     def test_get_winupdater(self):
         url = f"/api/v3/{self.agent.agent_id}/winupdater/"

api/tacticalrmm/apiv3/urls.py

@@ -14,4 +14,6 @@ urlpatterns = [
     path("newagent/", views.NewAgent.as_view()),
     path("winupdater/", views.WinUpdater.as_view()),
     path("<str:agentid>/winupdater/", views.WinUpdater.as_view()),
+    path("software/", views.Software.as_view()),
+    path("installer/", views.Installer.as_view()),
 ]

api/tacticalrmm/apiv3/views.py

@@ -1,6 +1,8 @@
+import asyncio
 import os
 import requests
 from loguru import logger
+from packaging import version as pyver
 
 from django.conf import settings
 from django.shortcuts import get_object_or_404
@@ -16,10 +18,9 @@ from rest_framework.authtoken.models import Token
 from agents.models import Agent
 from checks.models import Check
 from autotasks.models import AutomatedTask
-from winupdate.models import WinUpdate
 from accounts.models import User
-from clients.models import Client, Site
 from winupdate.models import WinUpdatePolicy
+from software.models import InstalledSoftware
 from checks.serializers import CheckRunnerGetSerializerV3
 from agents.serializers import WinAgentSerializer
 from autotasks.serializers import TaskGOGetSerializer, TaskRunnerPatchSerializer
@@ -28,13 +29,12 @@ from winupdate.serializers import ApprovedUpdateSerializer
 from agents.tasks import (
     agent_recovery_email_task,
     agent_recovery_sms_task,
-    get_wmi_detail_task,
     sync_salt_modules_task,
 )
 from winupdate.tasks import check_for_updates_task
-from software.tasks import get_installed_software, install_chocolatey
+from software.tasks import install_chocolatey
 from checks.utils import bytes2human
-from tacticalrmm.utils import notify_error
+from tacticalrmm.utils import notify_error, reload_nats, filter_software, SoftwareList
 
 logger.configure(**settings.LOG_CONFIG)
 
@@ -98,6 +98,17 @@ class Hello(APIView):
             recovery.save(update_fields=["last_run"])
             return Response(recovery.send())
 
+        # handle agent update
+        if agent.pendingactions.filter(
+            action_type="agentupdate", status="pending"
+        ).exists():
+            update = agent.pendingactions.filter(
+                action_type="agentupdate", status="pending"
+            ).last()
+            update.status = "completed"
+            update.save(update_fields=["status"])
+            return Response(update.details)
+
         # get any pending actions
         if agent.pendingactions.filter(status="pending").exists():
             agent.handle_pending_actions()
@@ -112,8 +123,6 @@ class Hello(APIView):
         serializer.save(last_seen=djangotime.now())
 
         sync_salt_modules_task.delay(agent.pk)
-        get_installed_software.delay(agent.pk)
-        get_wmi_detail_task.delay(agent.pk)
         check_for_updates_task.apply_async(
             queue="wupdate", kwargs={"pk": agent.pk, "wait": True}
         )
@@ -134,8 +143,6 @@ class CheckRunner(APIView):
 
     def get(self, request, agentid):
         agent = get_object_or_404(Agent, agent_id=agentid)
-        agent.last_seen = djangotime.now()
-        agent.save(update_fields=["last_seen"])
         checks = Check.objects.filter(agent__pk=agent.pk, overriden_by_policy=False)
 
         ret = {
@@ -146,10 +153,23 @@ class CheckRunner(APIView):
         return Response(ret)
 
     def patch(self, request):
+        from logs.models import AuditLog
+
         check = get_object_or_404(Check, pk=request.data["id"])
         check.last_run = djangotime.now()
         check.save(update_fields=["last_run"])
         status = check.handle_checkv2(request.data)
+
+        # create audit entry
+        AuditLog.objects.create(
+            username=check.agent.hostname,
+            agent=check.agent.hostname,
+            object_type="agent",
+            action="check_run",
+            message=f"{check.readable_desc} was run on {check.agent.hostname}. Status: {status}",
+            after_value=Check.serialize(check),
+        )
+
         return Response(status)
 
 
@@ -167,6 +187,8 @@ class TaskRunner(APIView):
         return Response(TaskGOGetSerializer(task).data)
 
     def patch(self, request, pk, agentid):
+        from logs.models import AuditLog
+
         agent = get_object_or_404(Agent, agent_id=agentid)
         task = get_object_or_404(AutomatedTask, pk=pk)
 
@@ -175,6 +197,17 @@ class TaskRunner(APIView):
         )
         serializer.is_valid(raise_exception=True)
         serializer.save(last_run=djangotime.now())
+
+        new_task = AutomatedTask.objects.get(pk=task.pk)
+        AuditLog.objects.create(
+            username=agent.hostname,
+            agent=agent.hostname,
+            object_type="agent",
+            action="task_run",
+            message=f"Scheduled Task {task.name} was run on {agent.hostname}",
+            after_value=AutomatedTask.serialize(new_task),
+        )
+
         return Response("ok")
 
 
@@ -308,21 +341,16 @@ class WinUpdater(APIView):
                 agent.save(update_fields=["needs_reboot"])
 
         if reboot:
-            r = agent.salt_api_cmd(
-                timeout=15,
-                func="system.reboot",
-                arg=7,
-                kwargs={"in_seconds": True},
-            )
-
-            if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
-                check_for_updates_task.apply_async(
-                    queue="wupdate", kwargs={"pk": agent.pk, "wait": False}
-                )
+            if agent.has_nats:
+                asyncio.run(agent.nats_cmd({"func": "rebootnow"}, wait=False))
             else:
-                logger.info(
-                    f"{agent.hostname} is rebooting after updates were installed."
+                agent.salt_api_async(
+                    func="system.reboot",
+                    arg=7,
+                    kwargs={"in_seconds": True},
                 )
+
+            logger.info(f"{agent.hostname} is rebooting after updates were installed.")
         else:
             check_for_updates_task.apply_async(
                 queue="wupdate", kwargs={"pk": agent.pk, "wait": False}
@@ -356,7 +384,15 @@ class MeshInfo(APIView):
 
     def patch(self, request, pk):
         agent = get_object_or_404(Agent, pk=pk)
-        agent.mesh_node_id = request.data["nodeidhex"]
+
+        if "nodeidhex" in request.data:
+            # agent <= 1.1.0
+            nodeid = request.data["nodeidhex"]
+        else:
+            # agent >= 1.1.1
+            nodeid = request.data["nodeid"]
+
+        agent.mesh_node_id = nodeid
         agent.save(update_fields=["mesh_node_id"])
         return Response("ok")
 
@@ -387,31 +423,9 @@ class MeshExe(APIView):
 
 
 class NewAgent(APIView):
-    """ For the installer """
-
     def post(self, request):
-        """
-        Creates and returns the agents auth token
-        which is stored in the agent's local db
-        and used to authenticate every agent request
-        """
+        from logs.models import AuditLog
 
-        if "agent_id" not in request.data:
-            return notify_error("Invalid payload")
-
-        agentid = request.data["agent_id"]
-        if Agent.objects.filter(agent_id=agentid).exists():
-            return notify_error(
-                "Agent already exists. Remove old agent first if trying to re-install"
-            )
-
-        user = User.objects.create_user(
-            username=agentid, password=User.objects.make_random_password(60)
-        )
-        token = Token.objects.create(user=user)
-        return Response({"token": token.key})
-
-    def patch(self, request):
         """ Creates the agent """
 
         if Agent.objects.filter(agent_id=request.data["agent_id"]).exists():
@@ -419,14 +433,10 @@ class NewAgent(APIView):
                 "Agent already exists. Remove old agent first if trying to re-install"
             )
 
-        client = get_object_or_404(Client, pk=int(request.data["client"]))
-        site = get_object_or_404(Site, pk=int(request.data["site"]))
-
         agent = Agent(
             agent_id=request.data["agent_id"],
             hostname=request.data["hostname"],
-            client=client.client,
-            site=site.site,
+            site_id=int(request.data["site"]),
             monitoring_type=request.data["monitoring_type"],
             description=request.data["description"],
             mesh_node_id=request.data["mesh_node_id"],
@@ -436,13 +446,78 @@ class NewAgent(APIView):
         agent.salt_id = f"{agent.hostname}-{agent.pk}"
         agent.save(update_fields=["salt_id"])
 
+        user = User.objects.create_user(
+            username=request.data["agent_id"],
+            agent=agent,
+            password=User.objects.make_random_password(60),
+        )
+
+        token = Token.objects.create(user=user)
+
         if agent.monitoring_type == "workstation":
             WinUpdatePolicy(agent=agent, run_time_days=[5, 6]).save()
         else:
             WinUpdatePolicy(agent=agent).save()
 
+        reload_nats()
+
         # Generate policies for new agent
         agent.generate_checks_from_policies()
         agent.generate_tasks_from_policies()
 
-        return Response({"pk": agent.pk, "saltid": f"{agent.hostname}-{agent.pk}"})
+        # create agent install audit record
+        AuditLog.objects.create(
+            username=request.user,
+            agent=agent.hostname,
+            object_type="agent",
+            action="agent_install",
+            message=f"{request.user} installed new agent {agent.hostname}",
+            after_value=Agent.serialize(agent),
+        )
+
+        return Response(
+            {
+                "pk": agent.pk,
+                "saltid": f"{agent.hostname}-{agent.pk}",
+                "token": token.key,
+            }
+        )
+
+
+class Software(APIView):
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request):
+        agent = get_object_or_404(Agent, agent_id=request.data["agent_id"])
+        raw: SoftwareList = request.data["software"]
+        if not isinstance(raw, list):
+            return notify_error("err")
+
+        sw = filter_software(raw)
+        if not InstalledSoftware.objects.filter(agent=agent).exists():
+            InstalledSoftware(agent=agent, software=sw).save()
+        else:
+            s = agent.installedsoftware_set.first()
+            s.software = sw
+            s.save(update_fields=["software"])
+
+        return Response("ok")
+
+
+class Installer(APIView):
+    def get(self, request):
+        # used to check if token is valid. will return 401 if not
+        return Response("ok")
+
+    def post(self, request):
+        if "version" not in request.data:
+            return notify_error("Invalid data")
+
+        ver = request.data["version"]
+        if pyver.parse(ver) < pyver.parse(settings.LATEST_AGENT_VER):
+            return notify_error(
+                f"Old installer detected (version {ver} ). Latest version is {settings.LATEST_AGENT_VER} Please generate a new installer from the RMM"
+            )
+
+        return Response("ok")

api/tacticalrmm/automation/admin.py

@@ -1,6 +1,5 @@
 from django.contrib import admin
 
-from .models import Policy, PolicyExclusions
+from .models import Policy
 
 admin.site.register(Policy)
-admin.site.register(PolicyExclusions)

api/tacticalrmm/automation/migrations/0006_delete_policyexclusions.py

@@ -0,0 +1,16 @@
+# Generated by Django 3.1.2 on 2020-11-02 19:13
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('automation', '0005_auto_20200922_1344'),
+    ]
+
+    operations = [
+        migrations.DeleteModel(
+            name='PolicyExclusions',
+        ),
+    ]

api/tacticalrmm/automation/models.py

@@ -32,16 +32,15 @@ class Policy(BaseAuditModel):
 
         filtered_agents_pks = Policy.objects.none()
 
-        for site in explicit_sites:
-            if site.client not in explicit_clients:
-                filtered_agents_pks |= Agent.objects.filter(
-                    client=site.client.client,
-                    site=site.site,
-                    monitoring_type=mon_type,
-                ).values_list("pk", flat=True)
+        filtered_agents_pks |= Agent.objects.filter(
+            site__in=[
+                site for site in explicit_sites if site.client not in explicit_clients
+            ],
+            monitoring_type=mon_type,
+        ).values_list("pk", flat=True)
 
         filtered_agents_pks |= Agent.objects.filter(
-            client__in=[client.client for client in explicit_clients],
+            site__client__in=[client for client in explicit_clients],
             monitoring_type=mon_type,
         ).values_list("pk", flat=True)
 
@@ -68,8 +67,8 @@ class Policy(BaseAuditModel):
         ]
 
         # Get policies applied to agent and agent site and client
-        client = Client.objects.get(client=agent.client)
-        site = Site.objects.filter(client=client).get(site=agent.site)
+        client = agent.client
+        site = agent.site
 
         default_policy = None
         client_policy = None
@@ -121,8 +120,8 @@ class Policy(BaseAuditModel):
         ]
 
         # Get policies applied to agent and agent site and client
-        client = Client.objects.get(client=agent.client)
-        site = Site.objects.filter(client=client).get(site=agent.site)
+        client = agent.client
+        site = agent.site
 
         default_policy = None
         client_policy = None
@@ -300,11 +299,3 @@ class Policy(BaseAuditModel):
         if tasks:
             for task in tasks:
                 task.create_policy_task(agent)
-
-
-class PolicyExclusions(models.Model):
-    policy = models.ForeignKey(
-        Policy, related_name="exclusions", on_delete=models.CASCADE
-    )
-    agents = models.ManyToManyField(Agent, related_name="policy_exclusions")
-    sites = models.ManyToManyField(Site, related_name="policy_exclusions")

api/tacticalrmm/automation/serializers.py

@@ -5,6 +5,9 @@ from rest_framework.serializers import (
     ReadOnlyField,
 )
 
+from clients.serializers import ClientSerializer, SiteSerializer
+from agents.serializers import AgentHostnameSerializer
+
 from .models import Policy
 from agents.models import Agent
 from autotasks.models import AutomatedTask
@@ -21,11 +24,11 @@ class PolicySerializer(ModelSerializer):
 
 class PolicyTableSerializer(ModelSerializer):
 
-    server_clients = StringRelatedField(many=True, read_only=True)
-    server_sites = StringRelatedField(many=True, read_only=True)
-    workstation_clients = StringRelatedField(many=True, read_only=True)
-    workstation_sites = StringRelatedField(many=True, read_only=True)
-    agents = StringRelatedField(many=True, read_only=True)
+    server_clients = ClientSerializer(many=True, read_only=True)
+    server_sites = SiteSerializer(many=True, read_only=True)
+    workstation_clients = ClientSerializer(many=True, read_only=True)
+    workstation_sites = SiteSerializer(many=True, read_only=True)
+    agents = AgentHostnameSerializer(many=True, read_only=True)
     default_server_policy = ReadOnlyField(source="is_default_server_policy")
     default_workstation_policy = ReadOnlyField(source="is_default_workstation_policy")
     agents_count = SerializerMethodField(read_only=True)
@@ -43,7 +46,7 @@ class PolicyTableSerializer(ModelSerializer):
 class PolicyOverviewSerializer(ModelSerializer):
     class Meta:
         model = Client
-        fields = ("pk", "client", "sites", "workstation_policy", "server_policy")
+        fields = ("pk", "name", "sites", "workstation_policy", "server_policy")
         depth = 2
 
 

api/tacticalrmm/automation/tests.py

@@ -71,8 +71,8 @@ class TestPolicyViews(TacticalTestCase):
 
         # create policy with tasks and checks
         policy = baker.make("automation.Policy")
-        checks = self.create_checks(policy=policy)
-        tasks = baker.make("autotasks.AutomatedTask", policy=policy, _quantity=3)
+        self.create_checks(policy=policy)
+        baker.make("autotasks.AutomatedTask", policy=policy, _quantity=3)
 
         # test copy tasks and checks to another policy
         data = {
@@ -152,7 +152,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # create policy with tasks
         policy = baker.make("automation.Policy")
-        tasks = baker.make("autotasks.AutomatedTask", policy=policy, _quantity=3)
+        baker.make("autotasks.AutomatedTask", policy=policy, _quantity=3)
         url = f"/automation/{policy.pk}/policyautomatedtasks/"
 
         resp = self.client.get(url, format="json")
@@ -202,6 +202,8 @@ class TestPolicyViews(TacticalTestCase):
         self.check_not_authenticated("patch", url)
 
     def test_policy_overview(self):
+        from clients.models import Client
+
         url = "/automation/policies/overview/"
 
         policies = baker.make(
@@ -213,7 +215,7 @@ class TestPolicyViews(TacticalTestCase):
             workstation_policy=cycle(policies),
             _quantity=5,
         )
-        sites = baker.make(
+        baker.make(
             "clients.Site",
             client=cycle(clients),
             server_policy=cycle(policies),
@@ -221,8 +223,9 @@ class TestPolicyViews(TacticalTestCase):
             _quantity=4,
         )
 
-        sites = baker.make("clients.Site", client=cycle(clients), _quantity=3)
+        baker.make("clients.Site", client=cycle(clients), _quantity=3)
         resp = self.client.get(url, format="json")
+        clients = Client.objects.all()
         serializer = PolicyOverviewSerializer(clients, many=True)
 
         self.assertEqual(resp.status_code, 200)
@@ -256,31 +259,31 @@ class TestPolicyViews(TacticalTestCase):
 
         # data setup
         policy = baker.make("automation.Policy")
-        client = baker.make("clients.Client", client="Test Client")
-        site = baker.make("clients.Site", client=client, site="Test Site")
-        agent = baker.make_recipe("agents.agent", client=client.client, site=site.site)
+        client = baker.make("clients.Client")
+        site = baker.make("clients.Site", client=client)
+        agent = baker.make_recipe("agents.agent", site=site)
 
         # test add client to policy data
         client_server_payload = {
             "type": "client",
-            "pk": client.pk,
+            "pk": agent.client.pk,
             "server_policy": policy.pk,
         }
         client_workstation_payload = {
             "type": "client",
-            "pk": client.pk,
+            "pk": agent.client.pk,
             "workstation_policy": policy.pk,
         }
 
         # test add site to policy data
         site_server_payload = {
             "type": "site",
-            "pk": site.pk,
+            "pk": agent.site.pk,
             "server_policy": policy.pk,
         }
         site_workstation_payload = {
             "type": "site",
-            "pk": site.pk,
+            "pk": agent.site.pk,
             "workstation_policy": policy.pk,
         }
 
@@ -293,7 +296,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": client.client},
+            location={"site__client_id": client.id},
             mon_type="server",
             clear=True,
             create_tasks=True,
@@ -306,7 +309,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": client.client},
+            location={"site__client_id": client.id},
             mon_type="workstation",
             clear=True,
             create_tasks=True,
@@ -319,7 +322,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": site.client.client, "site": site.site},
+            location={"site_id": site.id},
             mon_type="server",
             clear=True,
             create_tasks=True,
@@ -332,7 +335,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": site.client.client, "site": site.site},
+            location={"site_id": site.id},
             mon_type="workstation",
             clear=True,
             create_tasks=True,
@@ -391,7 +394,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": client.client},
+            location={"site__client_id": client.id},
             mon_type="server",
             clear=True,
             create_tasks=True,
@@ -404,7 +407,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": client.client},
+            location={"site__client_id": client.id},
             mon_type="workstation",
             clear=True,
             create_tasks=True,
@@ -417,7 +420,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": site.client.client, "site": site.site},
+            location={"site_id": site.id},
             mon_type="server",
             clear=True,
             create_tasks=True,
@@ -430,7 +433,7 @@ class TestPolicyViews(TacticalTestCase):
 
         # called because the relation changed
         mock_checks_location_task.assert_called_with(
-            location={"client": site.client.client, "site": site.site},
+            location={"site_id": site.id},
             mon_type="workstation",
             clear=True,
             create_tasks=True,
@@ -471,14 +474,14 @@ class TestPolicyViews(TacticalTestCase):
 
         self.check_not_authenticated("post", url)
 
-    def test_relation_by_type(self):
+    def test_get_relation_by_type(self):
         url = f"/automation/related/"
 
         # data setup
         policy = baker.make("automation.Policy")
-        client = baker.make("clients.Client", client="Test Client")
-        site = baker.make("clients.Site", client=client, site="Test Site")
-        agent = baker.make_recipe("agents.agent", client=client.client, site=site.site)
+        client = baker.make("clients.Client", workstation_policy=policy)
+        site = baker.make("clients.Site", server_policy=policy)
+        agent = baker.make_recipe("agents.agent", site=site, policy=policy)
 
         client_payload = {"type": "client", "pk": client.pk}
 
@@ -621,43 +624,38 @@ class TestPolicyViews(TacticalTestCase):
             "reprocess_failed_inherit": True,
         }
 
-        # create agents in sites
-        clients = baker.make("clients.Client", client=seq("Client"), _quantity=3)
-        sites = baker.make(
-            "clients.Site", client=cycle(clients), site=seq("Site"), _quantity=6
-        )
-
+        clients = baker.make("clients.Client", _quantity=6)
+        sites = baker.make("clients.Site", client=cycle(clients), _quantity=10)
         agents = baker.make_recipe(
             "agents.agent",
-            client=cycle([x.client for x in clients]),
-            site=cycle([x.site for x in sites]),
+            site=cycle(sites),
             _quantity=6,
         )
 
         # create patch policies
-        patch_policies = baker.make_recipe(
+        baker.make_recipe(
             "winupdate.winupdate_approve", agent=cycle(agents), _quantity=6
         )
 
         # test reset agents in site
-        data = {"client": clients[0].client, "site": "Site0"}
+        data = {"site": sites[0].id}
 
         resp = self.client.patch(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
 
-        agents = Agent.objects.filter(client=clients[0].client, site="Site0")
+        agents = Agent.objects.filter(site=sites[0])
 
         for agent in agents:
             for k, v in inherit_fields.items():
                 self.assertEqual(getattr(agent.winupdatepolicy.get(), k), v)
 
         # test reset agents in client
-        data = {"client": clients[1].client}
+        data = {"client": clients[1].id}
 
         resp = self.client.patch(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
 
-        agents = Agent.objects.filter(client=clients[1].client)
+        agents = Agent.objects.filter(site__client=clients[1])
 
         for agent in agents:
             for k, v in inherit_fields.items():
@@ -703,40 +701,24 @@ class TestPolicyTasks(TacticalTestCase):
     def test_policy_related(self):
 
         # Get Site and Client from an agent in list
-        clients = baker.make("clients.Client", client=seq("Client"), _quantity=5)
-        sites = baker.make(
-            "clients.Site", client=cycle(clients), site=seq("Site"), _quantity=25
-        )
+        clients = baker.make("clients.Client", _quantity=5)
+        sites = baker.make("clients.Site", client=cycle(clients), _quantity=25)
         server_agents = baker.make_recipe(
             "agents.server_agent",
-            client=cycle([x.client for x in clients]),
-            site=seq("Site"),
+            site=cycle(sites),
             _quantity=25,
         )
         workstation_agents = baker.make_recipe(
             "agents.workstation_agent",
-            client=cycle([x.client for x in clients]),
-            site=seq("Site"),
+            site=cycle(sites),
             _quantity=25,
         )
 
-        server_client = clients[3]
-        server_site = server_client.sites.all()[3]
-        workstation_client = clients[1]
-        workstation_site = server_client.sites.all()[2]
-        server_agent = baker.make_recipe(
-            "agents.server_agent", client=server_client.client, site=server_site.site
-        )
-        workstation_agent = baker.make_recipe(
-            "agents.workstation_agent",
-            client=workstation_client.client,
-            site=workstation_site.site,
-        )
         policy = baker.make("automation.Policy", active=True)
 
         # Add Client to Policy
-        policy.server_clients.add(server_client)
-        policy.workstation_clients.add(workstation_client)
+        policy.server_clients.add(server_agents[13].client)
+        policy.workstation_clients.add(workstation_agents[15].client)
 
         resp = self.client.get(
             f"/automation/policies/{policy.pk}/related/", format="json"
@@ -747,19 +729,19 @@ class TestPolicyTasks(TacticalTestCase):
         self.assertEquals(len(resp.data["server_sites"]), 5)
         self.assertEquals(len(resp.data["workstation_clients"]), 1)
         self.assertEquals(len(resp.data["workstation_sites"]), 5)
-        self.assertEquals(len(resp.data["agents"]), 12)
+        self.assertEquals(len(resp.data["agents"]), 10)
 
         # Add Site to Policy and the agents and sites length shouldn't change
-        policy.server_sites.add(server_site)
-        policy.workstation_sites.add(workstation_site)
+        policy.server_sites.add(server_agents[13].site)
+        policy.workstation_sites.add(workstation_agents[15].site)
         self.assertEquals(len(resp.data["server_sites"]), 5)
         self.assertEquals(len(resp.data["workstation_sites"]), 5)
-        self.assertEquals(len(resp.data["agents"]), 12)
+        self.assertEquals(len(resp.data["agents"]), 10)
 
         # Add Agent to Policy and the agents length shouldn't change
-        policy.agents.add(server_agent)
-        policy.agents.add(workstation_agent)
-        self.assertEquals(len(resp.data["agents"]), 12)
+        policy.agents.add(server_agents[13])
+        policy.agents.add(workstation_agents[15])
+        self.assertEquals(len(resp.data["agents"]), 10)
 
     def test_generating_agent_policy_checks(self):
         from .tasks import generate_agent_checks_from_policies_task
@@ -767,9 +749,8 @@ class TestPolicyTasks(TacticalTestCase):
         # setup data
         policy = baker.make("automation.Policy", active=True)
         checks = self.create_checks(policy=policy)
-        client = baker.make("clients.Client", client="Default")
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe("agents.agent", policy=policy)
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.agent", site=site, policy=policy)
 
         # test policy assigned to agent
         generate_agent_checks_from_policies_task(policy.id, clear=True)
@@ -815,9 +796,8 @@ class TestPolicyTasks(TacticalTestCase):
         policy = baker.make("automation.Policy", active=True, enforced=True)
         script = baker.make_recipe("scripts.script")
         self.create_checks(policy=policy, script=script)
-        client = baker.make("clients.Client", client="Default")
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe("agents.agent", policy=policy)
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.agent", site=site, policy=policy)
         self.create_checks(agent=agent, script=script)
 
         generate_agent_checks_from_policies_task(policy.id, create_tasks=True)
@@ -839,25 +819,18 @@ class TestPolicyTasks(TacticalTestCase):
         self.create_checks(policy=policy)
         clients = baker.make(
             "clients.Client",
-            client=seq("Default"),
             _quantity=2,
             server_policy=policy,
             workstation_policy=policy,
         )
-        baker.make(
-            "clients.Site", client=cycle(clients), site=seq("Default"), _quantity=4
-        )
-        server_agent = baker.make_recipe(
-            "agents.server_agent", client="Default1", site="Default1"
-        )
-        workstation_agent = baker.make_recipe(
-            "agents.workstation_agent", client="Default1", site="Default3"
-        )
-        agent1 = baker.make_recipe("agents.agent", client="Default2", site="Default2")
-        agent2 = baker.make_recipe("agents.agent", client="Default2", site="Default4")
+        sites = baker.make("clients.Site", client=cycle(clients), _quantity=4)
+        server_agent = baker.make_recipe("agents.server_agent", site=sites[0])
+        workstation_agent = baker.make_recipe("agents.workstation_agent", site=sites[2])
+        agent1 = baker.make_recipe("agents.server_agent", site=sites[1])
+        agent2 = baker.make_recipe("agents.workstation_agent", site=sites[3])
 
         generate_agent_checks_by_location_task(
-            {"client": "Default1", "site": "Default1"},
+            {"site_id": sites[0].id},
             "server",
             clear=True,
             create_tasks=True,
@@ -871,7 +844,10 @@ class TestPolicyTasks(TacticalTestCase):
         self.assertEqual(Agent.objects.get(pk=agent1.id).agentchecks.count(), 0)
 
         generate_agent_checks_by_location_task(
-            {"client": "Default1"}, "workstation", clear=True, create_tasks=True
+            {"site__client_id": clients[0].id},
+            "workstation",
+            clear=True,
+            create_tasks=True,
         )
         # workstation_agent should now have policy checks and the other agents should not
         self.assertEqual(
@@ -888,18 +864,12 @@ class TestPolicyTasks(TacticalTestCase):
         # setup data
         policy = baker.make("automation.Policy", active=True)
         self.create_checks(policy=policy)
-        clients = baker.make("clients.Client", client=seq("Default"), _quantity=2)
-        baker.make(
-            "clients.Site", client=cycle(clients), site=seq("Default"), _quantity=4
+
+        site = baker.make("clients.Site")
+        server_agents = baker.make_recipe("agents.server_agent", site=site, _quantity=3)
+        workstation_agents = baker.make_recipe(
+            "agents.workstation_agent", site=site, _quantity=4
         )
-        server_agent = baker.make_recipe(
-            "agents.server_agent", client="Default1", site="Default1"
-        )
-        workstation_agent = baker.make_recipe(
-            "agents.workstation_agent", client="Default1", site="Default3"
-        )
-        agent1 = baker.make_recipe("agents.agent", client="Default2", site="Default2")
-        agent2 = baker.make_recipe("agents.agent", client="Default2", site="Default4")
         core = CoreSettings.objects.first()
         core.server_policy = policy
         core.workstation_policy = policy
@@ -908,22 +878,20 @@ class TestPolicyTasks(TacticalTestCase):
         generate_all_agent_checks_task("server", clear=True, create_tasks=True)
 
         # all servers should have 7 checks
-        self.assertEqual(
-            Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 0
-        )
-        self.assertEqual(Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
-        self.assertEqual(Agent.objects.get(pk=agent1.id).agentchecks.count(), 7)
-        self.assertEqual(Agent.objects.get(pk=agent2.id).agentchecks.count(), 0)
+        for agent in server_agents:
+            self.assertEqual(Agent.objects.get(pk=agent.id).agentchecks.count(), 7)
+
+        for agent in workstation_agents:
+            self.assertEqual(Agent.objects.get(pk=agent.id).agentchecks.count(), 0)
 
         generate_all_agent_checks_task("workstation", clear=True, create_tasks=True)
 
         # all agents should have 7 checks now
-        self.assertEqual(
-            Agent.objects.get(pk=workstation_agent.id).agentchecks.count(), 7
-        )
-        self.assertEqual(Agent.objects.get(pk=server_agent.id).agentchecks.count(), 7)
-        self.assertEqual(Agent.objects.get(pk=agent1.id).agentchecks.count(), 7)
-        self.assertEqual(Agent.objects.get(pk=agent2.id).agentchecks.count(), 7)
+        for agent in server_agents:
+            self.assertEqual(Agent.objects.get(pk=agent.id).agentchecks.count(), 7)
+
+        for agent in workstation_agents:
+            self.assertEqual(Agent.objects.get(pk=agent.id).agentchecks.count(), 7)
 
     def test_delete_policy_check(self):
         from .tasks import delete_policy_check_task
@@ -931,11 +899,8 @@ class TestPolicyTasks(TacticalTestCase):
 
         policy = baker.make("automation.Policy", active=True)
         self.create_checks(policy=policy)
-        client = baker.make("clients.Client", client="Default", server_policy=policy)
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe(
-            "agents.server_agent", client="Default", site="Default"
-        )
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.server_agent", site=site, policy=policy)
         agent.generate_checks_from_policies()
 
         # make sure agent has 7 checks
@@ -960,11 +925,7 @@ class TestPolicyTasks(TacticalTestCase):
 
         policy = baker.make("automation.Policy", active=True)
         self.create_checks(policy=policy)
-        client = baker.make("clients.Client", client="Default", server_policy=policy)
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe(
-            "agents.server_agent", client="Default", site="Default"
-        )
+        agent = baker.make_recipe("agents.server_agent", policy=policy)
         agent.generate_checks_from_policies()
 
         # make sure agent has 7 checks
@@ -997,11 +958,8 @@ class TestPolicyTasks(TacticalTestCase):
         tasks = baker.make(
             "autotasks.AutomatedTask", policy=policy, name=seq("Task"), _quantity=3
         )
-        client = baker.make("clients.Client", client="Default")
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe(
-            "agents.server_agent", client="Default", site="Default", policy=policy
-        )
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.server_agent", site=site, policy=policy)
 
         generate_agent_tasks_from_policies_task(policy.id, clear=True)
 
@@ -1027,33 +985,26 @@ class TestPolicyTasks(TacticalTestCase):
 
         # setup data
         policy = baker.make("automation.Policy", active=True)
-        tasks = baker.make(
+        baker.make(
             "autotasks.AutomatedTask", policy=policy, name=seq("Task"), _quantity=3
         )
         clients = baker.make(
             "clients.Client",
-            client=seq("Default"),
             _quantity=2,
             server_policy=policy,
             workstation_policy=policy,
         )
-        baker.make(
-            "clients.Site", client=cycle(clients), site=seq("Default"), _quantity=4
-        )
-        server_agent = baker.make_recipe(
-            "agents.server_agent", client="Default1", site="Default1"
-        )
-        workstation_agent = baker.make_recipe(
-            "agents.workstation_agent", client="Default1", site="Default3"
-        )
-        agent1 = baker.make_recipe("agents.agent", client="Default2", site="Default2")
-        agent2 = baker.make_recipe("agents.agent", client="Default2", site="Default4")
+        sites = baker.make("clients.Site", client=cycle(clients), _quantity=4)
+        server_agent = baker.make_recipe("agents.server_agent", site=sites[0])
+        workstation_agent = baker.make_recipe("agents.workstation_agent", site=sites[2])
+        agent1 = baker.make_recipe("agents.agent", site=sites[1])
+        agent2 = baker.make_recipe("agents.agent", site=sites[3])
 
         generate_agent_tasks_by_location_task(
-            {"client": "Default1", "site": "Default1"}, "server", clear=True
+            {"site_id": sites[0].id}, "server", clear=True
         )
 
-        # all servers in Default1 and site Default1 should have 3 tasks
+        # all servers in site1 and site2 should have 3 tasks
         self.assertEqual(
             Agent.objects.get(pk=workstation_agent.id).autotasks.count(), 0
         )
@@ -1062,7 +1013,7 @@ class TestPolicyTasks(TacticalTestCase):
         self.assertEqual(Agent.objects.get(pk=agent2.id).autotasks.count(), 0)
 
         generate_agent_tasks_by_location_task(
-            {"client": "Default1"}, "workstation", clear=True
+            {"site__client_id": clients[0].id}, "workstation", clear=True
         )
 
         # all workstations in Default1 should have 3 tasks
@@ -1079,11 +1030,8 @@ class TestPolicyTasks(TacticalTestCase):
 
         policy = baker.make("automation.Policy", active=True)
         tasks = baker.make("autotasks.AutomatedTask", policy=policy, _quantity=3)
-        client = baker.make("clients.Client", client="Default", server_policy=policy)
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe(
-            "agents.server_agent", client="Default", site="Default"
-        )
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.server_agent", site=site, policy=policy)
         agent.generate_tasks_from_policies()
 
         delete_policy_autotask_task(tasks[0].id)
@@ -1103,20 +1051,20 @@ class TestPolicyTasks(TacticalTestCase):
         for task in tasks:
             run_win_task.assert_any_call(task.id)
 
-    def test_updated_policy_tasks(self):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_update_policy_tasks(self, nats_cmd):
         from .tasks import update_policy_task_fields_task
         from autotasks.models import AutomatedTask
 
+        nats_cmd.return_value = "ok"
+
         # setup data
         policy = baker.make("automation.Policy", active=True)
         tasks = baker.make(
             "autotasks.AutomatedTask", enabled=True, policy=policy, _quantity=3
         )
-        client = baker.make("clients.Client", client="Default", server_policy=policy)
-        baker.make("clients.Site", client=client, site="Default")
-        agent = baker.make_recipe(
-            "agents.server_agent", client="Default", site="Default"
-        )
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.server_agent", site=site, policy=policy)
         agent.generate_tasks_from_policies()
 
         tasks[0].enabled = False

api/tacticalrmm/automation/views.py

@@ -1,4 +1,3 @@
-from django.db import DataError
 from django.shortcuts import get_object_or_404
 
 from rest_framework.views import APIView
@@ -12,7 +11,7 @@ from checks.models import Check
 from autotasks.models import AutomatedTask
 from winupdate.models import WinUpdatePolicy
 
-from clients.serializers import ClientSerializer, TreeSerializer
+from clients.serializers import ClientSerializer, SiteSerializer
 from agents.serializers import AgentHostnameSerializer
 from winupdate.serializers import WinUpdatePolicySerializer
 
@@ -33,7 +32,6 @@ from .tasks import (
     generate_agent_checks_from_policies_task,
     generate_agent_checks_by_location_task,
     generate_agent_tasks_from_policies_task,
-    generate_agent_tasks_by_location_task,
     run_win_policy_autotask_task,
 )
 
@@ -172,7 +170,7 @@ class GetRelated(APIView):
                 if site not in policy.server_sites.all():
                     filtered_server_sites.append(site)
 
-        response["server_sites"] = TreeSerializer(
+        response["server_sites"] = SiteSerializer(
             filtered_server_sites + list(policy.server_sites.all()), many=True
         ).data
 
@@ -181,7 +179,7 @@ class GetRelated(APIView):
                 if site not in policy.workstation_sites.all():
                     filtered_workstation_sites.append(site)
 
-        response["workstation_sites"] = TreeSerializer(
+        response["workstation_sites"] = SiteSerializer(
             filtered_workstation_sites + list(policy.workstation_sites.all()), many=True
         ).data
 
@@ -218,7 +216,7 @@ class GetRelated(APIView):
                     client.save()
 
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": client.client},
+                        location={"site__client_id": client.id},
                         mon_type="workstation",
                         clear=True,
                         create_tasks=True,
@@ -236,7 +234,7 @@ class GetRelated(APIView):
                     site.workstation_policy = policy
                     site.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": site.client.client, "site": site.site},
+                        location={"site_id": site.id},
                         mon_type="workstation",
                         clear=True,
                         create_tasks=True,
@@ -258,7 +256,7 @@ class GetRelated(APIView):
                     client.server_policy = policy
                     client.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": client.client},
+                        location={"site__client_id": client.id},
                         mon_type="server",
                         clear=True,
                         create_tasks=True,
@@ -276,7 +274,7 @@ class GetRelated(APIView):
                     site.server_policy = policy
                     site.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": site.client.client, "site": site.site},
+                        location={"site_id": site.id},
                         mon_type="server",
                         clear=True,
                         create_tasks=True,
@@ -296,7 +294,7 @@ class GetRelated(APIView):
                     client.workstation_policy = None
                     client.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": client.client},
+                        location={"site__client_id": client.id},
                         mon_type="workstation",
                         clear=True,
                         create_tasks=True,
@@ -311,7 +309,7 @@ class GetRelated(APIView):
                     site.workstation_policy = None
                     site.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": site.client.client, "site": site.site},
+                        location={"site_id": site.id},
                         mon_type="workstation",
                         clear=True,
                         create_tasks=True,
@@ -329,7 +327,7 @@ class GetRelated(APIView):
                     client.server_policy = None
                     client.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": client.client},
+                        location={"site__client_id": client.id},
                         mon_type="server",
                         clear=True,
                         create_tasks=True,
@@ -343,7 +341,7 @@ class GetRelated(APIView):
                     site.server_policy = None
                     site.save()
                     generate_agent_checks_by_location_task.delay(
-                        location={"client": site.client.client, "site": site.site},
+                        location={"site_id": site.pk},
                         mon_type="server",
                         clear=True,
                         create_tasks=True,
@@ -423,12 +421,10 @@ class UpdatePatchPolicy(APIView):
     def patch(self, request):
 
         agents = None
-        if "client" in request.data and "site" in request.data:
-            agents = Agent.objects.filter(
-                client=request.data["client"], site=request.data["site"]
-            )
-        elif "client" in request.data:
-            agents = Agent.objects.filter(client=request.data["client"])
+        if "client" in request.data:
+            agents = Agent.objects.filter(site__client_id=request.data["client"])
+        elif "site" in request.data:
+            agents = Agent.objects.filter(site_id=request.data["site"])
         else:
             agents = Agent.objects.all()
 

api/tacticalrmm/autotasks/migrations/0009_automatedtask_run_time_bit_weekdays.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.3 on 2020-11-29 09:12
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('autotasks', '0008_auto_20201030_1515'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='automatedtask',
+            name='run_time_bit_weekdays',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+    ]

api/tacticalrmm/autotasks/migrations/0010_migrate_days_to_bitdays.py

@@ -0,0 +1,33 @@
+from django.db import migrations
+from tacticalrmm.utils import get_bit_days
+
+DAYS_OF_WEEK = {
+    0: "Monday",
+    1: "Tuesday",
+    2: "Wednesday",
+    3: "Thursday",
+    4: "Friday",
+    5: "Saturday",
+    6: "Sunday",
+}
+
+
+def migrate_days(apps, schema_editor):
+    AutomatedTask = apps.get_model("autotasks", "AutomatedTask")
+    for task in AutomatedTask.objects.exclude(run_time_days__isnull=True).exclude(
+        run_time_days=[]
+    ):
+        run_days = [DAYS_OF_WEEK.get(day) for day in task.run_time_days]
+        task.run_time_bit_weekdays = get_bit_days(run_days)
+        task.save(update_fields=["run_time_bit_weekdays"])
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("autotasks", "0009_automatedtask_run_time_bit_weekdays"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_days),
+    ]

api/tacticalrmm/autotasks/models.py

@@ -1,3 +1,4 @@
+import pytz
 import random
 import string
 import datetime as dt
@@ -7,6 +8,7 @@ from django.contrib.postgres.fields import ArrayField
 from django.db.models.fields import DateTimeField
 from automation.models import Policy
 from logs.models import BaseAuditModel
+from tacticalrmm.utils import bitdays_to_string
 
 RUN_TIME_DAY_CHOICES = [
     (0, "Monday"),
@@ -68,6 +70,8 @@ class AutomatedTask(BaseAuditModel):
         on_delete=models.SET_NULL,
     )
     name = models.CharField(max_length=255)
+    run_time_bit_weekdays = models.IntegerField(null=True, blank=True)
+    # run_time_days is deprecated, use bit weekdays
     run_time_days = ArrayField(
         models.IntegerField(choices=RUN_TIME_DAY_CHOICES, null=True, blank=True),
         null=True,
@@ -106,21 +110,21 @@ class AutomatedTask(BaseAuditModel):
         elif self.task_type == "runonce":
             return f'Run once on {self.run_time_date.strftime("%m/%d/%Y %I:%M%p")}'
         elif self.task_type == "scheduled":
-            ret = []
-            for i in self.run_time_days:
-                for j in RUN_TIME_DAY_CHOICES:
-                    if i in j:
-                        ret.append(j[1][0:3])
-
             run_time_nice = dt.datetime.strptime(
                 self.run_time_minute, "%H:%M"
             ).strftime("%I:%M %p")
 
-            if len(ret) == 7:
-                return f"Every day at {run_time_nice}"
-            else:
-                days = ",".join(ret)
-                return f"{days} at {run_time_nice}"
+            days = bitdays_to_string(self.run_time_bit_weekdays)
+            return f"{days} at {run_time_nice}"
+
+    @property
+    def last_run_as_timezone(self):
+        if self.last_run is not None and self.agent is not None:
+            return self.last_run.astimezone(
+                pytz.timezone(self.agent.timezone)
+            ).strftime("%b-%d-%Y - %H:%M")
+
+        return self.last_run
 
     @staticmethod
     def generate_task_name():
@@ -137,7 +141,7 @@ class AutomatedTask(BaseAuditModel):
     def create_policy_task(self, agent=None, policy=None):
         from .tasks import create_win_task_schedule
 
-        # exit is neither are set or if both are set
+        # exit if neither are set or if both are set
         if not agent and not policy or agent and policy:
             return
 
@@ -159,6 +163,7 @@ class AutomatedTask(BaseAuditModel):
             name=self.name,
             run_time_days=self.run_time_days,
             run_time_minute=self.run_time_minute,
+            run_time_bit_weekdays=self.run_time_bit_weekdays,
             run_time_date=self.run_time_date,
             task_type=self.task_type,
             win_task_name=self.win_task_name,

api/tacticalrmm/autotasks/serializers.py

@@ -1,3 +1,4 @@
+import pytz
 from rest_framework import serializers
 
 from .models import AutomatedTask
@@ -12,6 +13,7 @@ class TaskSerializer(serializers.ModelSerializer):
 
     assigned_check = CheckSerializer(read_only=True)
     schedule = serializers.ReadOnlyField()
+    last_run = serializers.ReadOnlyField(source="last_run_as_timezone")
 
     class Meta:
         model = AutomatedTask

api/tacticalrmm/autotasks/tasks.py

@@ -1,52 +1,37 @@
+import asyncio
+import datetime as dt
 from loguru import logger
 from tacticalrmm.celery import app
 from django.conf import settings
 import pytz
 from django.utils import timezone as djangotime
+from packaging import version as pyver
 
 from .models import AutomatedTask
 from logs.models import PendingAction
 
 logger.configure(**settings.LOG_CONFIG)
 
-DAYS_OF_WEEK = {
-    0: "Monday",
-    1: "Tuesday",
-    2: "Wednesday",
-    3: "Thursday",
-    4: "Friday",
-    5: "Saturday",
-    6: "Sunday",
-}
-
 
 @app.task
 def create_win_task_schedule(pk, pending_action=False):
     task = AutomatedTask.objects.get(pk=pk)
 
     if task.task_type == "scheduled":
-        run_days = [DAYS_OF_WEEK.get(day) for day in task.run_time_days]
-
-        r = task.agent.salt_api_cmd(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task.win_task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {task.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Weekly",
-                f'start_time="{task.run_time_minute}"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-            ],
-            kwargs={"days_of_week": run_days},
-        )
+        nats_data = {
+            "func": "schedtask",
+            "schedtaskpayload": {
+                "type": "rmm",
+                "trigger": "weekly",
+                "weekdays": task.run_time_bit_weekdays,
+                "pk": task.pk,
+                "name": task.win_task_name,
+                "hour": dt.datetime.strptime(task.run_time_minute, "%H:%M").hour,
+                "min": dt.datetime.strptime(task.run_time_minute, "%H:%M").minute,
+            },
+        }
 
     elif task.task_type == "runonce":
-
         # check if scheduled time is in the past
         agent_tz = pytz.timezone(task.agent.timezone)
         task_time_utc = task.run_time_date.replace(tzinfo=agent_tz).astimezone(pytz.utc)
@@ -57,45 +42,41 @@ def create_win_task_schedule(pk, pending_action=False):
             ) + djangotime.timedelta(minutes=5)
             task.save()
 
-        r = task.agent.salt_api_cmd(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task.win_task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {task.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                f'start_date="{task.run_time_date.strftime("%Y-%m-%d")}"',
-                f'start_time="{task.run_time_date.strftime("%H:%M")}"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-                "start_when_available=True",
-            ],
-        )
+        nats_data = {
+            "func": "schedtask",
+            "schedtaskpayload": {
+                "type": "rmm",
+                "trigger": "once",
+                "pk": task.pk,
+                "name": task.win_task_name,
+                "year": int(dt.datetime.strftime(task.run_time_date, "%Y")),
+                "month": dt.datetime.strftime(task.run_time_date, "%B"),
+                "day": int(dt.datetime.strftime(task.run_time_date, "%d")),
+                "hour": int(dt.datetime.strftime(task.run_time_date, "%H")),
+                "min": int(dt.datetime.strftime(task.run_time_date, "%M")),
+            },
+        }
+
+        if task.remove_if_not_scheduled and pyver.parse(
+            task.agent.version
+        ) >= pyver.parse("1.1.2"):
+            nats_data["schedtaskpayload"]["deleteafter"] = True
 
     elif task.task_type == "checkfailure" or task.task_type == "manual":
-        r = task.agent.salt_api_cmd(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task.win_task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {task.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                'start_date="1975-01-01"',
-                'start_time="01:00"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-            ],
-        )
+        nats_data = {
+            "func": "schedtask",
+            "schedtaskpayload": {
+                "type": "rmm",
+                "trigger": "manual",
+                "pk": task.pk,
+                "name": task.win_task_name,
+            },
+        }
+    else:
+        return "error"
 
-    if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
+    r = asyncio.run(task.agent.nats_cmd(nats_data, timeout=10))
+    if r != "ok":
         # don't create pending action if this task was initiated by a pending action
         if not pending_action:
             PendingAction(
@@ -129,13 +110,16 @@ def create_win_task_schedule(pk, pending_action=False):
 def enable_or_disable_win_task(pk, action, pending_action=False):
     task = AutomatedTask.objects.get(pk=pk)
 
-    r = task.agent.salt_api_cmd(
-        timeout=20,
-        func="task.edit_task",
-        arg=[f"name={task.win_task_name}", f"enabled={action}"],
-    )
+    nats_data = {
+        "func": "enableschedtask",
+        "schedtaskpayload": {
+            "name": task.win_task_name,
+            "enabled": action,
+        },
+    }
+    r = asyncio.run(task.agent.nats_cmd(nats_data))
 
-    if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
+    if r != "ok":
         # don't create pending action if this task was initiated by a pending action
         if not pending_action:
             PendingAction(
@@ -150,9 +134,6 @@ def enable_or_disable_win_task(pk, action, pending_action=False):
             task.sync_status = "notsynced"
             task.save(update_fields=["sync_status"])
 
-        logger.error(
-            f"Unable to update the scheduled task {task.win_task_name} on {task.agent.hostname}. It will be updated when the agent checks in."
-        )
         return
 
     # clear pending action since it was successful
@@ -163,7 +144,6 @@ def enable_or_disable_win_task(pk, action, pending_action=False):
 
     task.sync_status = "synced"
     task.save(update_fields=["sync_status"])
-    logger.info(f"{task.agent.hostname} task {task.name} was edited.")
     return "ok"
 
 
@@ -171,13 +151,13 @@ def enable_or_disable_win_task(pk, action, pending_action=False):
 def delete_win_task_schedule(pk, pending_action=False):
     task = AutomatedTask.objects.get(pk=pk)
 
-    r = task.agent.salt_api_cmd(
-        timeout=20,
-        func="task.delete_task",
-        arg=[f"name={task.win_task_name}"],
-    )
+    nats_data = {
+        "func": "delschedtask",
+        "schedtaskpayload": {"name": task.win_task_name},
+    }
+    r = asyncio.run(task.agent.nats_cmd(nats_data, timeout=10))
 
-    if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
+    if r != "ok":
         # don't create pending action if this task was initiated by a pending action
         if not pending_action:
             PendingAction(
@@ -188,9 +168,6 @@ def delete_win_task_schedule(pk, pending_action=False):
             task.sync_status = "pendingdeletion"
             task.save(update_fields=["sync_status"])
 
-        logger.error(
-            f"Unable to delete scheduled task {task.win_task_name} on {task.agent.hostname}. It was marked pending deletion and will be removed when the agent checks in."
-        )
         return
 
     # complete pending action since it was successful
@@ -200,14 +177,13 @@ def delete_win_task_schedule(pk, pending_action=False):
         pendingaction.save(update_fields=["status"])
 
     task.delete()
-    logger.info(f"{task.agent.hostname} task {task.name} was deleted.")
     return "ok"
 
 
 @app.task
 def run_win_task(pk):
     task = AutomatedTask.objects.get(pk=pk)
-    r = task.agent.salt_api_async(func="task.run", arg=[f"name={task.win_task_name}"])
+    asyncio.run(task.agent.nats_cmd({"func": "runtask", "taskpk": task.pk}, wait=False))
     return "ok"
 
 
@@ -219,18 +195,9 @@ def remove_orphaned_win_tasks(agentpk):
 
     logger.info(f"Orphaned task cleanup initiated on {agent.hostname}.")
 
-    r = agent.salt_api_cmd(
-        timeout=15,
-        func="task.list_tasks",
-    )
+    r = asyncio.run(agent.nats_cmd({"func": "listschedtasks"}, timeout=10))
 
-    if r == "timeout" or r == "error":
-        logger.error(
-            f"Unable to clean up scheduled tasks on {agent.hostname}. Agent might be offline"
-        )
-        return "errtimeout"
-
-    if not isinstance(r, list):
+    if not isinstance(r, list) and not r:  # empty list
         logger.error(f"Unable to clean up scheduled tasks on {agent.hostname}: {r}")
         return "notlist"
 
@@ -239,7 +206,8 @@ def remove_orphaned_win_tasks(agentpk):
     exclude_tasks = (
         "TacticalRMM_fixmesh",
         "TacticalRMM_SchedReboot",
-        "TacticalRMM_saltwatchdog",  # will be implemented in future
+        "TacticalRMM_sync",
+        "TacticalRMM_agentupdate",
     )
 
     for task in r:
@@ -249,16 +217,16 @@ def remove_orphaned_win_tasks(agentpk):
 
         if task.startswith("TacticalRMM_") and task not in agent_task_names:
             # delete task since it doesn't exist in UI
-            ret = agent.salt_api_cmd(
-                timeout=20,
-                func="task.delete_task",
-                arg=[f"name={task}"],
-            )
-            if isinstance(ret, bool) and ret is True:
-                logger.info(f"Removed orphaned task {task} from {agent.hostname}")
-            else:
+            nats_data = {
+                "func": "delschedtask",
+                "schedtaskpayload": {"name": task},
+            }
+            ret = asyncio.run(agent.nats_cmd(nats_data, timeout=10))
+            if ret != "ok":
                 logger.error(
                     f"Unable to clean up orphaned task {task} on {agent.hostname}: {ret}"
                 )
+            else:
+                logger.info(f"Removed orphaned task {task} from {agent.hostname}")
 
     logger.info(f"Orphaned task cleanup finished on {agent.hostname}")

api/tacticalrmm/autotasks/tests.py

@@ -1,3 +1,4 @@
+import datetime as dt
 from unittest.mock import patch, call
 from model_bakery import baker
 from django.utils import timezone as djangotime
@@ -25,9 +26,9 @@ class TestAutotaskViews(TacticalTestCase):
         # setup data
         script = baker.make_recipe("scripts.script")
         agent = baker.make_recipe("agents.agent")
-        agent_old = baker.make_recipe("agents.agent", version="0.9.0")
         policy = baker.make("automation.Policy")
         check = baker.make_recipe("checks.diskspace_check", agent=agent)
+        old_agent = baker.make_recipe("agents.agent", version="1.1.0")
 
         # test script set to invalid pk
         data = {"autotask": {"script": 500}}
@@ -50,10 +51,10 @@ class TestAutotaskViews(TacticalTestCase):
         resp = self.client.post(url, data, format="json")
         self.assertEqual(resp.status_code, 404)
 
-        # test invalid agent version
+        # test old agent version
         data = {
-            "autotask": {"script": script.id, "script_args": ["args"]},
-            "agent": agent_old.id,
+            "autotask": {"script": script.id},
+            "agent": old_agent.id,
         }
 
         resp = self.client.post(url, data, format="json")
@@ -63,7 +64,7 @@ class TestAutotaskViews(TacticalTestCase):
         data = {
             "autotask": {
                 "name": "Test Task Scheduled with Assigned Check",
-                "run_time_days": [0, 1, 2],
+                "run_time_days": ["Sunday", "Monday", "Friday"],
                 "run_time_minute": "10:00",
                 "timeout": 120,
                 "enabled": True,
@@ -84,6 +85,7 @@ class TestAutotaskViews(TacticalTestCase):
         data = {
             "autotask": {
                 "name": "Test Task Manual",
+                "run_time_days": [],
                 "timeout": 120,
                 "enabled": True,
                 "script": script.id,
@@ -181,10 +183,10 @@ class TestAutotaskViews(TacticalTestCase):
 
         self.check_not_authenticated("delete", url)
 
-    @patch("autotasks.tasks.run_win_task.delay")
-    def test_run_autotask(self, run_win_task):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_run_autotask(self, nats_cmd):
         # setup data
-        agent = baker.make_recipe("agents.agent")
+        agent = baker.make_recipe("agents.agent", version="1.1.0")
         task = baker.make("autotasks.AutomatedTask", agent=agent)
 
         # test invalid url
@@ -195,7 +197,15 @@ class TestAutotaskViews(TacticalTestCase):
         url = f"/tasks/runwintask/{task.id}/"
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 200)
-        run_win_task.assert_called_with(task.id)
+        nats_cmd.assert_called_with({"func": "runtask", "taskpk": task.id}, wait=False)
+        nats_cmd.reset_mock()
+
+        old_agent = baker.make_recipe("agents.agent", version="1.0.2")
+        task2 = baker.make("autotasks.AutomatedTask", agent=old_agent)
+        url = f"/tasks/runwintask/{task2.id}/"
+        resp = self.client.get(url, format="json")
+        self.assertEqual(resp.status_code, 400)
+        nats_cmd.assert_not_called()
 
         self.check_not_authenticated("get", url)
 
@@ -205,8 +215,8 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
         self.authenticate()
         self.setup_coresettings()
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_remove_orphaned_win_task(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_remove_orphaned_win_task(self, nats_cmd):
         self.agent = baker.make_recipe("agents.agent")
         self.task1 = AutomatedTask.objects.create(
             agent=self.agent,
@@ -214,20 +224,6 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             win_task_name=AutomatedTask.generate_task_name(),
         )
 
-        salt_api_cmd.return_value = "timeout"
-        ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        self.assertEqual(ret.result, "errtimeout")
-
-        salt_api_cmd.return_value = "error"
-        ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        self.assertEqual(ret.result, "errtimeout")
-
-        salt_api_cmd.return_value = "task not found in"
-        ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        self.assertEqual(ret.result, "notlist")
-
-        salt_api_cmd.reset_mock()
-
         # test removing an orphaned task
         win_tasks = [
             "Adobe Acrobat Update Task",
@@ -242,50 +238,54 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
         ]
 
         self.calls = [
-            call(timeout=15, func="task.list_tasks"),
+            call({"func": "listschedtasks"}, timeout=10),
             call(
-                timeout=20,
-                func="task.delete_task",
-                arg=["name=TacticalRMM_iggrLcOaldIZnUzLuJWPLNwikiOoJJHHznb"],
+                {
+                    "func": "delschedtask",
+                    "schedtaskpayload": {
+                        "name": "TacticalRMM_iggrLcOaldIZnUzLuJWPLNwikiOoJJHHznb"
+                    },
+                },
+                timeout=10,
             ),
         ]
 
-        salt_api_cmd.side_effect = [win_tasks, True]
+        nats_cmd.side_effect = [win_tasks, "ok"]
         ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        self.assertEqual(salt_api_cmd.call_count, 2)
-        salt_api_cmd.assert_has_calls(self.calls)
+        self.assertEqual(nats_cmd.call_count, 2)
+        nats_cmd.assert_has_calls(self.calls)
         self.assertEqual(ret.status, "SUCCESS")
 
-        # test salt delete_task fail
-        salt_api_cmd.reset_mock()
-        salt_api_cmd.side_effect = [win_tasks, False]
+        # test nats delete task fail
+        nats_cmd.reset_mock()
+        nats_cmd.side_effect = [win_tasks, "error deleting task"]
         ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        salt_api_cmd.assert_has_calls(self.calls)
-        self.assertEqual(salt_api_cmd.call_count, 2)
+        nats_cmd.assert_has_calls(self.calls)
+        self.assertEqual(nats_cmd.call_count, 2)
         self.assertEqual(ret.status, "SUCCESS")
 
         # no orphaned tasks
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
         win_tasks.remove("TacticalRMM_iggrLcOaldIZnUzLuJWPLNwikiOoJJHHznb")
-        salt_api_cmd.side_effect = [win_tasks, True]
+        nats_cmd.side_effect = [win_tasks, "ok"]
         ret = remove_orphaned_win_tasks.s(self.agent.pk).apply()
-        self.assertEqual(salt_api_cmd.call_count, 1)
+        self.assertEqual(nats_cmd.call_count, 1)
         self.assertEqual(ret.status, "SUCCESS")
 
-    @patch("agents.models.Agent.salt_api_async")
-    def test_run_win_task(self, salt_api_async):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_run_win_task(self, nats_cmd):
         self.agent = baker.make_recipe("agents.agent")
         self.task1 = AutomatedTask.objects.create(
             agent=self.agent,
             name="test task 1",
             win_task_name=AutomatedTask.generate_task_name(),
         )
-        salt_api_async.return_value = "Response 200"
+        nats_cmd.return_value = "ok"
         ret = run_win_task.s(self.task1.pk).apply()
         self.assertEqual(ret.status, "SUCCESS")
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_create_win_task_schedule(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_create_win_task_schedule(self, nats_cmd):
         self.agent = baker.make_recipe("agents.agent")
 
         task_name = AutomatedTask.generate_task_name()
@@ -295,46 +295,32 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             name="test task 1",
             win_task_name=task_name,
             task_type="scheduled",
-            run_time_days=[0, 1, 6],
+            run_time_bit_weekdays=127,
             run_time_minute="21:55",
         )
         self.assertEqual(self.task1.sync_status, "notsynced")
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(pk=self.task1.pk, pending_action=False).apply()
-        self.assertEqual(salt_api_cmd.call_count, 1)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {self.task1.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Weekly",
-                'start_time="21:55"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-            ],
-            kwargs={"days_of_week": ["Monday", "Tuesday", "Sunday"]},
+        self.assertEqual(nats_cmd.call_count, 1)
+        nats_cmd.assert_called_with(
+            {
+                "func": "schedtask",
+                "schedtaskpayload": {
+                    "type": "rmm",
+                    "trigger": "weekly",
+                    "weekdays": 127,
+                    "pk": self.task1.pk,
+                    "name": task_name,
+                    "hour": 21,
+                    "min": 55,
+                },
+            },
+            timeout=10,
         )
         self.task1 = AutomatedTask.objects.get(pk=self.task1.pk)
         self.assertEqual(self.task1.sync_status, "synced")
 
-        salt_api_cmd.return_value = "timeout"
-        ret = create_win_task_schedule.s(pk=self.task1.pk, pending_action=False).apply()
-        self.assertEqual(ret.status, "SUCCESS")
-        self.task1 = AutomatedTask.objects.get(pk=self.task1.pk)
-        self.assertEqual(self.task1.sync_status, "notsynced")
-
-        salt_api_cmd.return_value = "error"
-        ret = create_win_task_schedule.s(pk=self.task1.pk, pending_action=False).apply()
-        self.assertEqual(ret.status, "SUCCESS")
-        self.task1 = AutomatedTask.objects.get(pk=self.task1.pk)
-        self.assertEqual(self.task1.sync_status, "notsynced")
-
-        salt_api_cmd.return_value = False
+        nats_cmd.return_value = "timeout"
         ret = create_win_task_schedule.s(pk=self.task1.pk, pending_action=False).apply()
         self.assertEqual(ret.status, "SUCCESS")
         self.task1 = AutomatedTask.objects.get(pk=self.task1.pk)
@@ -345,7 +331,7 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             agent=self.agent, action_type="taskaction"
         )
         self.assertEqual(self.pending_action.status, "pending")
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(
             pk=self.task1.pk, pending_action=self.pending_action.pk
         ).apply()
@@ -354,7 +340,7 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
         self.assertEqual(self.pending_action.status, "completed")
 
         # test runonce with future date
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
         task_name = AutomatedTask.generate_task_name()
         run_time_date = djangotime.now() + djangotime.timedelta(hours=22)
         self.task2 = AutomatedTask.objects.create(
@@ -364,30 +350,29 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             task_type="runonce",
             run_time_date=run_time_date,
         )
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(pk=self.task2.pk, pending_action=False).apply()
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {self.task2.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                f'start_date="{run_time_date.strftime("%Y-%m-%d")}"',
-                f'start_time="{run_time_date.strftime("%H:%M")}"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-                "start_when_available=True",
-            ],
+        nats_cmd.assert_called_with(
+            {
+                "func": "schedtask",
+                "schedtaskpayload": {
+                    "type": "rmm",
+                    "trigger": "once",
+                    "pk": self.task2.pk,
+                    "name": task_name,
+                    "year": int(dt.datetime.strftime(self.task2.run_time_date, "%Y")),
+                    "month": dt.datetime.strftime(self.task2.run_time_date, "%B"),
+                    "day": int(dt.datetime.strftime(self.task2.run_time_date, "%d")),
+                    "hour": int(dt.datetime.strftime(self.task2.run_time_date, "%H")),
+                    "min": int(dt.datetime.strftime(self.task2.run_time_date, "%M")),
+                },
+            },
+            timeout=10,
         )
         self.assertEqual(ret.status, "SUCCESS")
 
         # test runonce with date in the past
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
         task_name = AutomatedTask.generate_task_name()
         run_time_date = djangotime.now() - djangotime.timedelta(days=13)
         self.task3 = AutomatedTask.objects.create(
@@ -397,31 +382,13 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             task_type="runonce",
             run_time_date=run_time_date,
         )
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(pk=self.task3.pk, pending_action=False).apply()
         self.task3 = AutomatedTask.objects.get(pk=self.task3.pk)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {self.task3.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                f'start_date="{self.task3.run_time_date.strftime("%Y-%m-%d")}"',
-                f'start_time="{self.task3.run_time_date.strftime("%H:%M")}"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-                "start_when_available=True",
-            ],
-        )
         self.assertEqual(ret.status, "SUCCESS")
 
         # test checkfailure
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
         self.check = baker.make_recipe("checks.diskspace_check", agent=self.agent)
         task_name = AutomatedTask.generate_task_name()
         self.task4 = AutomatedTask.objects.create(
@@ -431,29 +398,24 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             task_type="checkfailure",
             assigned_check=self.check,
         )
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(pk=self.task4.pk, pending_action=False).apply()
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {self.task4.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                'start_date="1975-01-01"',
-                'start_time="01:00"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-            ],
+        nats_cmd.assert_called_with(
+            {
+                "func": "schedtask",
+                "schedtaskpayload": {
+                    "type": "rmm",
+                    "trigger": "manual",
+                    "pk": self.task4.pk,
+                    "name": task_name,
+                },
+            },
+            timeout=10,
         )
         self.assertEqual(ret.status, "SUCCESS")
 
         # test manual
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
         task_name = AutomatedTask.generate_task_name()
         self.task5 = AutomatedTask.objects.create(
             agent=self.agent,
@@ -461,23 +423,18 @@ class TestAutoTaskCeleryTasks(TacticalTestCase):
             win_task_name=task_name,
             task_type="manual",
         )
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = "ok"
         ret = create_win_task_schedule.s(pk=self.task5.pk, pending_action=False).apply()
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="task.create_task",
-            arg=[
-                f"name={task_name}",
-                "force=True",
-                "action_type=Execute",
-                'cmd="C:\\Program Files\\TacticalAgent\\tacticalrmm.exe"',
-                f'arguments="-m taskrunner -p {self.task5.pk}"',
-                "start_in=C:\\Program Files\\TacticalAgent",
-                "trigger_type=Once",
-                'start_date="1975-01-01"',
-                'start_time="01:00"',
-                "ac_only=False",
-                "stop_if_on_batteries=False",
-            ],
+        nats_cmd.assert_called_with(
+            {
+                "func": "schedtask",
+                "schedtaskpayload": {
+                    "type": "rmm",
+                    "trigger": "manual",
+                    "pk": self.task5.pk,
+                    "name": task_name,
+                },
+            },
+            timeout=10,
         )
         self.assertEqual(ret.status, "SUCCESS")

api/tacticalrmm/autotasks/views.py

@@ -1,3 +1,5 @@
+import asyncio
+import pytz
 from django.shortcuts import get_object_or_404
 
 from rest_framework.views import APIView
@@ -9,16 +11,16 @@ from agents.models import Agent
 from checks.models import Check
 
 from scripts.models import Script
+from core.models import CoreSettings
 
 from .serializers import TaskSerializer, AutoTaskSerializer
 
 from .tasks import (
     create_win_task_schedule,
     delete_win_task_schedule,
-    run_win_task,
     enable_or_disable_win_task,
 )
-from tacticalrmm.utils import notify_error
+from tacticalrmm.utils import notify_error, get_bit_days
 
 
 class AddAutoTask(APIView):
@@ -36,17 +38,20 @@ class AddAutoTask(APIView):
             parent = {"policy": policy}
         else:
             agent = get_object_or_404(Agent, pk=data["agent"])
+            if not agent.has_gotasks:
+                return notify_error("Requires agent version 1.1.1 or greater")
+
             parent = {"agent": agent}
-            added = "0.11.0"
-            if data["autotask"]["script_args"] and agent.not_supported(added):
-                return notify_error(
-                    f"Script arguments only available in agent {added} or greater"
-                )
 
         check = None
         if data["autotask"]["assigned_check"]:
             check = get_object_or_404(Check, pk=data["autotask"]["assigned_check"])
 
+        bit_weekdays = None
+        if data["autotask"]["run_time_days"]:
+            bit_weekdays = get_bit_days(data["autotask"]["run_time_days"])
+
+        del data["autotask"]["run_time_days"]
         serializer = TaskSerializer(data=data["autotask"], partial=True, context=parent)
         serializer.is_valid(raise_exception=True)
         obj = serializer.save(
@@ -54,6 +59,7 @@ class AddAutoTask(APIView):
             script=script,
             win_task_name=AutomatedTask.generate_task_name(),
             assigned_check=check,
+            run_time_bit_weekdays=bit_weekdays,
         )
 
         if not "policy" in data:
@@ -68,8 +74,12 @@ class AddAutoTask(APIView):
 class AutoTask(APIView):
     def get(self, request, pk):
 
-        agent = Agent.objects.only("pk").get(pk=pk)
-        return Response(AutoTaskSerializer(agent).data)
+        agent = get_object_or_404(Agent, pk=pk)
+        ctx = {
+            "default_tz": pytz.timezone(CoreSettings.objects.first().default_time_zone),
+            "agent_tz": agent.time_zone,
+        }
+        return Response(AutoTaskSerializer(agent, context=ctx).data)
 
     def patch(self, request, pk):
         from automation.tasks import update_policy_task_fields_task
@@ -108,5 +118,8 @@ class AutoTask(APIView):
 @api_view()
 def run_task(request, pk):
     task = get_object_or_404(AutomatedTask, pk=pk)
-    run_win_task.delay(task.pk)
+    if not task.agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+
+    asyncio.run(task.agent.nats_cmd({"func": "runtask", "taskpk": task.pk}, wait=False))
     return Response(f"{task.name} will now be run on {task.agent.hostname}")

api/tacticalrmm/checks/models.py

@@ -1,8 +1,8 @@
-import base64
+import asyncio
 import string
 import os
 import json
-import zlib
+import pytz
 from statistics import mean
 
 from django.db import models
@@ -177,6 +177,15 @@ class Check(BaseAuditModel):
         if self.check_type == "cpuload" or self.check_type == "memory":
             return ", ".join(str(f"{x}%") for x in self.history[-6:])
 
+    @property
+    def last_run_as_timezone(self):
+        if self.last_run is not None and self.agent is not None:
+            return self.last_run.astimezone(
+                pytz.timezone(self.agent.timezone)
+            ).strftime("%b-%d-%Y - %H:%M")
+
+        return self.last_run
+
     @property
     def non_editable_fields(self):
         return [
@@ -199,6 +208,10 @@ class Check(BaseAuditModel):
             "parent_check",
             "managed_by_policy",
             "overriden_by_policy",
+            "created_by",
+            "created_time",
+            "modified_by",
+            "modified_time",
         ]
 
     def handle_checkv2(self, data):
@@ -292,12 +305,16 @@ class Check(BaseAuditModel):
                     self.status = "passing"
                 else:
                     if self.agent and self.restart_if_stopped:
-                        r = self.agent.salt_api_cmd(
-                            func="service.restart", arg=self.svc_name, timeout=45
-                        )
-                        if r == "timeout" or r == "error":
+                        nats_data = {
+                            "func": "winsvcaction",
+                            "payload": {"name": self.svc_name, "action": "start"},
+                        }
+                        r = asyncio.run(self.agent.nats_cmd(nats_data, timeout=32))
+                        if r == "timeout" or r == "natsdown":
                             self.status = "failing"
-                        elif isinstance(r, bool) and r:
+                        elif not r["success"] and r["errormsg"]:
+                            self.status = "failing"
+                        elif r["success"]:
                             self.status = "passing"
                             self.more_info = f"Status RUNNING"
                         else:
@@ -322,8 +339,7 @@ class Check(BaseAuditModel):
             eventID = self.event_id
             source = self.event_source
             message = self.event_message
-
-            r = json.loads(zlib.decompress(base64.b64decode(data["log"])))
+            r = data["log"]
 
             for i in r:
                 if i["eventType"] == eventType:
@@ -518,7 +534,7 @@ class Check(BaseAuditModel):
         CORE = CoreSettings.objects.first()
 
         if self.agent:
-            subject = f"{self.agent.client}, {self.agent.site}, {self} Failed"
+            subject = f"{self.agent.client.name}, {self.agent.site.name}, {self} Failed"
         else:
             subject = f"{self} Failed"
 
@@ -594,7 +610,7 @@ class Check(BaseAuditModel):
         CORE = CoreSettings.objects.first()
 
         if self.agent:
-            subject = f"{self.agent.client}, {self.agent.site}, {self} Failed"
+            subject = f"{self.agent.client.name}, {self.agent.site.name}, {self} Failed"
         else:
             subject = f"{self} Failed"
 

api/tacticalrmm/checks/serializers.py

@@ -18,6 +18,7 @@ class CheckSerializer(serializers.ModelSerializer):
     readable_desc = serializers.ReadOnlyField()
     script = ScriptSerializer(read_only=True)
     assigned_task = serializers.SerializerMethodField()
+    last_run = serializers.ReadOnlyField(source="last_run_as_timezone")
     history_info = serializers.ReadOnlyField()
 
     ## Change to return only array of tasks after 9/25/2020
@@ -47,12 +48,11 @@ class CheckSerializer(serializers.ModelSerializer):
                 .filter(check_type="diskspace")
                 .exclude(managed_by_policy=True)
             )
-            if checks:
-                for check in checks:
-                    if val["disk"] in check.disk:
-                        raise serializers.ValidationError(
-                            f"A disk check for Drive {val['disk']} already exists!"
-                        )
+            for check in checks:
+                if val["disk"] in check.disk:
+                    raise serializers.ValidationError(
+                        f"A disk check for Drive {val['disk']} already exists!"
+                    )
 
         # ping checks
         if check_type == "ping":

api/tacticalrmm/checks/tasks.py

@@ -56,10 +56,3 @@ def handle_check_sms_alert_task(pk):
                 check.save(update_fields=["text_sent"])
 
     return "ok"
-
-
-@app.task
-def run_checks_task(pk):
-    agent = Agent.objects.get(pk=pk)
-    agent.salt_api_async(func="win_agent.run_manual_checks")
-    return "ok"

api/tacticalrmm/checks/tests.py

@@ -1,26 +1,38 @@
-from tacticalrmm.test import BaseTestCase
+from tacticalrmm.test import TacticalTestCase
 from .serializers import CheckSerializer
 
+from model_bakery import baker
+from itertools import cycle
+
+
+class TestCheckViews(TacticalTestCase):
+    def setUp(self):
+        self.authenticate()
 
-class TestCheckViews(BaseTestCase):
     def test_get_disk_check(self):
-        url = f"/checks/{self.agentDiskCheck.pk}/check/"
+        # setup data
+        disk_check = baker.make_recipe("checks.diskspace_check")
+
+        url = f"/checks/{disk_check.pk}/check/"
 
         resp = self.client.get(url, format="json")
-        serializer = CheckSerializer(self.agentDiskCheck)
+        serializer = CheckSerializer(disk_check)
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp.data, serializer.data)
         self.check_not_authenticated("post", url)
 
     def test_add_disk_check(self):
+        # setup data
+        agent = baker.make_recipe("agents.agent")
+
         url = "/checks/checks/"
 
         valid_payload = {
-            "pk": self.agent.pk,
+            "pk": agent.pk,
             "check": {
                 "check_type": "diskspace",
-                "disk": "D:",
+                "disk": "C:",
                 "threshold": 55,
                 "fails_b4_alert": 3,
             },
@@ -31,7 +43,7 @@ class TestCheckViews(BaseTestCase):
 
         # this should fail because we already have a check for drive C: in setup
         invalid_payload = {
-            "pk": self.agent.pk,
+            "pk": agent.pk,
             "check": {
                 "check_type": "diskspace",
                 "disk": "C:",
@@ -44,23 +56,30 @@ class TestCheckViews(BaseTestCase):
         self.assertEqual(resp.status_code, 400)
 
     def test_get_policy_disk_check(self):
-        url = f"/checks/{self.policyDiskCheck.pk}/check/"
+        # setup data
+        policy = baker.make("automation.Policy")
+        disk_check = baker.make_recipe("checks.diskspace_check", policy=policy)
+
+        url = f"/checks/{disk_check.pk}/check/"
 
         resp = self.client.get(url, format="json")
-        serializer = CheckSerializer(self.policyDiskCheck)
+        serializer = CheckSerializer(disk_check)
 
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(resp.data, serializer.data)
         self.check_not_authenticated("post", url)
 
     def test_add_policy_disk_check(self):
+        # setup data
+        policy = baker.make("automation.Policy")
+
         url = "/checks/checks/"
 
         valid_payload = {
-            "policy": self.policy.pk,
+            "policy": policy.pk,
             "check": {
                 "check_type": "diskspace",
-                "disk": "D:",
+                "disk": "M:",
                 "threshold": 86,
                 "fails_b4_alert": 2,
             },
@@ -71,7 +90,7 @@ class TestCheckViews(BaseTestCase):
 
         # this should fail because we already have a check for drive M: in setup
         invalid_payload = {
-            "policy": self.policy.pk,
+            "policy": policy.pk,
             "check": {
                 "check_type": "diskspace",
                 "disk": "M:",
@@ -90,8 +109,14 @@ class TestCheckViews(BaseTestCase):
         self.assertEqual(26, len(r.data))
 
     def test_edit_check_alert(self):
-        url_a = f"/checks/{self.agentDiskCheck.pk}/check/"
-        url_p = f"/checks/{self.policyDiskCheck.pk}/check/"
+        # setup data
+        policy = baker.make("automation.Policy")
+        agent = baker.make_recipe("agents.agent")
+
+        policy_disk_check = baker.make_recipe("checks.diskspace_check", policy=policy)
+        agent_disk_check = baker.make_recipe("checks.diskspace_check", agent=agent)
+        url_a = f"/checks/{agent_disk_check.pk}/check/"
+        url_p = f"/checks/{policy_disk_check.pk}/check/"
 
         valid_payload = {"email_alert": False, "check_alert": True}
         invalid_payload = {"email_alert": False}

api/tacticalrmm/checks/urls.py

@@ -2,7 +2,7 @@ from django.urls import path
 from . import views
 
 urlpatterns = [
-    path("checks/", views.GetAddCheck.as_view()),
+    path("checks/", views.AddCheck.as_view()),
     path("<int:pk>/check/", views.GetUpdateDeleteCheck.as_view()),
     path("<pk>/loadchecks/", views.load_checks),
     path("getalldisks/", views.get_disks_for_policies),

api/tacticalrmm/checks/views.py

@@ -1,3 +1,5 @@
+import asyncio
+
 from django.shortcuts import get_object_or_404
 
 from rest_framework.views import APIView
@@ -13,7 +15,6 @@ from scripts.models import Script
 
 from .serializers import CheckSerializer
 
-from .tasks import run_checks_task
 
 from automation.tasks import (
     generate_agent_checks_from_policies_task,
@@ -22,11 +23,7 @@ from automation.tasks import (
 )
 
 
-class GetAddCheck(APIView):
-    def get(self, request):
-        checks = Check.objects.all()
-        return Response(CheckSerializer(checks, many=True).data)
-
+class AddCheck(APIView):
     def post(self, request):
         policy = None
         agent = None
@@ -39,17 +36,6 @@ class GetAddCheck(APIView):
         else:
             agent = get_object_or_404(Agent, pk=request.data["pk"])
             parent = {"agent": agent}
-            added = "0.11.0"
-            if (
-                request.data["check"]["check_type"] == "script"
-                and request.data["check"]["script_args"]
-                and agent.not_supported(version_added=added)
-            ):
-                return notify_error(
-                    {
-                        "non_field_errors": f"Script arguments only available in agent {added} or greater"
-                    }
-                )
 
         script = None
         if "script" in request.data["check"]:
@@ -61,13 +47,6 @@ class GetAddCheck(APIView):
             request.data["check"]["check_type"] == "eventlog"
             and request.data["check"]["event_id_is_wildcard"]
         ):
-            if agent and agent.not_supported(version_added="0.10.2"):
-                return notify_error(
-                    {
-                        "non_field_errors": "Wildcard is only available in agent 0.10.2 or greater"
-                    }
-                )
-
             request.data["check"]["event_id"] = 0
 
         serializer = CheckSerializer(
@@ -119,31 +98,8 @@ class GetUpdateDeleteCheck(APIView):
                 pass
             else:
                 if request.data["event_id_is_wildcard"]:
-                    if check.agent.not_supported(version_added="0.10.2"):
-                        return notify_error(
-                            {
-                                "non_field_errors": "Wildcard is only available in agent 0.10.2 or greater"
-                            }
-                        )
-
                     request.data["event_id"] = 0
 
-        elif check.check_type == "script":
-            added = "0.11.0"
-            try:
-                request.data["script_args"]
-            except KeyError:
-                pass
-            else:
-                if request.data["script_args"] and check.agent.not_supported(
-                    version_added=added
-                ):
-                    return notify_error(
-                        {
-                            "non_field_errors": f"Script arguments only available in agent {added} or greater"
-                        }
-                    )
-
         serializer = CheckSerializer(instance=check, data=request.data, partial=True)
         serializer.is_valid(raise_exception=True)
         obj = serializer.save()
@@ -182,7 +138,10 @@ class GetUpdateDeleteCheck(APIView):
 @api_view()
 def run_checks(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
-    run_checks_task.delay(agent.pk)
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+
+    asyncio.run(agent.nats_cmd({"func": "runchecks"}, wait=False))
     return Response(agent.hostname)
 
 

api/tacticalrmm/clients/migrations/0007_auto_20201102_1920.py

@@ -0,0 +1,23 @@
+# Generated by Django 3.1.2 on 2020-11-02 19:20
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('clients', '0006_deployment'),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name='client',
+            old_name='client',
+            new_name='name',
+        ),
+        migrations.RenameField(
+            model_name='site',
+            old_name='site',
+            new_name='name',
+        ),
+    ]

api/tacticalrmm/clients/migrations/0008_auto_20201103_1430.py

@@ -0,0 +1,21 @@
+# Generated by Django 3.1.2 on 2020-11-03 14:30
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('clients', '0007_auto_20201102_1920'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='client',
+            options={'ordering': ('name',)},
+        ),
+        migrations.AlterModelOptions(
+            name='site',
+            options={'ordering': ('name',)},
+        ),
+    ]

api/tacticalrmm/clients/models.py

@@ -7,7 +7,7 @@ from logs.models import BaseAuditModel
 
 
 class Client(BaseAuditModel):
-    client = models.CharField(max_length=255, unique=True)
+    name = models.CharField(max_length=255, unique=True)
     workstation_policy = models.ForeignKey(
         "automation.Policy",
         related_name="workstation_clients",
@@ -24,13 +24,16 @@ class Client(BaseAuditModel):
         on_delete=models.SET_NULL,
     )
 
+    class Meta:
+        ordering = ("name",)
+
     def __str__(self):
-        return self.client
+        return self.name
 
     @property
     def has_maintenanace_mode_agents(self):
         return (
-            Agent.objects.filter(client=self.client, maintenance_mode=True).count() > 0
+            Agent.objects.filter(site__client=self, maintenance_mode=True).count() > 0
         )
 
     @property
@@ -44,7 +47,7 @@ class Client(BaseAuditModel):
                 "last_seen",
                 "overdue_time",
             )
-            .filter(client=self.client)
+            .filter(site__client=self)
             .prefetch_related("agentchecks")
         )
         for agent in agents:
@@ -52,8 +55,7 @@ class Client(BaseAuditModel):
                 return True
 
             if agent.overdue_email_alert or agent.overdue_text_alert:
-                if agent.status == "overdue":
-                    return True
+                return agent.status == "overdue"
 
         return False
 
@@ -67,7 +69,7 @@ class Client(BaseAuditModel):
 
 class Site(BaseAuditModel):
     client = models.ForeignKey(Client, related_name="sites", on_delete=models.CASCADE)
-    site = models.CharField(max_length=255)
+    name = models.CharField(max_length=255)
     workstation_policy = models.ForeignKey(
         "automation.Policy",
         related_name="workstation_sites",
@@ -84,17 +86,15 @@ class Site(BaseAuditModel):
         on_delete=models.SET_NULL,
     )
 
+    class Meta:
+        ordering = ("name",)
+
     def __str__(self):
-        return self.site
+        return self.name
 
     @property
     def has_maintenanace_mode_agents(self):
-        return (
-            Agent.objects.filter(
-                client=self.client.client, site=self.site, maintenance_mode=True
-            ).count()
-            > 0
-        )
+        return Agent.objects.filter(site=self, maintenance_mode=True).count() > 0
 
     @property
     def has_failing_checks(self):
@@ -107,7 +107,7 @@ class Site(BaseAuditModel):
                 "last_seen",
                 "overdue_time",
             )
-            .filter(client=self.client.client, site=self.site)
+            .filter(site=self)
             .prefetch_related("agentchecks")
         )
         for agent in agents:
@@ -115,8 +115,7 @@ class Site(BaseAuditModel):
                 return True
 
             if agent.overdue_email_alert or agent.overdue_text_alert:
-                if agent.status == "overdue":
-                    return True
+                return agent.status == "overdue"
 
         return False
 
@@ -128,13 +127,6 @@ class Site(BaseAuditModel):
         return SiteSerializer(site).data
 
 
-def validate_name(name):
-    if "|" in name:
-        return False
-    else:
-        return True
-
-
 MON_TYPE_CHOICES = [
     ("server", "Server"),
     ("workstation", "Workstation"),

api/tacticalrmm/clients/serializers.py

@@ -3,19 +3,25 @@ from .models import Client, Site, Deployment
 
 
 class SiteSerializer(ModelSerializer):
+    client_name = ReadOnlyField(source="client.name")
+
     class Meta:
         model = Site
         fields = "__all__"
 
     def validate(self, val):
-        if "|" in val["site"]:
+        if "|" in val["name"]:
             raise ValidationError("Site name cannot contain the | character")
 
+        if self.context:
+            client = Client.objects.get(pk=self.context["clientpk"])
+            if Site.objects.filter(client=client, name=val["name"]).exists():
+                raise ValidationError(f"Site {val['name']} already exists")
+
         return val
 
 
 class ClientSerializer(ModelSerializer):
-
     sites = SiteSerializer(many=True, read_only=True)
 
     class Meta:
@@ -30,29 +36,38 @@ class ClientSerializer(ModelSerializer):
             if len(self.context["site"]) > 255:
                 raise ValidationError("Site name too long")
 
-        if "|" in val["client"]:
+        if "|" in val["name"]:
             raise ValidationError("Client name cannot contain the | character")
 
         return val
 
 
-class TreeSerializer(ModelSerializer):
-    client_name = ReadOnlyField(source="client.client")
+class SiteTreeSerializer(ModelSerializer):
+    maintenance_mode = ReadOnlyField(source="has_maintenanace_mode_agents")
+    failing_checks = ReadOnlyField(source="has_failing_checks")
 
     class Meta:
         model = Site
-        fields = (
-            "id",
-            "site",
-            "client_name",
-        )
+        fields = "__all__"
+        ordering = ("failing_checks",)
+
+
+class ClientTreeSerializer(ModelSerializer):
+    sites = SiteTreeSerializer(many=True, read_only=True)
+    maintenance_mode = ReadOnlyField(source="has_maintenanace_mode_agents")
+    failing_checks = ReadOnlyField(source="has_failing_checks")
+
+    class Meta:
+        model = Client
+        fields = "__all__"
+        ordering = ("failing_checks",)
 
 
 class DeploymentSerializer(ModelSerializer):
     client_id = ReadOnlyField(source="client.id")
     site_id = ReadOnlyField(source="site.id")
-    client_name = ReadOnlyField(source="client.client")
-    site_name = ReadOnlyField(source="site.site")
+    client_name = ReadOnlyField(source="client.name")
+    site_name = ReadOnlyField(source="site.name")
 
     class Meta:
         model = Deployment

api/tacticalrmm/clients/tests.py

@@ -1,16 +1,32 @@
 import uuid
-from unittest import mock
-
-from tacticalrmm.test import BaseTestCase
-
+from tacticalrmm.test import TacticalTestCase
+from model_bakery import baker
 from .models import Client, Site, Deployment
+from rest_framework.serializers import ValidationError
+
+from .serializers import (
+    ClientSerializer,
+    SiteSerializer,
+    ClientTreeSerializer,
+    DeploymentSerializer,
+)
 
 
-class TestClientViews(BaseTestCase):
+class TestClientViews(TacticalTestCase):
+    def setUp(self):
+        self.authenticate()
+        self.setup_coresettings()
+
     def test_get_clients(self):
+        # setup data
+        baker.make("clients.Client", _quantity=5)
+        clients = Client.objects.all()
+
         url = "/clients/clients/"
-        r = self.client.get(url)
+        r = self.client.get(url, format="json")
+        serializer = ClientSerializer(clients, many=True)
         self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.data, serializer.data)
 
         self.check_not_authenticated("get", url)
 
@@ -21,15 +37,42 @@ class TestClientViews(BaseTestCase):
         self.assertEqual(r.status_code, 200)
 
         payload["client"] = "Company1|askd"
+        serializer = ClientSerializer(data={"name": payload["client"]}, context=payload)
+        with self.assertRaisesMessage(
+            ValidationError, "Client name cannot contain the | character"
+        ):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
+
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 400)
 
-        payload = {"client": "Company 1", "site": "Site2|a34"}
+        payload = {"client": "Company 156", "site": "Site2|a34"}
+        serializer = ClientSerializer(data={"name": payload["client"]}, context=payload)
+        with self.assertRaisesMessage(
+            ValidationError, "Site name cannot contain the | character"
+        ):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
+
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 400)
 
         # test unique
         payload = {"client": "Company 1", "site": "Site 1"}
+        serializer = ClientSerializer(data={"name": payload["client"]}, context=payload)
+        with self.assertRaisesMessage(
+            ValidationError, "client with this name already exists."
+        ):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
+
+        r = self.client.post(url, payload, format="json")
+        self.assertEqual(r.status_code, 400)
+
+        # test long site name
+        payload = {"client": "Company 2394", "site": "Site123" * 100}
+        serializer = ClientSerializer(data={"name": payload["client"]}, context=payload)
+        with self.assertRaisesMessage(ValidationError, "Site name too long"):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
+
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 400)
 
@@ -41,88 +84,177 @@ class TestClientViews(BaseTestCase):
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
 
-    def test_get_sites(self):
-        url = "/clients/sites/"
-        r = self.client.get(url)
+        self.check_not_authenticated("post", url)
+
+    def test_edit_client(self):
+        # setup data
+        client = baker.make("clients.Client")
+
+        # test invalid id
+        r = self.client.put("/clients/500/client/", format="json")
+        self.assertEqual(r.status_code, 404)
+
+        data = {"id": client.id, "name": "New Name"}
+
+        url = f"/clients/{client.id}/client/"
+        r = self.client.put(url, data, format="json")
         self.assertEqual(r.status_code, 200)
+        self.assertTrue(Client.objects.filter(name="New Name").exists())
+
+        self.check_not_authenticated("put", url)
+
+    def test_delete_client(self):
+        # setup data
+        client = baker.make("clients.Client")
+        site = baker.make("clients.Site", client=client)
+        agent = baker.make_recipe("agents.agent", site=site)
+
+        # test invalid id
+        r = self.client.delete("/clients/500/client/", format="json")
+        self.assertEqual(r.status_code, 404)
+
+        url = f"/clients/{client.id}/client/"
+
+        # test deleting with agents under client
+        r = self.client.delete(url, format="json")
+        self.assertEqual(r.status_code, 400)
+
+        # test successful deletion
+        agent.delete()
+        r = self.client.delete(url, format="json")
+        self.assertEqual(r.status_code, 200)
+        self.assertFalse(Client.objects.filter(pk=client.id).exists())
+        self.assertFalse(Site.objects.filter(pk=site.id).exists())
+
+        self.check_not_authenticated("put", url)
+
+    def test_get_sites(self):
+        # setup data
+        baker.make("clients.Site", _quantity=5)
+        sites = Site.objects.all()
+
+        url = "/clients/sites/"
+        r = self.client.get(url, format="json")
+        serializer = SiteSerializer(sites, many=True)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.data, serializer.data)
 
         self.check_not_authenticated("get", url)
 
     def test_add_site(self):
-        url = "/clients/addsite/"
+        # setup data
+        site = baker.make("clients.Site")
 
-        payload = {"client": "Google", "site": "LA Office"}
-        r = self.client.post(url, payload, format="json")
-        self.assertEqual(r.status_code, 400)
+        url = "/clients/sites/"
 
-        payload = {"client": "Google", "site": "LA Off|ice  |*&@#$"}
-        r = self.client.post(url, payload, format="json")
-        self.assertEqual(r.status_code, 400)
-
-        payload = {"client": "Google", "site": "KN Office"}
+        # test success add
+        payload = {"client": site.client.id, "name": "LA Office"}
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
+        self.assertTrue(
+            Site.objects.filter(
+                name="LA Office", client__name=site.client.name
+            ).exists()
+        )
+
+        # test with | symbol
+        payload = {"client": site.client.id, "name": "LA Off|ice  |*&@#$"}
+        serializer = SiteSerializer(data=payload, context={"clientpk": site.client.id})
+        with self.assertRaisesMessage(
+            ValidationError, "Site name cannot contain the | character"
+        ):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
+
+        r = self.client.post(url, payload, format="json")
+        self.assertEqual(r.status_code, 400)
+
+        # test site already exists
+        payload = {"client": site.client.id, "name": "LA Office"}
+        serializer = SiteSerializer(data=payload, context={"clientpk": site.client.id})
+        with self.assertRaisesMessage(ValidationError, "Site LA Office already exists"):
+            self.assertFalse(serializer.is_valid(raise_exception=True))
 
         self.check_not_authenticated("post", url)
 
-    def test_list_clients(self):
-        url = "/clients/listclients/"
+    def test_edit_site(self):
+        # setup data
+        site = baker.make("clients.Site")
 
-        r = self.client.get(url)
+        # test invalid id
+        r = self.client.put("/clients/500/site/", format="json")
+        self.assertEqual(r.status_code, 404)
+
+        data = {"id": site.id, "name": "New Name", "client": site.client.id}
+
+        url = f"/clients/{site.id}/site/"
+        r = self.client.put(url, data, format="json")
         self.assertEqual(r.status_code, 200)
+        self.assertTrue(Site.objects.filter(name="New Name").exists())
 
-        self.check_not_authenticated("get", url)
+        self.check_not_authenticated("put", url)
 
-    def test_load_tree(self):
+    def test_delete_site(self):
+        # setup data
+        site = baker.make("clients.Site")
+        agent = baker.make_recipe("agents.agent", site=site)
 
-        with mock.patch(
-            "clients.models.Client.has_failing_checks",
-            new_callable=mock.PropertyMock,
-            return_value=True,
-        ):
+        # test invalid id
+        r = self.client.delete("/clients/500/site/", format="json")
+        self.assertEqual(r.status_code, 404)
 
-            url = "/clients/loadtree/"
+        url = f"/clients/{site.id}/site/"
 
-            r = self.client.get(url)
-            self.assertEqual(r.status_code, 200)
+        # test deleting with last site under client
+        r = self.client.delete(url, format="json")
+        self.assertEqual(r.status_code, 400)
 
-            client = Client.objects.get(client="Facebook")
-            self.assertTrue(f"Facebook|{client.pk}|negative" in r.data.keys())
+        # test deletion when agents exist under site
+        baker.make("clients.Site", client=site.client)
+        r = self.client.delete(url, format="json")
+        self.assertEqual(r.status_code, 400)
 
-        with mock.patch(
-            "clients.models.Site.has_failing_checks",
-            new_callable=mock.PropertyMock,
-            return_value=False,
-        ):
-
-            client = Client.objects.get(client="Google")
-            site = Site.objects.get(client=client, site="LA Office")
-            self.assertTrue(
-                f"LA Office|{site.pk}|black" in [i for i in r.data.values()][0]
-            )
-
-        self.check_not_authenticated("get", url)
-
-    def test_load_clients(self):
-        url = "/clients/loadclients/"
-
-        r = self.client.get(url)
+        # test successful deletion
+        agent.delete()
+        r = self.client.delete(url, format="json")
         self.assertEqual(r.status_code, 200)
+        self.assertFalse(Site.objects.filter(pk=site.id).exists())
+
+        self.check_not_authenticated("delete", url)
+
+    def test_get_tree(self):
+        # setup data
+        baker.make("clients.Site", _quantity=10)
+        clients = Client.objects.all()
+
+        url = "/clients/tree/"
+
+        r = self.client.get(url, format="json")
+        serializer = ClientTreeSerializer(clients, many=True)
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.data, serializer.data)
 
         self.check_not_authenticated("get", url)
 
     def test_get_deployments(self):
+        # setup data
+        deployments = baker.make("clients.Deployment", _quantity=5)
+
         url = "/clients/deployments/"
         r = self.client.get(url)
+        serializer = DeploymentSerializer(deployments, many=True)
         self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.data, serializer.data)
 
         self.check_not_authenticated("get", url)
 
     def test_add_deployment(self):
+        # setup data
+        site = baker.make("clients.Site")
+
         url = "/clients/deployments/"
         payload = {
-            "client": "Google",
-            "site": "Main Office",
+            "client": site.client.id,
+            "site": site.id,
             "expires": "2037-11-23 18:53",
             "power": 1,
             "ping": 0,
@@ -134,36 +266,26 @@ class TestClientViews(BaseTestCase):
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 200)
 
-        payload["site"] = "ASDkjh23k4jh"
+        payload["site"] = "500"
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 404)
 
-        payload["client"] = "324234ASDqwe"
+        payload["client"] = "500"
         r = self.client.post(url, payload, format="json")
         self.assertEqual(r.status_code, 404)
 
         self.check_not_authenticated("post", url)
 
     def test_delete_deployment(self):
+        # setup data
+        deployment = baker.make("clients.Deployment")
+
         url = "/clients/deployments/"
-        payload = {
-            "client": "Google",
-            "site": "Main Office",
-            "expires": "2037-11-23 18:53",
-            "power": 1,
-            "ping": 0,
-            "rdp": 1,
-            "agenttype": "server",
-            "arch": "64",
-        }
 
-        r = self.client.post(url, payload, format="json")
-        self.assertEqual(r.status_code, 200)
-
-        dep = Deployment.objects.last()
-        url = f"/clients/{dep.pk}/deployment/"
+        url = f"/clients/{deployment.id}/deployment/"
         r = self.client.delete(url)
         self.assertEqual(r.status_code, 200)
+        self.assertFalse(Deployment.objects.filter(pk=deployment.id).exists())
 
         url = "/clients/32348/deployment/"
         r = self.client.delete(url)

api/tacticalrmm/clients/urls.py

@@ -4,14 +4,9 @@ from . import views
 urlpatterns = [
     path("clients/", views.GetAddClients.as_view()),
     path("<int:pk>/client/", views.GetUpdateDeleteClient.as_view()),
+    path("tree/", views.GetClientTree.as_view()),
     path("sites/", views.GetAddSites.as_view()),
-    path("listclients/", views.list_clients),
-    path("listsites/", views.list_sites),
-    path("addsite/", views.add_site),
-    path("editsite/", views.edit_site),
-    path("deletesite/", views.delete_site),
-    path("loadtree/", views.load_tree),
-    path("loadclients/", views.load_clients),
+    path("<int:pk>/site/", views.GetUpdateDeleteSite.as_view()),
     path("deployments/", views.AgentDeployment.as_view()),
     path("<int:pk>/deployment/", views.AgentDeployment.as_view()),
     path("<str:uid>/deploy/", views.GenerateAgent.as_view()),

api/tacticalrmm/clients/views.py

@@ -22,10 +22,10 @@ from rest_framework.decorators import api_view
 from .serializers import (
     ClientSerializer,
     SiteSerializer,
-    TreeSerializer,
+    ClientTreeSerializer,
     DeploymentSerializer,
 )
-from .models import Client, Site, Deployment, validate_name
+from .models import Client, Site, Deployment
 from agents.models import Agent
 from core.models import CoreSettings
 from tacticalrmm.utils import notify_error
@@ -39,51 +39,50 @@ class GetAddClients(APIView):
     def post(self, request):
 
         if "initialsetup" in request.data:
-            client = {"client": request.data["client"]["client"].strip()}
-            site = {"site": request.data["client"]["site"].strip()}
+            client = {"name": request.data["client"]["client"].strip()}
+            site = {"name": request.data["client"]["site"].strip()}
             serializer = ClientSerializer(data=client, context=request.data["client"])
             serializer.is_valid(raise_exception=True)
             core = CoreSettings.objects.first()
             core.default_time_zone = request.data["timezone"]
             core.save(update_fields=["default_time_zone"])
         else:
-            client = {"client": request.data["client"].strip()}
-            site = {"site": request.data["site"].strip()}
+            client = {"name": request.data["client"].strip()}
+            site = {"name": request.data["site"].strip()}
             serializer = ClientSerializer(data=client, context=request.data)
             serializer.is_valid(raise_exception=True)
 
         obj = serializer.save()
-        Site(client=obj, site=site["site"]).save()
+        Site(client=obj, name=site["name"]).save()
 
         return Response(f"{obj} was added!")
 
 
 class GetUpdateDeleteClient(APIView):
-    def patch(self, request, pk):
+    def put(self, request, pk):
         client = get_object_or_404(Client, pk=pk)
-        orig = client.client
-
         serializer = ClientSerializer(data=request.data, instance=client)
         serializer.is_valid(raise_exception=True)
-        obj = serializer.save()
+        serializer.save()
 
-        agents = Agent.objects.filter(client=orig)
-        for agent in agents:
-            agent.client = obj.client
-            agent.save(update_fields=["client"])
-
-        return Response(f"{orig} renamed to {obj}")
+        return Response("The Client was renamed")
 
     def delete(self, request, pk):
         client = get_object_or_404(Client, pk=pk)
-        agents = Agent.objects.filter(client=client.client)
-        if agents.exists():
+        agent_count = Agent.objects.filter(site__client=client).count()
+        if agent_count > 0:
             return notify_error(
-                f"Cannot delete {client} while {agents.count()} agents exist in it. Move the agents to another client first."
+                f"Cannot delete {client} while {agent_count} agents exist in it. Move the agents to another client first."
             )
 
         client.delete()
-        return Response(f"{client.client} was deleted!")
+        return Response(f"{client.name} was deleted!")
+
+
+class GetClientTree(APIView):
+    def get(self, request):
+        clients = Client.objects.all()
+        return Response(ClientTreeSerializer(clients, many=True).data)
 
 
 class GetAddSites(APIView):
@@ -91,126 +90,42 @@ class GetAddSites(APIView):
         sites = Site.objects.all()
         return Response(SiteSerializer(sites, many=True).data)
 
+    def post(self, request):
+        name = request.data["name"].strip()
+        serializer = SiteSerializer(
+            data={"name": name, "client": request.data["client"]},
+            context={"clientpk": request.data["client"]},
+        )
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
 
-@api_view(["POST"])
-def add_site(request):
-    client = Client.objects.get(client=request.data["client"].strip())
-    site = request.data["site"].strip()
-
-    if not validate_name(site):
-        content = {"error": "Site name cannot contain the | character"}
-        return Response(content, status=status.HTTP_400_BAD_REQUEST)
-
-    if Site.objects.filter(client=client).filter(site=site):
-        content = {"error": f"Site {site} already exists"}
-        return Response(content, status=status.HTTP_400_BAD_REQUEST)
-
-    try:
-        Site(client=client, site=site).save()
-    except DataError:
-        content = {"error": "Site name too long (max 255 chars)"}
-        return Response(content, status=status.HTTP_400_BAD_REQUEST)
-    else:
         return Response("ok")
 
 
-@api_view(["PATCH"])
-def edit_site(request):
-    new_name = request.data["name"].strip()
+class GetUpdateDeleteSite(APIView):
+    def put(self, request, pk):
 
-    if not validate_name(new_name):
-        err = "Site name cannot contain the | character"
-        return Response(err, status=status.HTTP_400_BAD_REQUEST)
+        site = get_object_or_404(Site, pk=pk)
+        serializer = SiteSerializer(instance=site, data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
 
-    client = get_object_or_404(Client, client=request.data["client"])
-    site = Site.objects.filter(client=client).filter(site=request.data["site"]).get()
+        return Response("ok")
 
-    agents = Agent.objects.filter(client=client.client).filter(site=site.site)
+    def delete(self, request, pk):
+        site = get_object_or_404(Site, pk=pk)
+        if site.client.sites.count() == 1:
+            return notify_error(f"A client must have at least 1 site.")
 
-    site.site = new_name
-    site.save(update_fields=["site"])
+        agent_count = Agent.objects.filter(site=site).count()
 
-    for agent in agents:
-        agent.site = new_name
-        agent.save(update_fields=["site"])
+        if agent_count > 0:
+            return notify_error(
+                f"Cannot delete {site.name} while {agent_count} agents exist in it. Move the agents to another site first."
+            )
 
-    return Response("ok")
-
-
-@api_view(["DELETE"])
-def delete_site(request):
-    client = get_object_or_404(Client, client=request.data["client"])
-    if client.sites.count() == 1:
-        return notify_error(f"A client must have at least 1 site.")
-
-    site = Site.objects.filter(client=client).filter(site=request.data["site"]).get()
-    agents = Agent.objects.filter(client=client.client).filter(site=site.site)
-
-    if agents.exists():
-        return notify_error(
-            f"Cannot delete {site} while {agents.count()} agents exist in it. Move the agents to another site first."
-        )
-
-    site.delete()
-    return Response(f"{site} was deleted!")
-
-
-@api_view()
-# for vue
-def list_clients(request):
-    clients = Client.objects.all()
-    return Response(ClientSerializer(clients, many=True).data)
-
-
-@api_view()
-# for vue
-def list_sites(request):
-    sites = Site.objects.all()
-    return Response(TreeSerializer(sites, many=True).data)
-
-
-@api_view()
-def load_tree(request):
-    clients = Client.objects.all()
-    new = {}
-
-    for x in clients:
-        b = []
-
-        sites = Site.objects.filter(client=x)
-        for i in sites:
-
-            if i.has_maintenanace_mode_agents:
-                b.append(f"{i.site}|{i.pk}|warning")
-            elif i.has_failing_checks:
-                b.append(f"{i.site}|{i.pk}|negative")
-            else:
-                b.append(f"{i.site}|{i.pk}|black")
-
-            if x.has_maintenanace_mode_agents:
-                new[f"{x.client}|{x.pk}|warning"] = b
-            elif x.has_failing_checks:
-                new[f"{x.client}|{x.pk}|negative"] = b
-            else:
-                new[f"{x.client}|{x.pk}|black"] = b
-
-    return Response(new)
-
-
-@api_view()
-def load_clients(request):
-    clients = Client.objects.all()
-    new = {}
-
-    for x in clients:
-        b = []
-
-        sites = Site.objects.filter(client=x)
-        for i in sites:
-            b.append(i.site)
-            new[x.client] = b
-
-    return Response(new)
+        site.delete()
+        return Response(f"{site.name} was deleted!")
 
 
 class AgentDeployment(APIView):
@@ -221,8 +136,8 @@ class AgentDeployment(APIView):
     def post(self, request):
         from knox.models import AuthToken
 
-        client = get_object_or_404(Client, client=request.data["client"])
-        site = get_object_or_404(Site, client=client, site=request.data["site"])
+        client = get_object_or_404(Client, pk=request.data["client"])
+        site = get_object_or_404(Site, pk=request.data["site"])
 
         expires = dt.datetime.strptime(
             request.data["expires"], "%Y-%m-%d %H:%M"
@@ -285,8 +200,8 @@ class GenerateAgent(APIView):
         )
         download_url = settings.DL_64 if d.arch == "64" else settings.DL_32
 
-        client = d.client.client.replace(" ", "").lower()
-        site = d.site.site.replace(" ", "").lower()
+        client = d.client.name.replace(" ", "").lower()
+        site = d.site.name.replace(" ", "").lower()
         client = re.sub(r"([^a-zA-Z0-9]+)", "", client)
         site = re.sub(r"([^a-zA-Z0-9]+)", "", site)
 

api/tacticalrmm/core/goinstaller/installer.go

@@ -56,8 +56,8 @@ func downloadAgent(filepath string) (err error) {
 func main() {
 
 	debugLog := flag.String("log", "", "Verbose output")
-	localSalt := flag.String("local-salt", "", "Use local salt minion")
 	localMesh := flag.String("local-mesh", "", "Use local mesh agent")
+	noSalt := flag.Bool("nosalt", false, "Does not install salt")
 	cert := flag.String("cert", "", "Path to ca.pem")
 	timeout := flag.String("timeout", "", "Timeout for subprocess calls")
 	flag.Parse()
@@ -81,8 +81,8 @@ func main() {
 		cmdArgs = append(cmdArgs, "--log", "DEBUG")
 	}
 
-	if len(strings.TrimSpace(*localSalt)) != 0 {
-		cmdArgs = append(cmdArgs, "--local-salt", *localSalt)
+	if *noSalt {
+		cmdArgs = append(cmdArgs, "-nosalt")
 	}
 
 	if len(strings.TrimSpace(*localMesh)) != 0 {
@@ -133,7 +133,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	time.Sleep(20 * time.Second)
+	time.Sleep(10 * time.Second)
 
 	fmt.Println("Installation starting.")
 	cmd := exec.Command(tacrmm, cmdArgs...)

api/tacticalrmm/core/installer.ps1

@@ -36,7 +36,7 @@ If (Get-Service $serviceName -ErrorAction SilentlyContinue) {
         Invoke-WebRequest -Uri $downloadlink -OutFile $OutPath\$output
         Start-Process -FilePath $OutPath\$output -ArgumentList ('/VERYSILENT /SUPPRESSMSGBOXES') -Wait
         write-host ('Extracting...')
-        Start-Sleep -s 20
+        Start-Sleep -s 10
         Start-Process -FilePath "C:\Program Files\TacticalAgent\tacticalrmm.exe" -ArgumentList $installArgs -Wait
         exit 0
     }

api/tacticalrmm/core/management/commands/get_mesh_exe_url.py

@@ -3,7 +3,6 @@ from django.conf import settings
 from core.models import CoreSettings
 from .helpers import get_auth_token
 import asyncio
-import ssl
 import websockets
 import json
 
@@ -11,15 +10,14 @@ import json
 class Command(BaseCommand):
     help = "Sets up initial mesh central configuration"
 
-    async def websocket_call(self):
-        token = get_auth_token(
-            self.mesh_settings.mesh_username, self.mesh_settings.mesh_token
-        )
+    async def websocket_call(self, mesh_settings):
+        token = get_auth_token(mesh_settings.mesh_username, mesh_settings.mesh_token)
 
-        if settings.MESH_WS_URL:
-            uri = f"{settings.MESH_WS_URL}/control.ashx?auth={token}"
+        if settings.DOCKER_BUILD:
+            site = mesh_settings.mesh_site.replace("https", "ws")
+            uri = f"{site}:443/control.ashx?auth={token}"
         else:
-            site = self.mesh_settings.mesh_site.replace("https", "wss")
+            site = mesh_settings.mesh_site.replace("https", "wss")
             uri = f"{site}/control.ashx?auth={token}"
 
         async with websockets.connect(uri) as websocket:
@@ -45,5 +43,5 @@ class Command(BaseCommand):
                     break
 
     def handle(self, *args, **kwargs):
-        self.mesh_settings = CoreSettings.objects.first()
-        asyncio.get_event_loop().run_until_complete(self.websocket_call())
+        mesh_settings = CoreSettings.objects.first()
+        asyncio.get_event_loop().run_until_complete(self.websocket_call(mesh_settings))

api/tacticalrmm/core/management/commands/initial_mesh_setup.py

@@ -1,53 +1,90 @@
-from django.core.management.base import BaseCommand
-from django.conf import settings
-from core.models import CoreSettings
-from .helpers import get_auth_token
-import asyncio
-import websockets
-import json
-
-
-class Command(BaseCommand):
-    help = "Sets up initial mesh central configuration"
-
-    async def websocket_call(self):
-
-        token = get_auth_token(
-            self.mesh_settings.mesh_username, self.mesh_settings.mesh_token
-        )
-
-        if settings.MESH_WS_URL:
-            uri = f"{settings.MESH_WS_URL}/control.ashx?auth={token}"
-        else:
-            site = self.mesh_settings.mesh_site.replace("https", "wss")
-            uri = f"{site}/control.ashx?auth={token}"
-
-        async with websockets.connect(uri) as websocket:
-
-            # Get Device groups to see if it exists
-            await websocket.send(json.dumps({"action": "meshes"}))
-
-            async for message in websocket:
-                response = json.loads(message)
-                if response["action"] == "meshes":
-
-                    # If no meshes are present
-                    if not response["meshes"]:
-                        await websocket.send(
-                            json.dumps(
-                                {
-                                    "action": "createmesh",
-                                    "meshname": "TacticalRMM",
-                                    "meshtype": 2,
-                                    "responseid": "python",
-                                }
-                            )
-                        )
-                        break
-                    else:
-                        break
-
-    def handle(self, *args, **kwargs):
-        self.mesh_settings = CoreSettings.objects.first()
-        asyncio.get_event_loop().run_until_complete(self.websocket_call())
-        self.stdout.write("Initial Mesh Central setup complete")
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from core.models import CoreSettings
+from .helpers import get_auth_token
+import asyncio
+import websockets
+import json
+
+
+class Command(BaseCommand):
+    help = "Sets up initial mesh central configuration"
+
+    async def websocket_call(self, mesh_settings):
+
+        token = get_auth_token(mesh_settings.mesh_username, mesh_settings.mesh_token)
+
+        if settings.DOCKER_BUILD:
+            site = mesh_settings.mesh_site.replace("https", "ws")
+            uri = f"{site}:443/control.ashx?auth={token}"
+        else:
+            site = mesh_settings.mesh_site.replace("https", "wss")
+            uri = f"{site}/control.ashx?auth={token}"
+
+        async with websockets.connect(uri) as websocket:
+
+            # Get Device groups to see if it exists
+            await websocket.send(json.dumps({"action": "meshes"}))
+
+            async for message in websocket:
+                response = json.loads(message)
+                if response["action"] == "meshes":
+
+                    # If no meshes are present
+                    if not response["meshes"]:
+                        await websocket.send(
+                            json.dumps(
+                                {
+                                    "action": "createmesh",
+                                    "meshname": "TacticalRMM",
+                                    "meshtype": 2,
+                                    "responseid": "python",
+                                }
+                            )
+                        )
+                        break
+                    else:
+                        break
+
+    def handle(self, *args, **kwargs):
+        mesh_settings = CoreSettings.objects.first()
+
+        try:
+            # Check for Mesh Username
+            if (
+                not mesh_settings.mesh_username
+                or settings.MESH_USERNAME != mesh_settings.mesh_username
+            ):
+                mesh_settings.mesh_username = settings.MESH_USERNAME
+
+            # Check for Mesh Site
+            if (
+                not mesh_settings.mesh_site
+                or settings.MESH_SITE != mesh_settings.mesh_site
+            ):
+                mesh_settings.mesh_site = settings.MESH_SITE
+
+            # Check for Mesh Token
+            if (
+                not mesh_settings.mesh_token
+                or settings.MESH_TOKEN_KEY != mesh_settings.mesh_token
+            ):
+                mesh_settings.mesh_token = settings.MESH_TOKEN_KEY
+
+            mesh_settings.save()
+
+        except AttributeError:
+            self.stdout.write(
+                "Mesh Setup was skipped because the configuration wasn't available. Needs to be setup manually."
+            )
+            return
+
+        try:
+            asyncio.get_event_loop().run_until_complete(
+                self.websocket_call(mesh_settings)
+            )
+            self.stdout.write("Initial Mesh Central setup complete")
+        except websockets.exceptions.ConnectionClosedError:
+            self.stdout.write(
+                "Unable to connect to MeshCentral. Please verify it is online and the configuration is correct in the settings."
+            )

api/tacticalrmm/core/management/commands/post_update_tasks.py

@@ -1,9 +1,7 @@
 import os
 import shutil
 import subprocess
-import sys
 import tempfile
-from time import sleep
 
 from django.core.management.base import BaseCommand
 
@@ -15,18 +13,6 @@ class Command(BaseCommand):
     help = "Collection of tasks to run after updating the rmm, after migrations"
 
     def handle(self, *args, **kwargs):
-
-        if not os.path.exists("/usr/local/bin/goversioninfo"):
-            self.stdout.write(self.style.ERROR("*" * 100))
-            self.stdout.write("\n")
-            self.stdout.write(
-                self.style.ERROR(
-                    "ERROR: New update script available. Delete this one and re-download."
-                )
-            )
-            self.stdout.write("\n")
-            sys.exit(1)
-
         # 10-16-2020 changed the type of the agent's 'disks' model field
         # from a dict of dicts, to a list of disks in the golang agent
         # the following will convert dicts to lists for agent's still on the python agent
@@ -43,88 +29,17 @@ class Command(BaseCommand):
                     self.style.SUCCESS(f"Migrated disks on {agent.hostname}")
                 )
 
-        # sync modules. split into chunks of 60 agents to not overload the salt master
-        agents = Agent.objects.all()
-        online = [i.salt_id for i in agents if i.status == "online"]
-
-        chunks = (online[i : i + 60] for i in range(0, len(online), 60))
-
-        self.stdout.write(self.style.SUCCESS("Syncing agent modules..."))
-        for chunk in chunks:
-            r = Agent.salt_batch_async(minions=chunk, func="saltutil.sync_modules")
-            sleep(5)
-
-        has_old_config = True
-        rmm_conf = "/etc/nginx/sites-available/rmm.conf"
-        if os.path.exists(rmm_conf):
-            with open(rmm_conf) as f:
-                for line in f:
-                    if "location" and "builtin" in line:
-                        has_old_config = False
-                        break
-
-        if has_old_config:
-            new_conf = """
-            location /builtin/ {
-                internal;
-                add_header "Access-Control-Allow-Origin" "https://rmm.yourwebsite.com";
-                alias /srv/salt/scripts/;
-            }
-            """
-
-            after_this = """
-            location /saltscripts/ {
-                internal;
-                add_header "Access-Control-Allow-Origin" "https://rmm.yourwebsite.com";
-                alias /srv/salt/scripts/userdefined/;
-            }
-            """
-
-            self.stdout.write(self.style.ERROR("*" * 100))
-            self.stdout.write("\n")
-            self.stdout.write(
-                self.style.ERROR(
-                    "WARNING: A recent update requires you to manually edit your nginx config"
-                )
-            )
-            self.stdout.write("\n")
-            self.stdout.write(
-                self.style.ERROR("Please add the following location block to ")
-                + self.style.WARNING(rmm_conf)
-            )
-            self.stdout.write(self.style.SUCCESS(new_conf))
-            self.stdout.write("\n")
-            self.stdout.write(
-                self.style.ERROR(
-                    "You can paste the above right after the following block that's already in your nginx config:"
-                )
-            )
-            self.stdout.write(after_this)
-            self.stdout.write("\n")
-            self.stdout.write(
-                self.style.ERROR(
-                    "Make sure to replace rmm.yourwebsite.com with your domain"
-                )
-            )
-            self.stdout.write(
-                self.style.ERROR("After editing, restart nginx with the command ")
-                + self.style.WARNING("sudo systemctl restart nginx")
-            )
-            self.stdout.write("\n")
-            self.stdout.write(self.style.ERROR("*" * 100))
-            input("Press Enter to continue...")
-
         # install go
         if not os.path.exists("/usr/local/rmmgo/"):
             self.stdout.write(self.style.SUCCESS("Installing golang"))
             subprocess.run("sudo mkdir -p /usr/local/rmmgo", shell=True)
             tmpdir = tempfile.mkdtemp()
             r = subprocess.run(
-                f"wget https://golang.org/dl/go1.15.linux-amd64.tar.gz -P {tmpdir}",
+                f"wget https://golang.org/dl/go1.15.5.linux-amd64.tar.gz -P {tmpdir}",
                 shell=True,
             )
 
-            gotar = os.path.join(tmpdir, "go1.15.linux-amd64.tar.gz")
+            gotar = os.path.join(tmpdir, "go1.15.5.linux-amd64.tar.gz")
 
             subprocess.run(f"tar -xzf {gotar} -C {tmpdir}", shell=True)
 

api/tacticalrmm/core/management/commands/reload_nats.py

@@ -0,0 +1,9 @@
+from django.core.management.base import BaseCommand
+from tacticalrmm.utils import reload_nats
+
+
+class Command(BaseCommand):
+    help = "Reload Nats"
+
+    def handle(self, *args, **kwargs):
+        reload_nats()

api/tacticalrmm/core/models.py

@@ -72,16 +72,14 @@ class CoreSettings(BaseAuditModel):
         if not self.pk and CoreSettings.objects.exists():
             raise ValidationError("There can only be one CoreSettings instance")
 
-        # Only runs on first create
+        # for install script
         if not self.pk:
-            mesh_settings = self.get_initial_mesh_settings()
-
-            if "mesh_token" in mesh_settings:
-                self.mesh_token = mesh_settings["mesh_token"]
-            if "mesh_username" in mesh_settings:
-                self.mesh_username = mesh_settings["mesh_username"]
-            if "mesh_site" in mesh_settings:
-                self.mesh_site = mesh_settings["mesh_site"]
+            try:
+                self.mesh_site = settings.MESH_SITE
+                self.mesh_username = settings.MESH_USERNAME
+                self.mesh_token = settings.MESH_TOKEN_KEY
+            except:
+                pass
 
         return super(CoreSettings, self).save(*args, **kwargs)
 
@@ -121,8 +119,8 @@ class CoreSettings(BaseAuditModel):
             and self.smtp_port
         ):
             return True
-        else:
-            return False
+
+        return False
 
     def send_mail(self, subject, body, test=False):
 
@@ -168,60 +166,9 @@ class CoreSettings(BaseAuditModel):
             except Exception as e:
                 logger.error(f"SMS failed to send: {e}")
 
-    def get_initial_mesh_settings(self):
-
-        mesh_settings = {}
-
-        # Check for Mesh Username
-        try:
-            if settings.MESH_USERNAME:
-                mesh_settings["mesh_username"] = settings.MESH_USERNAME
-            else:
-                raise AttributeError("MESH_USERNAME doesn't exist")
-        except AttributeError:
-            pass
-
-        # Check for Mesh Site
-        try:
-            if settings.MESH_SITE:
-                mesh_settings["mesh_site"] = settings.MESH_SITE
-            else:
-                raise AttributeError("MESH_SITE doesn't exist")
-        except AttributeError:
-            pass
-
-        # Check for Mesh Token
-        try:
-            if settings.MESH_TOKEN_KEY:
-                mesh_settings["mesh_token"] = settings.MESH_TOKEN_KEY
-            else:
-                raise AttributeError("MESH_TOKEN_KEY doesn't exist")
-        except AttributeError:
-            filepath = "/token/token.key"
-            counter = 0
-            while counter < 12:
-                try:
-                    with open(filepath, "r") as read_file:
-                        key = read_file.readlines()
-
-                        # Remove key file contents for security reasons
-                        with open(filepath, "w") as write_file:
-                            write_file.write("")
-
-                        # readlines() returns an array. Get first item
-                        mesh_settings["mesh_token"] = key[0].rstrip()
-                        break
-                except (IOError, IndexError):
-                    pass
-
-                counter = counter + 1
-                time.sleep(10)
-
-        return mesh_settings
-
     @staticmethod
     def serialize(core):
         # serializes the core and returns json
         from .serializers import CoreSerializer
 
-        return CoreSerializer(core).data
+        return CoreSerializer(core).data

api/tacticalrmm/core/tasks.py

@@ -4,8 +4,6 @@ from loguru import logger
 from django.conf import settings
 from django.utils import timezone as djangotime
 from tacticalrmm.celery import app
-from accounts.models import User
-from agents.models import Agent
 from autotasks.models import AutomatedTask
 from autotasks.tasks import delete_win_task_schedule
 
@@ -14,15 +12,6 @@ logger.configure(**settings.LOG_CONFIG)
 
 @app.task
 def core_maintenance_tasks():
-    # cleanup any leftover agent user accounts
-    agents = Agent.objects.values_list("agent_id", flat=True)
-    users = User.objects.exclude(username__in=agents).filter(last_login=None)
-    if users:
-        users.delete()
-        logger.info(
-            "Removed leftover agent user accounts:", str([i.username for i in users])
-        )
-
     # cleanup expired runonce tasks
     tasks = AutomatedTask.objects.filter(
         task_type="runonce",

api/tacticalrmm/core/tests.py

@@ -1,8 +1,14 @@
-from tacticalrmm.test import BaseTestCase
+from tacticalrmm.test import TacticalTestCase
 from core.tasks import core_maintenance_tasks
+from unittest.mock import patch
+from model_bakery import baker, seq
 
 
-class TestCoreTasks(BaseTestCase):
+class TestCoreTasks(TacticalTestCase):
+    def setUp(self):
+        self.setup_coresettings()
+        self.authenticate()
+
     def test_core_maintenance_tasks(self):
         task = core_maintenance_tasks.s().apply()
         self.assertEqual(task.state, "SUCCESS")
@@ -27,3 +33,45 @@ class TestCoreTasks(BaseTestCase):
         self.assertEqual(r.status_code, 200)
 
         self.check_not_authenticated("get", url)
+
+    @patch("autotasks.tasks.remove_orphaned_win_tasks.delay")
+    def test_ui_maintenance_actions(self, remove_orphaned_win_tasks):
+        url = "/core/servermaintenance/"
+
+        agents = baker.make_recipe("agents.online_agent", _quantity=3)
+
+        # test with empty data
+        r = self.client.post(url, {})
+        self.assertEqual(r.status_code, 400)
+
+        # test with invalid action
+        data = {"action": "invalid_action"}
+
+        r = self.client.post(url, data)
+        self.assertEqual(r.status_code, 400)
+
+        # test reload nats action
+        data = {"action": "reload_nats"}
+        r = self.client.post(url, data)
+        self.assertEqual(r.status_code, 200)
+
+        # test prune db with no tables
+        data = {"action": "prune_db"}
+        r = self.client.post(url, data)
+        self.assertEqual(r.status_code, 400)
+
+        # test prune db with tables
+        data = {
+            "action": "prune_db",
+            "prune_tables": ["audit_logs", "agent_outages", "pending_actions"],
+        }
+        r = self.client.post(url, data)
+        self.assertEqual(r.status_code, 200)
+
+        # test remove orphaned tasks
+        data = {"action": "rm_orphaned_tasks"}
+        r = self.client.post(url, data)
+        self.assertEqual(r.status_code, 200)
+        remove_orphaned_win_tasks.assert_called()
+
+        self.check_not_authenticated("post", url)

api/tacticalrmm/core/urls.py

@@ -8,4 +8,5 @@ urlpatterns = [
     path("version/", views.version),
     path("emailtest/", views.email_test),
     path("dashinfo/", views.dashboard_info),
+    path("servermaintenance/", views.server_maintenance),
 ]

api/tacticalrmm/core/views.py

@@ -68,7 +68,9 @@ def version(request):
 
 @api_view()
 def dashboard_info(request):
-    return Response({"trmm_version": settings.TRMM_VERSION})
+    return Response(
+        {"trmm_version": settings.TRMM_VERSION, "dark_mode": request.user.dark_mode}
+    )
 
 
 @api_view()
@@ -82,3 +84,56 @@ def email_test(request):
         return notify_error(r)
 
     return Response("Email Test OK!")
+
+
+@api_view(["POST"])
+def server_maintenance(request):
+    from tacticalrmm.utils import reload_nats
+
+    if "action" not in request.data:
+        return notify_error("The data is incorrect")
+
+    if request.data["action"] == "reload_nats":
+        reload_nats()
+        return Response("Nats configuration was reloaded successfully.")
+
+    if request.data["action"] == "rm_orphaned_tasks":
+        from agents.models import Agent
+        from autotasks.tasks import remove_orphaned_win_tasks
+
+        agents = Agent.objects.all()
+        online = [i for i in agents if i.status == "online"]
+        for agent in online:
+            remove_orphaned_win_tasks.delay(agent.pk)
+
+        return Response(
+            "The task has been initiated. Check the Debug Log in the UI for progress."
+        )
+
+    if request.data["action"] == "prune_db":
+        from agents.models import AgentOutage
+        from logs.models import AuditLog, PendingAction
+
+        if "prune_tables" not in request.data:
+            return notify_error("The data is incorrect.")
+
+        tables = request.data["prune_tables"]
+        records_count = 0
+        if "agent_outages" in tables:
+            agentoutages = AgentOutage.objects.exclude(recovery_time=None)
+            records_count += agentoutages.count()
+            agentoutages.delete()
+
+        if "audit_logs" in tables:
+            auditlogs = AuditLog.objects.filter(action="check_run")
+            records_count += auditlogs.count()
+            auditlogs.delete()
+
+        if "pending_actions" in tables:
+            pendingactions = PendingAction.objects.filter(status="completed")
+            records_count += pendingactions.count()
+            pendingactions.delete()
+
+        return Response(f"{records_count} records were pruned from the database")
+
+    return notify_error("The data is incorrect")

api/tacticalrmm/logs/migrations/0008_auto_20201110_1431.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.2 on 2020-11-10 14:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logs', '0007_auditlog_debug_info'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='auditlog',
+            name='action',
+            field=models.CharField(choices=[('login', 'User Login'), ('failed_login', 'Failed User Login'), ('delete', 'Delete Object'), ('modify', 'Modify Object'), ('add', 'Add Object'), ('view', 'View Object'), ('check_run', 'Check Run'), ('task_run', 'Task Run'), ('remote_session', 'Remote Session'), ('execute_script', 'Execute Script'), ('execute_command', 'Execute Command')], max_length=100),
+        ),
+    ]

api/tacticalrmm/logs/migrations/0009_auto_20201110_1431.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.2 on 2020-11-10 14:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logs', '0008_auto_20201110_1431'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='auditlog',
+            name='action',
+            field=models.CharField(choices=[('login', 'User Login'), ('failed_login', 'Failed User Login'), ('delete', 'Delete Object'), ('modify', 'Modify Object'), ('add', 'Add Object'), ('view', 'View Object'), ('check_run', 'Check Run'), ('task_run', 'Task Run'), ('agent_install', 'Agent Install'), ('remote_session', 'Remote Session'), ('execute_script', 'Execute Script'), ('execute_command', 'Execute Command')], max_length=100),
+        ),
+    ]

api/tacticalrmm/logs/migrations/0010_auto_20201110_2238.py

@@ -0,0 +1,23 @@
+# Generated by Django 3.1.2 on 2020-11-10 22:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logs', '0009_auto_20201110_1431'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='auditlog',
+            name='action',
+            field=models.CharField(choices=[('login', 'User Login'), ('failed_login', 'Failed User Login'), ('delete', 'Delete Object'), ('modify', 'Modify Object'), ('add', 'Add Object'), ('view', 'View Object'), ('check_run', 'Check Run'), ('task_run', 'Task Run'), ('agent_install', 'Agent Install'), ('remote_session', 'Remote Session'), ('execute_script', 'Execute Script'), ('execute_command', 'Execute Command'), ('bulk_action', 'Bulk Action')], max_length=100),
+        ),
+        migrations.AlterField(
+            model_name='auditlog',
+            name='object_type',
+            field=models.CharField(choices=[('user', 'User'), ('script', 'Script'), ('agent', 'Agent'), ('policy', 'Policy'), ('winupdatepolicy', 'Patch Policy'), ('client', 'Client'), ('site', 'Site'), ('check', 'Check'), ('automatedtask', 'Automated Task'), ('coresettings', 'Core Settings'), ('bulk', 'Bulk')], max_length=100),
+        ),
+    ]

api/tacticalrmm/logs/migrations/0011_auto_20201119_0854.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.3 on 2020-11-19 08:54
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logs', '0010_auto_20201110_2238'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='pendingaction',
+            name='action_type',
+            field=models.CharField(blank=True, choices=[('schedreboot', 'Scheduled Reboot'), ('taskaction', 'Scheduled Task Action'), ('agentupdate', 'Agent Update')], max_length=255, null=True),
+        ),
+    ]

api/tacticalrmm/logs/models.py

@@ -6,6 +6,7 @@ from tacticalrmm.middleware import get_username, get_debug_info
 ACTION_TYPE_CHOICES = [
     ("schedreboot", "Scheduled Reboot"),
     ("taskaction", "Scheduled Task Action"),
+    ("agentupdate", "Agent Update"),
 ]
 
 AUDIT_ACTION_TYPE_CHOICES = [
@@ -15,9 +16,13 @@ AUDIT_ACTION_TYPE_CHOICES = [
     ("modify", "Modify Object"),
     ("add", "Add Object"),
     ("view", "View Object"),
+    ("check_run", "Check Run"),
+    ("task_run", "Task Run"),
+    ("agent_install", "Agent Install"),
     ("remote_session", "Remote Session"),
     ("execute_script", "Execute Script"),
     ("execute_command", "Execute Command"),
+    ("bulk_action", "Bulk Action"),
 ]
 
 AUDIT_OBJECT_TYPE_CHOICES = [
@@ -31,6 +36,7 @@ AUDIT_OBJECT_TYPE_CHOICES = [
     ("check", "Check"),
     ("automatedtask", "Automated Task"),
     ("coresettings", "Core Settings"),
+    ("bulk", "Bulk"),
 ]
 
 # taskaction details format
@@ -170,6 +176,45 @@ class AuditLog(models.Model):
             debug_info=debug_info,
         )
 
+    @staticmethod
+    def audit_bulk_action(username, action, affected, debug_info={}):
+        from clients.models import Client, Site
+        from agents.models import Agent
+        from scripts.models import Script
+
+        target = ""
+        agents = None
+
+        if affected["target"] == "all":
+            target = "on all agents"
+        elif affected["target"] == "client":
+            client = Client.objects.get(pk=affected["client"])
+            target = f"on all agents within client: {client.name}"
+        elif affected["target"] == "site":
+            site = Site.objects.get(pk=affected["site"])
+            target = f"on all agents within site: {site.client.name}\\{site.name}"
+        elif affected["target"] == "agents":
+            agents = Agent.objects.filter(pk__in=affected["agentPKs"]).values_list(
+                "hostname", flat=True
+            )
+            target = "on multiple agents"
+
+        if action == "script":
+            script = Script.objects.get(pk=affected["scriptPK"])
+            action = f"script: {script.name}"
+
+        if agents:
+            affected["agent_hostnames"] = list(agents)
+
+        AuditLog.objects.create(
+            username=username,
+            object_type="bulk",
+            action="bulk_action",
+            message=f"{username} executed bulk {action} {target}",
+            debug_info=debug_info,
+            after_value=affected,
+        )
+
 
 class DebugLog(models.Model):
     pass
@@ -203,7 +248,7 @@ class PendingAction(models.Model):
             obj = dt.datetime.strptime(self.details["time"], "%Y-%m-%d %H:%M:%S")
             return dt.datetime.strftime(obj, "%B %d, %Y at %I:%M %p")
 
-        elif self.action_type == "taskaction":
+        elif self.action_type == "taskaction" or self.action_type == "agentupdate":
             return "Next agent check-in"
 
     @property
@@ -211,6 +256,9 @@ class PendingAction(models.Model):
         if self.action_type == "schedreboot":
             return "Device pending reboot"
 
+        elif self.action_type == "agentupdate":
+            return f"Agent update to {self.details['version']}"
+
         elif self.action_type == "taskaction":
             if self.details["action"] == "taskdelete":
                 return "Device pending task deletion"
@@ -246,28 +294,31 @@ class BaseAuditModel(models.Model):
 
             before_value = {}
             object_class = type(self)
+            object_name = object_class.__name__.lower()
+            username = get_username()
 
             # populate created_by and modified_by fields on instance
             if not getattr(self, "created_by", None):
-                self.created_by = get_username()
+                self.created_by = username
             if hasattr(self, "modified_by"):
-                self.modified_by = get_username()
+                self.modified_by = username
 
             # capture object properties before edit
             if self.pk:
                 before_value = object_class.objects.get(pk=self.id)
 
+            # dont create entry for agent add since that is done in view
             if not self.pk:
                 AuditLog.audit_object_add(
-                    get_username(),
-                    object_class.__name__.lower(),
+                    username,
+                    object_name,
                     object_class.serialize(self),
                     self.__str__(),
                     debug_info=get_debug_info(),
                 )
             else:
                 AuditLog.audit_object_changed(
-                    get_username(),
+                    username,
                     object_class.__name__.lower(),
                     object_class.serialize(before_value),
                     object_class.serialize(self),
@@ -280,6 +331,7 @@ class BaseAuditModel(models.Model):
     def delete(self, *args, **kwargs):
 
         if get_username():
+
             object_class = type(self)
             AuditLog.audit_object_delete(
                 get_username(),

api/tacticalrmm/logs/serializers.py

@@ -22,8 +22,8 @@ class PendingActionSerializer(serializers.ModelSerializer):
 
     hostname = serializers.ReadOnlyField(source="agent.hostname")
     salt_id = serializers.ReadOnlyField(source="agent.salt_id")
-    client = serializers.ReadOnlyField(source="agent.client")
-    site = serializers.ReadOnlyField(source="agent.site")
+    client = serializers.ReadOnlyField(source="agent.client.name")
+    site = serializers.ReadOnlyField(source="agent.site.name")
     due = serializers.ReadOnlyField()
     description = serializers.ReadOnlyField()
 

api/tacticalrmm/logs/tasks.py

@@ -1,29 +0,0 @@
-from loguru import logger
-from tacticalrmm.celery import app
-from django.conf import settings
-
-logger.configure(**settings.LOG_CONFIG)
-
-
-@app.task
-def cancel_pending_action_task(data):
-
-    if data["action_type"] == "schedreboot" and data["status"] == "pending":
-
-        from agents.models import Agent
-
-        agent = Agent.objects.get(pk=data["agent"])
-
-        task_name = data["details"]["taskname"]
-        r = agent.salt_api_cmd(
-            timeout=30, func="task.delete_task", arg=[f"name={task_name}"]
-        )
-        if r == "timeout" or r == "error" or (isinstance(r, bool) and not r):
-            logger.error(
-                f"Unable to contact {agent.hostname}. Task {task_name} will need to cancelled manually."
-            )
-            return
-        else:
-            logger.info(f"Scheduled reboot cancelled on {agent.hostname}")
-
-    return "ok"

api/tacticalrmm/logs/tests.py

@@ -11,6 +11,10 @@ class TestAuditViews(TacticalTestCase):
         self.setup_coresettings()
 
     def create_audit_records(self):
+
+        # create clients for client filter
+        site = baker.make("clients.Site")
+        baker.make_recipe("agents.agent", site=site, hostname="AgentHostname1")
         # user jim agent logs
         baker.make_recipe(
             "logs.agent_logs",
@@ -75,11 +79,13 @@ class TestAuditViews(TacticalTestCase):
             _quantity=13,
         )
 
+        return site
+
     def test_get_audit_logs(self):
         url = "/logs/auditlogs/"
 
         # create data
-        self.create_audit_records()
+        site = self.create_audit_records()
 
         # test data and result counts
         data = [
@@ -111,12 +117,30 @@ class TestAuditViews(TacticalTestCase):
                 "count": 40,
             },
             {"filter": {"timeFilter": 35, "userFilter": ["james", "jim"]}, "count": 81},
+            {"filter": {"objectFilter": ["user"]}, "count": 26},
+            {"filter": {"actionFilter": ["login"]}, "count": 12},
+            {"filter": {"clientFilter": [site.client.id]}, "count": 23},
         ]
 
+        pagination = {
+            "rowsPerPage": 25,
+            "page": 1,
+            "sortBy": "entry_time",
+            "descending": True,
+        }
+
         for req in data:
-            resp = self.client.patch(url, req["filter"], format="json")
+            resp = self.client.patch(
+                url, {**req["filter"], "pagination": pagination}, format="json"
+            )
             self.assertEqual(resp.status_code, 200)
-            self.assertEqual(len(resp.data), req["count"])
+            self.assertEqual(
+                len(resp.data["audit_logs"]),
+                pagination["rowsPerPage"]
+                if req["count"] > pagination["rowsPerPage"]
+                else req["count"],
+            )
+            self.assertEqual(resp.data["total"], req["count"])
 
         self.check_not_authenticated("patch", url)
 
@@ -181,54 +205,31 @@ class TestAuditViews(TacticalTestCase):
 
         self.check_not_authenticated("get", url)
 
-    @patch("logs.tasks.cancel_pending_action_task.delay")
-    def test_cancel_pending_action(self, mock_task):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_cancel_pending_action(self, nats_cmd):
         url = "/logs/cancelpendingaction/"
-        pending_action = baker.make("logs.PendingAction")
+        # TODO fix this TypeError: Object of type coroutine is not JSON serializable
+        """ agent = baker.make("agents.Agent", version="1.1.1")
+        pending_action = baker.make(
+            "logs.PendingAction",
+            agent=agent,
+            details={
+                "time": "2021-01-13 18:20:00",
+                "taskname": "TacticalRMM_SchedReboot_wYzCCDVXlc",
+            },
+        )
 
-        serializer = PendingActionSerializer(pending_action).data
         data = {"pk": pending_action.id}
         resp = self.client.delete(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
-        mock_task.assert_called_with(serializer)
+        nats_data = {
+            "func": "delschedtask",
+            "schedtaskpayload": {"name": "TacticalRMM_SchedReboot_wYzCCDVXlc"},
+        }
+        nats_cmd.assert_called_with(nats_data, timeout=10)
 
         # try request again and it should fail since pending action doesn't exist
         resp = self.client.delete(url, data, format="json")
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(resp.status_code, 404) """
 
         self.check_not_authenticated("delete", url)
-
-
-class TestLogsTasks(TacticalTestCase):
-    def setUp(self):
-        self.authenticate()
-
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_cancel_pending_action_task(self, mock_salt_cmd):
-        from .tasks import cancel_pending_action_task
-
-        pending_action = baker.make(
-            "logs.PendingAction",
-            action_type="schedreboot",
-            status="pending",
-            details={"taskname": "test_name"},
-        )
-
-        # data that is passed to the task
-        data = PendingActionSerializer(pending_action).data
-
-        # set return value on mock to success
-        mock_salt_cmd.return_value = "success"
-        # call task with valid data and see if salt is called with correct data
-        ret = cancel_pending_action_task(data)
-        mock_salt_cmd.assert_called_with(
-            timeout=30, func="task.delete_task", arg=["name=test_name"]
-        )
-        # this should return successful
-        self.assertEquals(ret, "ok")
-
-        # this run should return false
-        mock_salt_cmd.reset_mock()
-        mock_salt_cmd.return_value = "timeout"
-        ret = cancel_pending_action_task(data)
-        self.assertEquals(ret, None)

api/tacticalrmm/logs/views.py

@@ -1,9 +1,12 @@
+import asyncio
 import subprocess
 
 from django.conf import settings
 from django.shortcuts import get_object_or_404
 from django.http import HttpResponse
 from django.utils import timezone as djangotime
+from django.db.models import Q
+from django.core.paginator import Paginator
 from datetime import datetime as dt
 
 from rest_framework.response import Response
@@ -17,38 +20,75 @@ from accounts.models import User
 from .serializers import PendingActionSerializer, AuditLogSerializer
 from agents.serializers import AgentHostnameSerializer
 from accounts.serializers import UserSerializer
-from .tasks import cancel_pending_action_task
+from tacticalrmm.utils import notify_error
 
 
 class GetAuditLogs(APIView):
     def patch(self, request):
+        from clients.models import Client
+        from agents.models import Agent
 
-        auditLogs = None
-        if "agentFilter" in request.data and "userFilter" in request.data:
-            audit_logs = AuditLog.objects.filter(
-                agent__in=request.data["agentFilter"],
-                username__in=request.data["userFilter"],
+        pagination = request.data["pagination"]
+
+        order_by = (
+            f"-{pagination['sortBy']}"
+            if pagination["descending"]
+            else f"{pagination['sortBy']}"
+        )
+
+        agentFilter = Q()
+        clientFilter = Q()
+        actionFilter = Q()
+        objectFilter = Q()
+        userFilter = Q()
+        timeFilter = Q()
+
+        if "agentFilter" in request.data:
+            agentFilter = Q(agent__in=request.data["agentFilter"])
+
+        elif "clientFilter" in request.data:
+            clients = Client.objects.filter(
+                pk__in=request.data["clientFilter"]
+            ).values_list("id")
+            agents = Agent.objects.filter(site__client_id__in=clients).values_list(
+                "hostname"
             )
+            clientFilter = Q(agent__in=agents)
 
-        elif "userFilter" in request.data:
-            audit_logs = AuditLog.objects.filter(
-                username__in=request.data["userFilter"]
-            )
+        if "userFilter" in request.data:
+            userFilter = Q(username__in=request.data["userFilter"])
 
-        elif "agentFilter" in request.data:
-            audit_logs = AuditLog.objects.filter(agent__in=request.data["agentFilter"])
+        if "actionFilter" in request.data:
+            actionFilter = Q(action__in=request.data["actionFilter"])
 
-        else:
-            audit_logs = AuditLog.objects.all()
+        if "objectFilter" in request.data:
+            objectFilter = Q(object_type__in=request.data["objectFilter"])
 
-        if audit_logs and "timeFilter" in request.data:
-            audit_logs = audit_logs.filter(
+        if "timeFilter" in request.data:
+            timeFilter = Q(
                 entry_time__lte=djangotime.make_aware(dt.today()),
                 entry_time__gt=djangotime.make_aware(dt.today())
                 - djangotime.timedelta(days=request.data["timeFilter"]),
             )
 
-        return Response(AuditLogSerializer(audit_logs, many=True).data)
+        audit_logs = (
+            AuditLog.objects.filter(agentFilter | clientFilter)
+            .filter(userFilter)
+            .filter(actionFilter)
+            .filter(objectFilter)
+            .filter(timeFilter)
+        ).order_by(order_by)
+
+        paginator = Paginator(audit_logs, pagination["rowsPerPage"])
+
+        return Response(
+            {
+                "audit_logs": AuditLogSerializer(
+                    paginator.get_page(pagination["page"]), many=True
+                ).data,
+                "total": paginator.count,
+            }
+        )
 
 
 class FilterOptionsAuditLog(APIView):
@@ -58,9 +98,8 @@ class FilterOptionsAuditLog(APIView):
             return Response(AgentHostnameSerializer(agents, many=True).data)
 
         if request.data["type"] == "user":
-            agents = Agent.objects.values_list("agent_id", flat=True)
-            users = User.objects.exclude(username__in=agents).filter(
-                username__icontains=request.data["pattern"]
+            users = User.objects.filter(
+                username__icontains=request.data["pattern"], agent=None
             )
             return Response(UserSerializer(users, many=True).data)
 
@@ -75,19 +114,26 @@ def agent_pending_actions(request, pk):
 
 @api_view()
 def all_pending_actions(request):
-    actions = PendingAction.objects.all()
+    actions = PendingAction.objects.all().select_related("agent")
     return Response(PendingActionSerializer(actions, many=True).data)
 
 
 @api_view(["DELETE"])
 def cancel_pending_action(request):
     action = get_object_or_404(PendingAction, pk=request.data["pk"])
-    data = PendingActionSerializer(action).data
-    cancel_pending_action_task.delay(data)
+    if not action.agent.has_gotasks:
+        return notify_error("Requires agent version 1.1.1 or greater")
+
+    nats_data = {
+        "func": "delschedtask",
+        "schedtaskpayload": {"name": action.details["taskname"]},
+    }
+    r = asyncio.run(action.agent.nats_cmd(nats_data, timeout=10))
+    if r != "ok":
+        return notify_error(r)
+
     action.delete()
-    return Response(
-        f"{action.agent.hostname}: {action.description} will be cancelled shortly"
-    )
+    return Response(f"{action.agent.hostname}: {action.description} was cancelled")
 
 
 @api_view()

api/tacticalrmm/requirements.txt

@@ -1,16 +1,17 @@
 amqp==2.6.1
-asgiref==3.2.10
+asgiref==3.3.1
+asyncio-nats-client==0.11.4
 billiard==3.6.3.0
 celery==4.4.6
-certifi==2020.6.20
+certifi==2020.12.5
 cffi==1.14.3
 chardet==3.0.4
-cryptography==3.2
+cryptography==3.2.1
 decorator==4.4.2
-Django==3.1.2
+Django==3.1.4
 django-cors-headers==3.5.0
 django-rest-knox==4.1.0
-djangorestframework==3.12.1
+djangorestframework==3.12.2
 future==0.18.2
 idna==2.10
 kombu==4.6.11
@@ -19,19 +20,19 @@ msgpack==1.0.0
 packaging==20.4
 psycopg2-binary==2.8.6
 pycparser==2.20
-pycryptodome==3.9.8
+pycryptodome==3.9.9
 pyotp==2.4.1
 pyparsing==2.4.7
-pytz==2020.1
+pytz==2020.4
 qrcode==6.1
 redis==3.5.3
-requests==2.24.0
+requests==2.25.0
 six==1.15.0
 sqlparse==0.4.1
-twilio==6.46.0
-urllib3==1.25.10
+twilio==6.49.0
+urllib3==1.26.2
 uWSGI==2.0.19.1
 validators==0.18.1
 vine==1.3.0
 websockets==8.1
-zipp==3.3.1
+zipp==3.4.0

api/tacticalrmm/scripts/models.py

@@ -1,5 +1,6 @@
 from django.db import models
 from logs.models import BaseAuditModel
+from django.conf import settings
 
 SCRIPT_SHELLS = [
     ("powershell", "Powershell"),
@@ -38,9 +39,9 @@ class Script(BaseAuditModel):
     @property
     def file(self):
         if self.script_type == "userdefined":
-            return f"/srv/salt/scripts/userdefined/{self.filename}"
+            return f"{settings.SCRIPTS_DIR}/userdefined/{self.filename}"
         else:
-            return f"/srv/salt/scripts/{self.filename}"
+            return f"{settings.SCRIPTS_DIR}/{self.filename}"
 
     @property
     def code(self):
@@ -62,7 +63,13 @@ class Script(BaseAuditModel):
         # load community uploaded scripts into the database
         # skip ones that already exist, only updating name / desc in case it changes
         # files will be copied by the update script or in docker to /srv/salt/scripts
-        scripts_dir = os.path.join(Path(settings.BASE_DIR).parents[1], "scripts")
+
+        # for install script
+        if not settings.DOCKER_BUILD:
+            scripts_dir = os.path.join(Path(settings.BASE_DIR).parents[1], "scripts")
+        # for docker
+        else:
+            scripts_dir = settings.SCRIPTS_DIR
 
         with open(
             os.path.join(settings.BASE_DIR, "scripts/community_scripts.json")

api/tacticalrmm/scripts/serializers.py

@@ -1,5 +1,6 @@
 import os
 
+from django.conf import settings
 from rest_framework.serializers import ModelSerializer, ValidationError, ReadOnlyField
 from .models import Script
 
@@ -27,7 +28,7 @@ class ScriptSerializer(ModelSerializer):
             # but only if adding, not if editing since will overwrite if edit
             if not self.instance:
                 script_path = os.path.join(
-                    "/srv/salt/scripts/userdefined", val["filename"]
+                    f"{settings.SCRIPTS_DIR}/userdefined", val["filename"]
                 )
                 if os.path.exists(script_path):
                     raise ValidationError(

api/tacticalrmm/scripts/tasks.py

@@ -1,38 +1,73 @@
+import asyncio
+
 from tacticalrmm.celery import app
 from agents.models import Agent
-from .models import Script
+from scripts.models import Script
 
 
 @app.task
-def run_script_bg_task(data):
-    agent = Agent.objects.get(pk=data["agentpk"])
-    script = Script.objects.get(pk=data["scriptpk"])
+def handle_bulk_command_task(agentpks, cmd, shell, timeout):
+    agents = Agent.objects.filter(pk__in=agentpks)
 
-    agent.salt_api_async(
-        func="win_agent.run_script",
-        kwargs={
-            "filepath": script.filepath,
-            "filename": script.filename,
-            "shell": script.shell,
-            "timeout": data["timeout"],
-            "args": data["args"],
-        },
-    )
+    agents_nats = [agent for agent in agents if agent.has_nats]
+    agents_salt = [agent for agent in agents if not agent.has_nats]
+    minions = [agent.salt_id for agent in agents_salt]
+
+    if minions:
+        Agent.salt_batch_async(
+            minions=minions,
+            func="cmd.run_bg",
+            kwargs={
+                "cmd": cmd,
+                "shell": shell,
+                "timeout": timeout,
+            },
+        )
+
+    if agents_nats:
+        nats_data = {
+            "func": "rawcmd",
+            "timeout": timeout,
+            "payload": {
+                "command": cmd,
+                "shell": shell,
+            },
+        }
+        for agent in agents_nats:
+            asyncio.run(agent.nats_cmd(nats_data, wait=False))
 
 
 @app.task
-def run_bulk_script_task(data):
-    # for powershell and batch scripts only, workaround for salt bg script bug
-    script = Script.objects.get(pk=data["scriptpk"])
+def handle_bulk_script_task(scriptpk, agentpks, args, timeout):
+    script = Script.objects.get(pk=scriptpk)
+    agents = Agent.objects.filter(pk__in=agentpks)
 
-    Agent.salt_batch_async(
-        minions=data["minions"],
-        func="win_agent.run_script",
-        kwargs={
-            "filepath": script.filepath,
-            "filename": script.filename,
+    agents_nats = [agent for agent in agents if agent.has_nats]
+    agents_salt = [agent for agent in agents if not agent.has_nats]
+    minions = [agent.salt_id for agent in agents_salt]
+
+    if minions:
+        Agent.salt_batch_async(
+            minions=minions,
+            func="win_agent.run_script",
+            kwargs={
+                "filepath": script.filepath,
+                "filename": script.filename,
+                "shell": script.shell,
+                "timeout": timeout,
+                "args": args,
+                "bg": True if script.shell == "python" else False,  # salt bg script bug
+            },
+        )
+
+    nats_data = {
+        "func": "runscript",
+        "timeout": timeout,
+        "script_args": args,
+        "payload": {
+            "code": script.code,
             "shell": script.shell,
-            "timeout": data["timeout"],
-            "args": data["args"],
         },
-    )
+    }
+    for agent in agents_nats:
+        asyncio.run(agent.nats_cmd(nats_data, wait=False))

api/tacticalrmm/scripts/tests.py

@@ -94,7 +94,11 @@ class TestScriptViews(TacticalTestCase):
 
     def test_load_community_scripts(self):
         valid_shells = ["powershell", "python", "cmd"]
-        scripts_dir = os.path.join(Path(settings.BASE_DIR).parents[1], "scripts")
+
+        if not settings.DOCKER_BUILD:
+            scripts_dir = os.path.join(Path(settings.BASE_DIR).parents[1], "scripts")
+        else:
+            scripts_dir = settings.SCRIPTS_DIR
 
         with open(
             os.path.join(settings.BASE_DIR, "scripts/community_scripts.json")

api/tacticalrmm/services/tests.py

@@ -9,21 +9,6 @@ class TestServiceViews(TacticalTestCase):
     def setUp(self):
         self.authenticate()
 
-    def test_get_services(self):
-
-        # test a call where agent doesn't exist
-        resp = self.client.get("/services/500/services/", format="json")
-        self.assertEqual(resp.status_code, 404)
-
-        agent = baker.make_recipe("agents.agent_with_services")
-        url = f"/services/{agent.pk}/services/"
-        serializer = ServicesSerializer(agent)
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(serializer.data, resp.data)
-
-        self.check_not_authenticated("get", url)
-
     def test_default_services(self):
         url = "/services/defaultservices/"
         resp = self.client.get(url, format="json")
@@ -32,16 +17,16 @@ class TestServiceViews(TacticalTestCase):
 
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_get_refreshed_services(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_get_services(self, nats_cmd):
         # test a call where agent doesn't exist
-        resp = self.client.get("/services/500/refreshedservices/", format="json")
+        resp = self.client.get("/services/500/services/", format="json")
         self.assertEqual(resp.status_code, 404)
 
         agent = baker.make_recipe("agents.agent_with_services")
-        url = f"/services/{agent.pk}/refreshedservices/"
+        url = f"/services/{agent.pk}/services/"
 
-        salt_return = [
+        nats_return = [
             {
                 "pid": 880,
                 "name": "AeLookupSvc",
@@ -65,30 +50,23 @@ class TestServiceViews(TacticalTestCase):
         ]
 
         # test failed attempt
-        salt_api_cmd.return_value = "timeout"
+        nats_cmd.return_value = "timeout"
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(timeout=15, func="win_agent.get_services")
-        salt_api_cmd.reset_mock()
-
-        # test failed attempt
-        salt_api_cmd.return_value = "error"
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(timeout=15, func="win_agent.get_services")
-        salt_api_cmd.reset_mock()
+        nats_cmd.assert_called_with(data={"func": "winservices"}, timeout=10)
+        nats_cmd.reset_mock()
 
         # test successful attempt
-        salt_api_cmd.return_value = salt_return
+        nats_cmd.return_value = nats_return
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(timeout=15, func="win_agent.get_services")
-        self.assertEquals(Agent.objects.get(pk=agent.pk).services, salt_return)
+        nats_cmd.assert_called_with(data={"func": "winservices"}, timeout=10)
+        self.assertEquals(Agent.objects.get(pk=agent.pk).services, nats_return)
 
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_service_action(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_service_action(self, nats_cmd):
         url = "/services/serviceaction/"
 
         invalid_data = {"pk": 500, "sv_name": "AeLookupSvc", "sv_action": "restart"}
@@ -101,47 +79,37 @@ class TestServiceViews(TacticalTestCase):
         data = {"pk": agent.pk, "sv_name": "AeLookupSvc", "sv_action": "restart"}
 
         # test failed attempt
-        salt_api_cmd.return_value = "timeout"
+        nats_cmd.return_value = "timeout"
         resp = self.client.post(url, data, format="json")
         self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=45,
-            func=f"service.restart",
-            arg="AeLookupSvc",
+        nats_cmd.assert_called_with(
+            {
+                "func": "winsvcaction",
+                "payload": {
+                    "name": "AeLookupSvc",
+                    "action": "stop",
+                },
+            },
+            timeout=32,
         )
-        salt_api_cmd.reset_mock()
-
-        salt_api_cmd.return_value = "error"
-        resp = self.client.post(url, data, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=45,
-            func=f"service.restart",
-            arg="AeLookupSvc",
-        )
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
 
         # test successful attempt
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = {"success": True, "errormsg": ""}
         resp = self.client.post(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=45,
-            func=f"service.restart",
-            arg="AeLookupSvc",
-        )
 
         self.check_not_authenticated("post", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_service_detail(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_service_detail(self, nats_cmd):
         # test a call where agent doesn't exist
         resp = self.client.get(
             "/services/500/doesntexist/servicedetail/", format="json"
         )
         self.assertEqual(resp.status_code, 404)
 
-        salt_return = {
+        nats_return = {
             "pid": 812,
             "name": "ALG",
             "status": "stopped",
@@ -156,29 +124,27 @@ class TestServiceViews(TacticalTestCase):
         url = f"/services/{agent.pk}/alg/servicedetail/"
 
         # test failed attempt
-        salt_api_cmd.return_value = "timeout"
+        nats_cmd.return_value = "timeout"
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(timeout=20, func="service.info", arg="alg")
-        salt_api_cmd.reset_mock()
-
-        salt_api_cmd.return_value = "error"
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(timeout=20, func="service.info", arg="alg")
-        salt_api_cmd.reset_mock()
+        nats_cmd.assert_called_with(
+            {"func": "winsvcdetail", "payload": {"name": "alg"}}, timeout=10
+        )
+        nats_cmd.reset_mock()
 
         # test successful attempt
-        salt_api_cmd.return_value = salt_return
+        nats_cmd.return_value = nats_return
         resp = self.client.get(url, format="json")
         self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(timeout=20, func="service.info", arg="alg")
-        self.assertEquals(resp.data, salt_return)
+        nats_cmd.assert_called_with(
+            {"func": "winsvcdetail", "payload": {"name": "alg"}}, timeout=10
+        )
+        self.assertEquals(resp.data, nats_return)
 
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_edit_service(self, salt_api_cmd):
+    @patch("agents.models.Agent.nats_cmd")
+    def test_edit_service(self, nats_cmd):
         url = "/services/editservice/"
         agent = baker.make_recipe("agents.agent_with_services")
 
@@ -189,64 +155,43 @@ class TestServiceViews(TacticalTestCase):
 
         data = {"pk": agent.pk, "sv_name": "AeLookupSvc", "edit_action": "autodelay"}
 
-        # test failed attempt
-        salt_api_cmd.return_value = "timeout"
+        # test timeout
+        nats_cmd.return_value = "timeout"
         resp = self.client.post(url, data, format="json")
         self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="service.modify",
-            arg=data["sv_name"],
-            kwargs={"start_type": "auto", "start_delayed": True},
-        )
-        salt_api_cmd.reset_mock()
-
-        salt_api_cmd.return_value = "error"
-        resp = self.client.post(url, data, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="service.modify",
-            arg=data["sv_name"],
-            kwargs={"start_type": "auto", "start_delayed": True},
-        )
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
 
         # test successful attempt autodelay
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = {"success": True, "errormsg": ""}
         resp = self.client.post(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="service.modify",
-            arg=data["sv_name"],
-            kwargs={"start_type": "auto", "start_delayed": True},
+        nats_cmd.assert_called_with(
+            {
+                "func": "editwinsvc",
+                "payload": {
+                    "name": "AeLookupSvc",
+                    "startType": "autodelay",
+                },
+            },
+            timeout=10,
         )
-        salt_api_cmd.reset_mock()
+        nats_cmd.reset_mock()
 
-        # test successful attempt with auto
+        # test error message from agent
         data = {"pk": agent.pk, "sv_name": "AeLookupSvc", "edit_action": "auto"}
-        salt_api_cmd.return_value = True
+        nats_cmd.return_value = {
+            "success": False,
+            "errormsg": "The parameter is incorrect",
+        }
         resp = self.client.post(url, data, format="json")
-        self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="service.modify",
-            arg=data["sv_name"],
-            kwargs={"start_type": "auto", "start_delayed": False},
-        )
-        salt_api_cmd.reset_mock()
+        self.assertEqual(resp.status_code, 400)
+        nats_cmd.reset_mock()
 
-        # test successful attempt with manual
-        data = {"pk": agent.pk, "sv_name": "AeLookupSvc", "edit_action": "manual"}
-        salt_api_cmd.return_value = True
+        # test catch all
+        data = {"pk": agent.pk, "sv_name": "AeLookupSvc", "edit_action": "auto"}
+        nats_cmd.return_value = {"success": False, "errormsg": ""}
         resp = self.client.post(url, data, format="json")
-        self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="service.modify",
-            arg=data["sv_name"],
-            kwargs={"start_type": "manual"},
-        )
+        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(resp.data, "Something went wrong")
 
         self.check_not_authenticated("post", url)

api/tacticalrmm/services/urls.py

@@ -4,7 +4,6 @@ from . import views
 urlpatterns = [
     path("<int:pk>/services/", views.get_services),
     path("defaultservices/", views.default_services),
-    path("<int:pk>/refreshedservices/", views.get_refreshed_services),
     path("serviceaction/", views.service_action),
     path("<int:pk>/<svcname>/servicedetail/", views.service_detail),
     path("editservice/", views.edit_service),

api/tacticalrmm/services/views.py

@@ -1,3 +1,4 @@
+import asyncio
 from loguru import logger
 
 from rest_framework.response import Response
@@ -19,6 +20,15 @@ logger.configure(**settings.LOG_CONFIG)
 @api_view()
 def get_services(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    r = asyncio.run(agent.nats_cmd(data={"func": "winservices"}, timeout=10))
+
+    if r == "timeout":
+        return notify_error("Unable to contact the agent")
+
+    agent.services = r
+    agent.save(update_fields=["services"])
     return Response(ServicesSerializer(agent).data)
 
 
@@ -27,81 +37,81 @@ def default_services(request):
     return Response(Check.load_default_services())
 
 
-@api_view()
-def get_refreshed_services(request, pk):
-    agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(timeout=15, func="win_agent.get_services")
-
-    if r == "timeout":
-        return notify_error("Unable to contact the agent")
-    elif r == "error" or not r:
-        return notify_error("Something went wrong")
-
-    agent.services = r
-    agent.save(update_fields=["services"])
-    return Response(ServicesSerializer(agent).data)
-
-
 @api_view(["POST"])
 def service_action(request):
-    data = request.data
-    pk = data["pk"]
-    service_name = data["sv_name"]
-    service_action = data["sv_action"]
-    agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(
-        timeout=45,
-        func=f"service.{service_action}",
-        arg=service_name,
-    )
+    agent = get_object_or_404(Agent, pk=request.data["pk"])
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    action = request.data["sv_action"]
+    data = {
+        "func": "winsvcaction",
+        "payload": {
+            "name": request.data["sv_name"],
+        },
+    }
+    # response struct from agent: {success: bool, errormsg: string}
+    if action == "restart":
+        data["payload"]["action"] = "stop"
+        r = asyncio.run(agent.nats_cmd(data, timeout=32))
+        if r == "timeout":
+            return notify_error("Unable to contact the agent")
+        elif not r["success"] and r["errormsg"]:
+            return notify_error(r["errormsg"])
+        elif r["success"]:
+            data["payload"]["action"] = "start"
+            r = asyncio.run(agent.nats_cmd(data, timeout=32))
+            if r == "timeout":
+                return notify_error("Unable to contact the agent")
+            elif not r["success"] and r["errormsg"]:
+                return notify_error(r["errormsg"])
+            elif r["success"]:
+                return Response("ok")
+    else:
+        data["payload"]["action"] = action
+        r = asyncio.run(agent.nats_cmd(data, timeout=32))
+        if r == "timeout":
+            return notify_error("Unable to contact the agent")
+        elif not r["success"] and r["errormsg"]:
+            return notify_error(r["errormsg"])
+        elif r["success"]:
+            return Response("ok")
 
-    if r == "timeout":
-        return notify_error("Unable to contact the agent")
-    elif r == "error" or not r:
-        return notify_error("Something went wrong")
-
-    return Response("ok")
+    return notify_error("Something went wrong")
 
 
 @api_view()
 def service_detail(request, pk, svcname):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(timeout=20, func="service.info", arg=svcname)
-
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    data = {"func": "winsvcdetail", "payload": {"name": svcname}}
+    r = asyncio.run(agent.nats_cmd(data, timeout=10))
     if r == "timeout":
         return notify_error("Unable to contact the agent")
-    elif r == "error" or not r:
-        return notify_error("Something went wrong")
 
     return Response(r)
 
 
 @api_view(["POST"])
 def edit_service(request):
-    data = request.data
-    pk = data["pk"]
-    service_name = data["sv_name"]
-    edit_action = data["edit_action"]
-
-    agent = get_object_or_404(Agent, pk=pk)
-
-    if edit_action == "autodelay":
-        kwargs = {"start_type": "auto", "start_delayed": True}
-    elif edit_action == "auto":
-        kwargs = {"start_type": "auto", "start_delayed": False}
-    else:
-        kwargs = {"start_type": edit_action}
-
-    r = agent.salt_api_cmd(
-        timeout=20,
-        func="service.modify",
-        arg=service_name,
-        kwargs=kwargs,
-    )
+    agent = get_object_or_404(Agent, pk=request.data["pk"])
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
+    data = {
+        "func": "editwinsvc",
+        "payload": {
+            "name": request.data["sv_name"],
+            "startType": request.data["edit_action"],
+        },
+    }
 
+    r = asyncio.run(agent.nats_cmd(data, timeout=10))
+    # response struct from agent: {success: bool, errormsg: string}
     if r == "timeout":
         return notify_error("Unable to contact the agent")
-    elif r == "error" or not r:
-        return notify_error("Something went wrong")
+    elif not r["success"] and r["errormsg"]:
+        return notify_error(r["errormsg"])
+    elif r["success"]:
+        return Response("ok")
 
-    return Response("ok")
+    return notify_error("Something went wrong")

api/tacticalrmm/software/tasks.py

@@ -1,4 +1,4 @@
-import string
+import asyncio
 from time import sleep
 from loguru import logger
 from tacticalrmm.celery import app
@@ -7,6 +7,7 @@ from django.utils import timezone as djangotime
 
 from agents.models import Agent
 from .models import ChocoSoftware, ChocoLog, InstalledSoftware
+from tacticalrmm.utils import filter_software
 
 logger.configure(**settings.LOG_CONFIG)
 
@@ -86,43 +87,6 @@ def update_chocos():
     return "ok"
 
 
-@app.task
-def get_installed_software(pk):
-    agent = Agent.objects.get(pk=pk)
-    r = agent.salt_api_cmd(
-        timeout=30,
-        func="pkg.list_pkgs",
-        kwargs={"include_components": False, "include_updates": False},
-    )
-
-    if r == "timeout" or r == "error":
-        logger.error(f"Timed out trying to get installed software on {agent.salt_id}")
-        return
-
-    printable = set(string.printable)
-
-    try:
-        software = [
-            {
-                "name": "".join(filter(lambda x: x in printable, k)),
-                "version": "".join(filter(lambda x: x in printable, v)),
-            }
-            for k, v in r.items()
-        ]
-    except Exception as e:
-        logger.error(f"Unable to get installed software on {agent.salt_id}: {e}")
-        return
-
-    if not InstalledSoftware.objects.filter(agent=agent).exists():
-        InstalledSoftware(agent=agent, software=software).save()
-    else:
-        s = agent.installedsoftware_set.get()
-        s.software = software
-        s.save(update_fields=["software"])
-
-    return "ok"
-
-
 @app.task
 def install_program(pk, name, version):
     agent = Agent.objects.get(pk=pk)
@@ -167,6 +131,4 @@ def install_program(pk, name, version):
         agent=agent, name=name, version=version, message=output, installed=installed
     ).save()
 
-    get_installed_software.delay(agent.pk)
-
     return "ok"

api/tacticalrmm/software/tests.py

@@ -62,72 +62,6 @@ class TestSoftwareViews(TacticalTestCase):
 
         self.check_not_authenticated("get", url)
 
-    @patch("agents.models.Agent.salt_api_cmd")
-    def test_chocos_refresh(self, salt_api_cmd):
-
-        salt_return = {"git": "2.3.4", "docker": "1.0.2"}
-
-        # test a call where agent doesn't exist
-        resp = self.client.get("/software/refresh/500/", format="json")
-        self.assertEqual(resp.status_code, 404)
-
-        agent = baker.make_recipe("agents.agent")
-        url = f"/software/refresh/{agent.pk}/"
-
-        # test failed attempt
-        salt_api_cmd.return_value = "timeout"
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        salt_api_cmd.reset_mock()
-
-        salt_api_cmd.return_value = "error"
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 400)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        salt_api_cmd.reset_mock()
-
-        # test success and created new software object
-        salt_api_cmd.return_value = salt_return
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        self.assertTrue(InstalledSoftware.objects.filter(agent=agent).exists())
-        salt_api_cmd.reset_mock()
-
-        # test success and updates software object
-        salt_api_cmd.return_value = salt_return
-        resp = self.client.get(url, format="json")
-        self.assertEqual(resp.status_code, 200)
-        salt_api_cmd.assert_called_with(
-            timeout=20,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        software = agent.installedsoftware_set.get()
-
-        expected = [
-            {"name": "git", "version": "2.3.4"},
-            {"name": "docker", "version": "1.0.2"},
-        ]
-
-        self.assertTrue(InstalledSoftware.objects.filter(agent=agent).exists())
-        self.assertEquals(software.software, expected)
-
-        self.check_not_authenticated("get", url)
-
 
 class TestSoftwareTasks(TacticalTestCase):
     @patch("agents.models.Agent.salt_api_cmd")
@@ -187,46 +121,7 @@ class TestSoftwareTasks(TacticalTestCase):
         self.assertEquals(salt_api_cmd.call_count, 2)
 
     @patch("agents.models.Agent.salt_api_cmd")
-    def test_get_installed_software(self, salt_api_cmd):
-        from .tasks import get_installed_software
-
-        agent = baker.make_recipe("agents.agent")
-
-        salt_return = {"git": "2.3.4", "docker": "1.0.2"}
-
-        # test failed attempt
-        salt_api_cmd.return_value = "timeout"
-        ret = get_installed_software(agent.pk)
-        self.assertFalse(ret)
-        salt_api_cmd.assert_called_with(
-            timeout=30,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        salt_api_cmd.reset_mock()
-
-        # test successful attempt
-        salt_api_cmd.return_value = salt_return
-        ret = get_installed_software(agent.pk)
-        self.assertTrue(ret)
-        salt_api_cmd.assert_called_with(
-            timeout=30,
-            func="pkg.list_pkgs",
-            kwargs={"include_components": False, "include_updates": False},
-        )
-        software = agent.installedsoftware_set.get()
-
-        expected = [
-            {"name": "git", "version": "2.3.4"},
-            {"name": "docker", "version": "1.0.2"},
-        ]
-
-        self.assertTrue(InstalledSoftware.objects.filter(agent=agent).exists())
-        self.assertEquals(software.software, expected)
-
-    @patch("agents.models.Agent.salt_api_cmd")
-    @patch("software.tasks.get_installed_software.delay")
-    def test_install_program(self, get_installed_software, salt_api_cmd):
+    def test_install_program(self, salt_api_cmd):
         from .tasks import install_program
 
         agent = baker.make_recipe("agents.agent")
@@ -247,6 +142,5 @@ class TestSoftwareTasks(TacticalTestCase):
         salt_api_cmd.assert_called_with(
             timeout=900, func="chocolatey.install", arg=["git", "version=2.3.4"]
         )
-        get_installed_software.assert_called_with(agent.pk)
 
         self.assertTrue(ChocoLog.objects.filter(agent=agent, name="git").exists())

api/tacticalrmm/software/views.py

@@ -1,4 +1,5 @@
-import string
+import asyncio
+from typing import Any
 
 from django.shortcuts import get_object_or_404
 
@@ -9,7 +10,7 @@ from agents.models import Agent
 from .models import ChocoSoftware, InstalledSoftware
 from .serializers import InstalledSoftwareSerializer
 from .tasks import install_program
-from tacticalrmm.utils import notify_error
+from tacticalrmm.utils import notify_error, filter_software
 
 
 @api_view()
@@ -41,35 +42,20 @@ def get_installed(request, pk):
 @api_view()
 def refresh_installed(request, pk):
     agent = get_object_or_404(Agent, pk=pk)
-    r = agent.salt_api_cmd(
-        timeout=20,
-        func="pkg.list_pkgs",
-        kwargs={"include_components": False, "include_updates": False},
-    )
+    if not agent.has_nats:
+        return notify_error("Requires agent version 1.1.0 or greater")
 
-    if r == "timeout":
+    r: Any = asyncio.run(agent.nats_cmd({"func": "softwarelist"}, timeout=15))
+    if r == "timeout" or r == "natsdown":
         return notify_error("Unable to contact the agent")
-    elif r == "error":
-        return notify_error("Something went wrong")
 
-    printable = set(string.printable)
-
-    try:
-        software = [
-            {
-                "name": "".join(filter(lambda x: x in printable, k)),
-                "version": "".join(filter(lambda x: x in printable, v)),
-            }
-            for k, v in r.items()
-        ]
-    except Exception:
-        return notify_error("Something went wrong")
+    sw = filter_software(r)
 
     if not InstalledSoftware.objects.filter(agent=agent).exists():
-        InstalledSoftware(agent=agent, software=software).save()
+        InstalledSoftware(agent=agent, software=sw).save()
     else:
-        s = agent.installedsoftware_set.get()
-        s.software = software
+        s = agent.installedsoftware_set.first()
+        s.software = sw
         s.save(update_fields=["software"])
 
     return Response("ok")

api/tacticalrmm/tacticalrmm/celery.py

@@ -27,27 +27,23 @@ app.conf.beat_schedule = {
     },
     "auto-approve-win-updates": {
         "task": "winupdate.tasks.auto_approve_updates_task",
-        "schedule": crontab(minute=0, hour="*/8"),
+        "schedule": crontab(minute=2, hour="*/8"),
     },
     "install-scheduled-win-updates": {
         "task": "winupdate.tasks.check_agent_update_schedule_task",
-        "schedule": crontab(minute=0, hour="*"),
+        "schedule": crontab(minute=5, hour="*"),
     },
     "sync-modules": {
         "task": "agents.tasks.batch_sync_modules_task",
-        "schedule": crontab(minute=40, hour="*/4"),
-    },
-    "sys-info": {
-        "task": "agents.tasks.batch_sysinfo_task",
-        "schedule": crontab(minute=15, hour="*/2"),
-    },
-    "update-salt": {
-        "task": "agents.tasks.update_salt_minion_task",
-        "schedule": crontab(minute=30, hour="*/6"),
+        "schedule": crontab(minute=25, hour="*/4"),
     },
     "agent-auto-update": {
         "task": "agents.tasks.auto_self_agent_update_task",
-        "schedule": crontab(minute=50, hour="*/3"),
+        "schedule": crontab(minute=35, hour="*"),
+    },
+    "agents-sync": {
+        "task": "agents.tasks.sync_sysinfo_task",
+        "schedule": crontab(minute=55, hour="*"),
     },
 }
 

api/tacticalrmm/tacticalrmm/local_settings.py.example

@@ -37,7 +37,6 @@ if not DEBUG:
         )
     })
 
-
 SALT_USERNAME = "changeme"
 SALT_PASSWORD = "changeme"
 MESH_USERNAME = "changeme"

api/tacticalrmm/tacticalrmm/middleware.py

@@ -16,16 +16,15 @@ def get_debug_info():
 EXCLUDE_PATHS = (
     "/api/v3",
     "/api/v2",
-    "/api/v1",
     "/logs/auditlogs",
-    "/winupdate/winupdater",
-    "/winupdate/results",
     f"/{settings.ADMIN_URL}",
     "/logout",
     "/agents/installagent",
     "/logs/downloadlog",
 )
 
+ENDS_WITH = "/services/"
+
 
 class AuditMiddleware:
     def __init__(self, get_response):
@@ -37,7 +36,9 @@ class AuditMiddleware:
         return response
 
     def process_view(self, request, view_func, view_args, view_kwargs):
-        if not request.path.startswith(EXCLUDE_PATHS):
+        if not request.path.startswith(EXCLUDE_PATHS) and not request.path.endswith(
+            ENDS_WITH
+        ):
             # https://stackoverflow.com/questions/26240832/django-and-middleware-which-uses-request-user-is-always-anonymous
             try:
                 # DRF saves the class of the view function as the .cls property

api/tacticalrmm/tacticalrmm/settings.py

@@ -1,8 +1,13 @@
 import os
+from pathlib import Path
 from datetime import timedelta
 
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+SCRIPTS_DIR = "/srv/salt/scripts"
+
+DOCKER_BUILD = False
+
 LOG_DIR = os.path.join(BASE_DIR, "tacticalrmm/private/log")
 
 EXE_DIR = os.path.join(BASE_DIR, "tacticalrmm/private/exe")
@@ -10,23 +15,25 @@ EXE_DIR = os.path.join(BASE_DIR, "tacticalrmm/private/exe")
 AUTH_USER_MODEL = "accounts.User"
 
 # latest release
-TRMM_VERSION = "0.1.1"
+TRMM_VERSION = "0.2.9"
 
 # bump this version everytime vue code is changed
 # to alert user they need to manually refresh their browser
-APP_VER = "0.0.84"
+APP_VER = "0.0.98"
 
 # https://github.com/wh1te909/salt
 LATEST_SALT_VER = "1.1.0"
 
 # https://github.com/wh1te909/rmmagent
-LATEST_AGENT_VER = "1.0.1"
+LATEST_AGENT_VER = "1.1.4"
 
-MESH_VER = "0.6.62"
+MESH_VER = "0.7.14"
+
+SALT_MASTER_VER = "3002.2"
 
 # for the update script, bump when need to recreate venv or npm install
-PIP_VER = "1"
-NPM_VER = "1"
+PIP_VER = "4"
+NPM_VER = "3"
 
 DL_64 = f"https://github.com/wh1te909/rmmagent/releases/download/v{LATEST_AGENT_VER}/winagent-v{LATEST_AGENT_VER}.exe"
 DL_32 = f"https://github.com/wh1te909/rmmagent/releases/download/v{LATEST_AGENT_VER}/winagent-v{LATEST_AGENT_VER}-x86.exe"
@@ -51,7 +58,6 @@ INSTALLED_APPS = [
     "knox",
     "corsheaders",
     "accounts",
-    "api",
     "apiv2",
     "apiv3",
     "clients",
@@ -149,38 +155,6 @@ LOG_CONFIG = {
     "handlers": [{"sink": os.path.join(LOG_DIR, "debug.log"), "serialize": False}]
 }
 
-if "TRAVIS" in os.environ:
-    DATABASES = {
-        "default": {
-            "ENGINE": "django.db.backends.postgresql",
-            "NAME": "travisci",
-            "USER": "travisci",
-            "PASSWORD": "travisSuperSekret6645",
-            "HOST": "127.0.0.1",
-            "PORT": "",
-        }
-    }
-
-    REST_FRAMEWORK = {
-        "DATETIME_FORMAT": "%b-%d-%Y - %H:%M",
-        "DEFAULT_PERMISSION_CLASSES": ("rest_framework.permissions.IsAuthenticated",),
-        "DEFAULT_AUTHENTICATION_CLASSES": ("knox.auth.TokenAuthentication",),
-        "DEFAULT_RENDERER_CLASSES": ("rest_framework.renderers.JSONRenderer",),
-    }
-
-    DEBUG = True
-    SECRET_KEY = "abcdefghijklmnoptravis123456789"
-
-    ADMIN_URL = "abc123456/"
-
-    SALT_USERNAME = "travis"
-    SALT_PASSWORD = "travis"
-    MESH_USERNAME = "travis"
-    MESH_SITE = "https://example.com"
-    MESH_TOKEN_KEY = "bd65e957a1e70c622d32523f61508400d6cd0937001a7ac12042227eba0b9ed625233851a316d4f489f02994145f74537a331415d00047dbbf13d940f556806dffe7a8ce1de216dc49edbad0c1a7399c"
-    REDIS_HOST = "localhost"
-    SALT_HOST = "127.0.0.1"
-
 if "AZPIPELINE" in os.environ:
     DATABASES = {
         "default": {
@@ -200,11 +174,14 @@ if "AZPIPELINE" in os.environ:
         "DEFAULT_RENDERER_CLASSES": ("rest_framework.renderers.JSONRenderer",),
     }
 
+    ALLOWED_HOSTS = ["api.example.com"]
+    DOCKER_BUILD = True
     DEBUG = True
     SECRET_KEY = "abcdefghijklmnoptravis123456789"
 
     ADMIN_URL = "abc123456/"
 
+    SCRIPTS_DIR = os.path.join(Path(BASE_DIR).parents[1], "scripts")
     SALT_USERNAME = "pipeline"
     SALT_PASSWORD = "pipeline"
     MESH_USERNAME = "pipeline"

api/tacticalrmm/tacticalrmm/test.py

@@ -1,24 +1,11 @@
-import json
-import os
-import random
-import string
-
 from django.test import TestCase, override_settings
-from django.utils import timezone as djangotime
-from django.conf import settings
 from model_bakery import baker
 
 from rest_framework.test import APIClient
-from rest_framework.authtoken.models import Token
 
 from accounts.models import User
-from agents.models import Agent
-from winupdate.models import WinUpdatePolicy
-from clients.models import Client, Site
-from automation.models import Policy
 from core.models import CoreSettings
-from checks.models import Check
-from autotasks.models import AutomatedTask
+from rest_framework.authtoken.models import Token
 
 
 class TacticalTestCase(TestCase):
@@ -29,6 +16,12 @@ class TacticalTestCase(TestCase):
         self.client_setup()
         self.client.force_authenticate(user=self.john)
 
+    def setup_agent_auth(self, agent):
+        agent_user = User.objects.create_user(
+            username=agent.agent_id, password=User.objects.make_random_password(60)
+        )
+        Token.objects.create(user=agent_user)
+
     def client_setup(self):
         self.client = APIClient()
 
@@ -51,62 +44,6 @@ class TacticalTestCase(TestCase):
         r = switch.get(method)
         self.assertEqual(r.status_code, 401)
 
-    def agent_setup(self):
-        self.agent = Agent.objects.create(
-            operating_system="Windows 10",
-            plat="windows",
-            plat_release="windows-Server2019",
-            hostname="DESKTOP-TEST123",
-            salt_id="aksdjaskdjs",
-            local_ip="10.0.25.188",
-            agent_id="71AHC-AA813-HH1BC-AAHH5-00013|DESKTOP-TEST123",
-            services=[
-                {
-                    "pid": 880,
-                    "name": "AeLookupSvc",
-                    "status": "stopped",
-                    "binpath": "C:\\Windows\\system32\\svchost.exe -k netsvcs",
-                    "username": "localSystem",
-                    "start_type": "manual",
-                    "description": "Processes application compatibility cache requests for applications as they are launched",
-                    "display_name": "Application Experience",
-                },
-                {
-                    "pid": 812,
-                    "name": "ALG",
-                    "status": "stopped",
-                    "binpath": "C:\\Windows\\System32\\alg.exe",
-                    "username": "NT AUTHORITY\\LocalService",
-                    "start_type": "manual",
-                    "description": "Provides support for 3rd party protocol plug-ins for Internet Connection Sharing",
-                    "display_name": "Application Layer Gateway Service",
-                },
-            ],
-            public_ip="74.13.24.14",
-            total_ram=16,
-            used_ram=33,
-            disks={
-                "C:": {
-                    "free": "42.3G",
-                    "used": "17.1G",
-                    "total": "59.5G",
-                    "device": "C:",
-                    "fstype": "NTFS",
-                    "percent": 28,
-                }
-            },
-            boot_time=8173231.4,
-            logged_in_username="John",
-            client="Google",
-            site="Main Office",
-            monitoring_type="server",
-            description="Test PC",
-            mesh_node_id="abcdefghijklmnopAABBCCDD77443355##!!AI%@#$%#*",
-            last_seen=djangotime.now(),
-        )
-
-        self.update_policy = WinUpdatePolicy.objects.create(agent=self.agent)
-
     def create_checks(self, policy=None, agent=None, script=None):
 
         if not policy and not agent:
@@ -132,136 +69,3 @@ class TacticalTestCase(TestCase):
                     baker.make_recipe(recipe, policy=policy, agent=agent, script=script)
                 )
         return checks
-
-
-class BaseTestCase(TestCase):
-    def setUp(self):
-
-        self.john = User(username="john")
-        self.john.set_password("password")
-        self.john.save()
-        self.client = APIClient()
-        self.client.force_authenticate(user=self.john)
-
-        self.coresettings = CoreSettings.objects.create()
-        self.agent = self.create_agent("DESKTOP-TEST123", "Google", "Main Office")
-        self.agent_user = User.objects.create_user(
-            username=self.agent.agent_id, password=User.objects.make_random_password(60)
-        )
-        self.agent_token = Token.objects.create(user=self.agent_user)
-        self.update_policy = WinUpdatePolicy.objects.create(agent=self.agent)
-
-        Client.objects.create(client="Google")
-        Client.objects.create(client="Facebook")
-        google = Client.objects.get(client="Google")
-        facebook = Client.objects.get(client="Facebook")
-        Site.objects.create(client=google, site="Main Office")
-        Site.objects.create(client=google, site="LA Office")
-        Site.objects.create(client=google, site="MO Office")
-        Site.objects.create(client=facebook, site="Main Office")
-        Site.objects.create(client=facebook, site="NY Office")
-
-        self.policy = Policy.objects.create(
-            name="testpolicy",
-            desc="my awesome policy",
-            active=True,
-        )
-        self.policy.server_clients.add(google)
-        self.policy.workstation_clients.add(facebook)
-
-        self.agentDiskCheck = Check.objects.create(
-            agent=self.agent,
-            check_type="diskspace",
-            disk="C:",
-            threshold=41,
-            fails_b4_alert=4,
-        )
-        self.policyDiskCheck = Check.objects.create(
-            policy=self.policy,
-            check_type="diskspace",
-            disk="M:",
-            threshold=87,
-            fails_b4_alert=1,
-        )
-
-        self.policyTask = AutomatedTask.objects.create(
-            policy=self.policy, name="Test Task"
-        )
-
-    def check_not_authenticated(self, method, url):
-        self.client.logout()
-        switch = {
-            "get": self.client.get(url),
-            "post": self.client.post(url),
-            "put": self.client.put(url),
-            "patch": self.client.patch(url),
-            "delete": self.client.delete(url),
-        }
-        r = switch.get(method)
-        self.assertEqual(r.status_code, 401)
-
-    def create_agent(self, hostname, client, site, monitoring_type="server"):
-        with open(
-            os.path.join(
-                settings.BASE_DIR, "tacticalrmm/test_data/wmi_python_agent.json"
-            )
-        ) as f:
-            wmi_py = json.load(f)
-
-        return Agent.objects.create(
-            operating_system="Windows 10",
-            plat="windows",
-            plat_release="windows-Server2019",
-            hostname=f"{hostname}",
-            salt_id=self.generate_agent_id(hostname),
-            local_ip="10.0.25.188",
-            agent_id="71AHC-AA813-HH1BC-AAHH5-00013|DESKTOP-TEST123",
-            services=[
-                {
-                    "pid": 880,
-                    "name": "AeLookupSvc",
-                    "status": "stopped",
-                    "binpath": "C:\\Windows\\system32\\svchost.exe -k netsvcs",
-                    "username": "localSystem",
-                    "start_type": "manual",
-                    "description": "Processes application compatibility cache requests for applications as they are launched",
-                    "display_name": "Application Experience",
-                },
-                {
-                    "pid": 812,
-                    "name": "ALG",
-                    "status": "stopped",
-                    "binpath": "C:\\Windows\\System32\\alg.exe",
-                    "username": "NT AUTHORITY\\LocalService",
-                    "start_type": "manual",
-                    "description": "Provides support for 3rd party protocol plug-ins for Internet Connection Sharing",
-                    "display_name": "Application Layer Gateway Service",
-                },
-            ],
-            public_ip="74.13.24.14",
-            total_ram=16,
-            used_ram=33,
-            disks={
-                "C:": {
-                    "free": "42.3G",
-                    "used": "17.1G",
-                    "total": "59.5G",
-                    "device": "C:",
-                    "fstype": "NTFS",
-                    "percent": 28,
-                }
-            },
-            boot_time=8173231.4,
-            logged_in_username="John",
-            client=f"{client}",
-            site=f"{site}",
-            monitoring_type=monitoring_type,
-            description="Test PC",
-            mesh_node_id="abcdefghijklmnopAABBCCDD77443355##!!AI%@#$%#*",
-            last_seen=djangotime.now(),
-            wmi_detail=wmi_py,
-        )
-
-    def generate_agent_id(self, hostname):
-        rand = "".join(random.choice(string.ascii_letters) for _ in range(35))
-        return f"{rand}-{hostname}"

api/tacticalrmm/tacticalrmm/urls.py

@@ -10,7 +10,6 @@ urlpatterns = [
     path("login/", LoginView.as_view()),
     path("logout/", knox_views.LogoutView.as_view()),
     path("logoutall/", knox_views.LogoutAllView.as_view()),
-    path("api/v1/", include("api.urls")),
     path("api/v2/", include("apiv2.urls")),
     path("api/v3/", include("apiv3.urls")),
     path("clients/", include("clients.urls")),

api/tacticalrmm/tacticalrmm/utils.py

@@ -1,4 +1,124 @@
+import json
+import os
+import string
+import subprocess
+import time
+from typing import List, Dict
+from loguru import logger
+
+from django.conf import settings
 from rest_framework import status
 from rest_framework.response import Response
 
+from agents.models import Agent
+
+logger.configure(**settings.LOG_CONFIG)
+
 notify_error = lambda msg: Response(msg, status=status.HTTP_400_BAD_REQUEST)
+
+SoftwareList = List[Dict[str, str]]
+
+WEEK_DAYS = {
+    "Sunday": 0x1,
+    "Monday": 0x2,
+    "Tuesday": 0x4,
+    "Wednesday": 0x8,
+    "Thursday": 0x10,
+    "Friday": 0x20,
+    "Saturday": 0x40,
+}
+
+
+def get_bit_days(days: List[str]) -> int:
+    bit_days = 0
+    for day in days:
+        bit_days |= WEEK_DAYS.get(day)
+    return bit_days
+
+
+def bitdays_to_string(day: int) -> str:
+    ret = []
+    if day == 127:
+        return "Every day"
+
+    if day & WEEK_DAYS["Sunday"]:
+        ret.append("Sunday")
+    if day & WEEK_DAYS["Monday"]:
+        ret.append("Monday")
+    if day & WEEK_DAYS["Tuesday"]:
+        ret.append("Tuesday")
+    if day & WEEK_DAYS["Wednesday"]:
+        ret.append("Wednesday")
+    if day & WEEK_DAYS["Thursday"]:
+        ret.append("Thursday")
+    if day & WEEK_DAYS["Friday"]:
+        ret.append("Friday")
+    if day & WEEK_DAYS["Saturday"]:
+        ret.append("Saturday")
+
+    return ", ".join(ret)
+
+
+def filter_software(sw: SoftwareList) -> SoftwareList:
+    ret: SoftwareList = []
+    printable = set(string.printable)
+    for s in sw:
+        ret.append(
+            {
+                "name": "".join(filter(lambda x: x in printable, s["name"])),
+                "version": "".join(filter(lambda x: x in printable, s["version"])),
+                "publisher": "".join(filter(lambda x: x in printable, s["publisher"])),
+                "install_date": s["install_date"],
+                "size": s["size"],
+                "source": s["source"],
+                "location": s["location"],
+                "uninstall": s["uninstall"],
+            }
+        )
+
+    return ret
+
+
+def reload_nats():
+    users = [{"user": "tacticalrmm", "password": settings.SECRET_KEY}]
+    agents = Agent.objects.prefetch_related("user").only("pk", "agent_id")
+    for agent in agents:
+        try:
+            users.append(
+                {"user": agent.agent_id, "password": agent.user.auth_token.key}
+            )
+        except:
+            logger.critical(
+                f"{agent.hostname} does not have a user account, NATS will not work"
+            )
+
+    domain = settings.ALLOWED_HOSTS[0].split(".", 1)[1]
+    if hasattr(settings, "CERT_FILE") and hasattr(settings, "KEY_FILE"):
+        if os.path.exists(settings.CERT_FILE) and os.path.exists(settings.KEY_FILE):
+            cert_file = settings.CERT_FILE
+            key_file = settings.KEY_FILE
+        else:
+            cert_file = f"/etc/letsencrypt/live/{domain}/fullchain.pem"
+            key_file = f"/etc/letsencrypt/live/{domain}/privkey.pem"
+    else:
+        cert_file = f"/etc/letsencrypt/live/{domain}/fullchain.pem"
+        key_file = f"/etc/letsencrypt/live/{domain}/privkey.pem"
+
+    config = {
+        "tls": {
+            "cert_file": cert_file,
+            "key_file": key_file,
+        },
+        "authorization": {"users": users},
+        "max_payload": 2048576005,
+    }
+
+    conf = os.path.join(settings.BASE_DIR, "nats-rmm.conf")
+    with open(conf, "w") as f:
+        json.dump(config, f)
+
+    if not settings.DOCKER_BUILD:
+        time.sleep(0.5)
+        subprocess.run(
+            ["/usr/local/bin/nats-server", "-signal", "reload"], capture_output=True
+        )