initial Discord bot

Author: andyshinn

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+omit = tests/*

.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+default_language_version:
+  python: python3.11
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-merge-conflict
+      - id: check-shebang-scripts-are-executable
+      - id: check-ast
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 24.8.0
+    hooks:
+      - id: black
+  - repo: https://github.com/pycqa/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort

.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Discord Bot",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "bridger.bot"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

bridger/bot.py

@@ -0,0 +1,54 @@
+import os
+
+from aiohttp import ClientConnectorError
+from discord import Intents
+from discord.ext import commands
+
+from bridger.log import logger
+
+try:
+    DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
+    DISCORD_BOT_OWNER_ID = int(os.getenv("DISCORD_BOT_OWNER_ID"))
+except TypeError as e:
+    logger.error(f"Failed to load environment variable {e}")
+    exit(1)
+
+
+class BridgerBot(commands.Bot):
+    def __init__(self, **kwargs):
+        super().__init__(command_prefix="./bridger ", **kwargs)
+
+        self.initial_extensions = [
+            "bridger.cogs.mqtt",
+        ]
+
+    async def setup_hook(self):
+        for ext in self.initial_extensions:
+            await self.load_extension(ext)
+
+
+intents = Intents.default()
+intents.message_content = True
+intents.members = True
+
+bot = BridgerBot(
+    intents=intents,
+    owner_id=DISCORD_BOT_OWNER_ID,
+)
+
+
+@commands.is_owner()
+@bot.command(name="sync-commands", description="Sync the commands with the database")
+async def sync_commands(ctx: commands.Context):
+    try:
+        await ctx.bot.tree.sync()
+        await ctx.send("Commands synced to all guilds")
+    except Exception as e:
+        await ctx.send(f"Error syncing commands: {e}")
+
+
+try:
+    bot.run(DISCORD_BOT_TOKEN)
+except ClientConnectorError as e:
+    logger.error(f"Failed to connect to Discord {e}")
+    exit(1)

bridger/cogs/mqtt.py

@@ -0,0 +1,146 @@
+import os
+
+from discord import Embed, Interaction, app_commands
+from discord.ext import commands
+from discord.utils import get
+
+from bridger.gateway import GatewayError, GatewayManagerEMQX, emqx
+from bridger.log import logger
+
+BRIDGER_ADMIN_ROLE = os.getenv("BRIDGER_ADMIN_ROLE", "Bridger Admin")
+
+
+def check_gateway_owner(interaction: Interaction) -> bool:
+    node_id = None
+    gateway_manager = GatewayManagerEMQX(emqx)
+
+    logger.debug(f"Interaction data: {interaction.data}")
+
+    if "options" in interaction.data:
+        # Look through nested options
+        for option in interaction.data["options"]:
+            if "options" in option:
+                for sub_option in option["options"]:
+                    if sub_option["name"] == "node_id":
+                        node_id = sub_option["value"]
+                        break
+
+    if not node_id:
+        raise ValueError("node_id not found in the command options")
+
+    logger.debug(f"Node ID: {node_id}")
+
+    try:
+        gateway = gateway_manager.get_gateway(node_id)
+        owner = interaction.client.get_user(gateway.owner_id)
+    except ValueError as e:
+        raise app_commands.AppCommandError(f"Error retrieving gateway: {e}")
+
+    logger.debug(f"Gateway owner: {owner}")
+    logger.debug(f"Interaction user: {interaction.user}")
+
+    compared = owner == interaction.user
+
+    logger.debug(f"Owner and interaction user compared: {compared}")
+
+    return owner == interaction.user
+
+
+def is_bridger_admin_or_owner(interaction: Interaction):
+    bridger_admin_role = get(interaction.guild.roles, name=BRIDGER_ADMIN_ROLE)
+    if bridger_admin_role in interaction.user.roles or check_gateway_owner(interaction):
+        return True
+    return False
+
+
+class MQTTCog(commands.GroupCog, name="bridger-mqtt"):
+    delete_after = None
+
+    def __init__(self, bot: commands.Bot, gateway_manager: GatewayManagerEMQX):
+        self.bot = bot
+        self.gateway_manager = gateway_manager
+
+    async def cog_app_command_error(self, interaction: Interaction, error: app_commands.AppCommandError):
+        # Log the type of error and error message
+        logger.debug(f"App command error: {type(error)}: {error}")
+
+        if isinstance(error, app_commands.errors.CommandInvokeError):
+            if isinstance(error.original, GatewayError):
+                await interaction.response.send_message(
+                    f"Gateway already exists: {error.original.gateway.node_hex_id}",
+                    ephemeral=True,
+                    delete_after=self.delete_after,
+                )
+            else:
+                await interaction.response.send_message(
+                    f"Command invoke error: {error.original}", ephemeral=True, delete_after=self.delete_after
+                )
+        elif isinstance(error, (app_commands.errors.MissingRole, app_commands.errors.CheckFailure)):
+            await interaction.response.send_message(
+                f"Check failure: {error}", ephemeral=True, delete_after=self.delete_after
+            )
+        elif isinstance(error, ValueError):
+            await interaction.response.send_message(f"Value error: {error}", ephemeral=True, delete_after=self.delete_after)
+        else:
+            await interaction.response.send_message(
+                f"Unknown error: {error}", ephemeral=True, delete_after=self.delete_after
+            )
+
+    @app_commands.command(name="request-account", description="Request a new MQTT account")
+    @app_commands.describe(
+        node_id="The hex node ID to request an account for. With or without the preceding ! such as !cbaf0421 or cbaf0421"
+    )
+    async def request_account(self, ctx: Interaction, node_id: str):
+        gateway, password = self.gateway_manager.create_gateway_user(node_id, ctx.user)
+        message = f"Gateway created: {gateway.node_hex_id} with password: {password}"
+
+        await ctx.response.send_message(message, ephemeral=True)
+
+    @app_commands.checks.has_role(BRIDGER_ADMIN_ROLE)
+    @app_commands.command(name="delete-account", description="Delete MQTT account")
+    async def delete_account(self, ctx: Interaction, node_id: str):
+        if self.gateway_manager.delete_gateway_user(node_id, ctx.user):
+            await ctx.response.send_message(f"Gateway deleted: {node_id}", ephemeral=True, delete_after=self.delete_after)
+        else:
+            await ctx.response.send_message(f"Gateway not found: {node_id}", ephemeral=True, delete_after=self.delete_after)
+
+    @app_commands.checks.has_role(BRIDGER_ADMIN_ROLE)
+    @app_commands.command(name="list-accounts", description="List all MQTT accounts")
+    async def list_accounts(self, ctx: Interaction):
+        gateways = self.gateway_manager.list_gateways()
+
+        if not gateways:
+            await ctx.response.send_message(content="There are no provisioned gateways in the system.", ephemeral=True)
+            return
+
+        embed = Embed(description="Currently provisioned gateways:", color=0x6CEB94)
+
+        for gateway in gateways:
+            owner = self.bot.get_user(gateway.owner_id)
+
+            embed.add_field(
+                name="Gateway",
+                value=f"ID: **{gateway.node_hex_id}**\nOwner: **{owner.name}**",
+                inline=True,
+            )
+
+        await ctx.response.send_message(
+            content=f"There are {len(gateways)} provisioned gateways in the system.",
+            embed=embed,
+            ephemeral=True,
+        )
+
+    @app_commands.check(check_gateway_owner)
+    @app_commands.command(name="reset-password", description="Reset MQTT account password")
+    async def reset_password(self, ctx: Interaction, node_id: str):
+        gateway, password = self.gateway_manager.reset_gateway_password(node_id, ctx.user)
+
+        await ctx.response.send_message(
+            f"Gateway password reset: {gateway.node_hex_id} with new password: {password}",
+            ephemeral=True,
+        )
+
+
+async def setup(bot):
+    gateway_manager = GatewayManagerEMQX(emqx)
+    await bot.add_cog(MQTTCog(bot, gateway_manager))

bridger/db.py bridger/dataclasses.pybridger/db.py renamed to bridger/dataclasses.py

@@ -0,0 +1,28 @@
+from urllib.parse import urljoin
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+from .api import ApiMixin
+from .authentication import AuthenticationMixin
+from .authorization import AuthorizationMixin
+
+
+class EMQXClient(ApiMixin, AuthenticationMixin, AuthorizationMixin):
+    def __init__(self, base_url, api_key, secret_key, prefix="/api/v5"):
+        self.base_url = base_url
+        self.prefix = prefix
+        self.auth = HTTPBasicAuth(api_key, secret_key)
+
+    def _handle_response(self, response):
+        response.raise_for_status()
+
+        if response.status_code in [204]:
+            return response.text
+        return response.json()
+
+    def _request(self, method, endpoint, data=None, params=None) -> requests.Response:
+        url = urljoin(self.base_url, f"{self.prefix}{endpoint}")
+        headers = {"Content-Type": "application/json"}
+        response = requests.request(method, url, auth=self.auth, headers=headers, json=data, params=params)
+        return response

bridger/emqx/__init__.py

@@ -0,0 +1,22 @@
+class ApiMixin:
+    def list_api_keys(self):
+        endpoint = "/api_key"
+        return self._request("GET", endpoint)
+
+    def create_api_key(self, key_name, secret, role="administrator"):
+        endpoint = "/api_key"
+        data = {"key_name": key_name, "secret": secret, "role": role}
+        return self._request("POST", endpoint, data=data)
+
+    def get_api_key(self, key_id):
+        endpoint = f"/api_key/{key_id}"
+        return self._request("GET", endpoint)
+
+    def update_api_key(self, key_id, key_name, secret, role):
+        endpoint = f"/api_key/{key_id}"
+        data = {"key_name": key_name, "secret": secret, "role": role}
+        return self._request("PUT", endpoint, data=data)
+
+    def delete_api_key(self, key_id):
+        endpoint = f"/api_key/{key_id}"
+        return self._request("DELETE", endpoint)

bridger/emqx/api.py

@@ -0,0 +1,36 @@
+class AuthenticationMixin:
+    def list_users(self, authentication_id):
+        endpoint = f"/authentication/{authentication_id}/users"
+        response = self._request("GET", endpoint)
+        return self._handle_response(response)
+
+    def get_user(self, authentication_id, user_id):
+        endpoint = f"/authentication/{authentication_id}/users/{user_id}"
+        return self._request("GET", endpoint)
+
+    def create_user(self, authentication_id, user_id, password, is_superuser=False):
+        endpoint = f"/authentication/{authentication_id}/users"
+        data = {"user_id": user_id, "password": password, "is_superuser": is_superuser}
+        request = self._request("POST", endpoint, data=data)
+        return self._handle_response(request)
+
+    def list_authentication(self):
+        endpoint = "/authentication"
+        request = self._request("GET", endpoint)
+        return self._handle_response(request)
+
+    def get_authentication(self, authentication_id):
+        endpoint = f"/authentication/{authentication_id}"
+        request = self._request("GET", endpoint)
+        return self._handle_response(request)
+
+    def delete_user(self, authentication_id, user_id):
+        endpoint = f"/authentication/{authentication_id}/users/{user_id}"
+        request = self._request("DELETE", endpoint)
+        return self._handle_response(request)
+
+    def update_user_password(self, authentication_id, user_id, password):
+        endpoint = f"/authentication/{authentication_id}/users/{user_id}"
+        data = {"password": password}
+        request = self._request("PUT", endpoint, data=data)
+        return self._handle_response(request)