finally reasonable file structure

Author: NegaScout

main.py

@@ -1,4 +1,4 @@
-from src import Hermes 
+from src import HermesBot
 
-bot = Hermes.Hermes()
+bot = HermesBot.Hermes()
 bot.run()

src/Hermes.py

@@ -0,0 +1,16 @@
+import os
+import asyncio
+def load_cogs(self):
+    cogs = os.listdir(self.cog_prefix.replace('.', '/'))
+    cogs = map(self.cog_prefix.replace('.', '/').__add__, cogs) 
+    cogs = filter(os.path.isfile, list(cogs))
+    for cog in cogs:
+        cog = cog[:-3].replace('/', '.')
+        try:
+            asyncio.run(self.load_extension(cog))
+            self.logger.info(f"Cog {cog} loaded.")
+            print("cog loaded")
+
+        except Exception as e:
+            self.logger.warning(f"Cog {cog} can not be loaded!")
+            raise e

src/Hermes/__init__.py

@@ -0,0 +1,15 @@
+import os
+from src.backend.sqlite import with_commit, scriptexec
+from sqlite3 import connect
+async def build_database(self):
+    if os.path.isfile(self.DB_WIREGUARD_SCHEMA):
+
+        scriptexec(self.cursor, self.DB_WIREGUARD_SCHEMA)
+
+async def ready_database(self):
+    try:
+        self.db_conn = connect(self.DB_PATH, check_same_thread=False) if self.db_conn is None else None 
+        self.cursor = self.db_conn.cursor() if self.cursor is None else None
+        self.logger.info("Database initialized")
+    except Exception as e:
+        self.logger.warn(f"Database could not be initialized!\n{e}")

src/Hermes/cogs.py

@@ -0,0 +1,17 @@
+import logging
+def start_logging(self):
+    self.logger = logging.getLogger('discord') # annother loggger for hermes?
+    self.logger.setLevel(logging.DEBUG)
+    logging.getLogger('discord.http').setLevel(logging.INFO) # is this enother logger?
+    
+    handler = logging.handlers.RotatingFileHandler(
+            filename='discord.log',
+            encoding='utf-8',
+            maxBytes=32 * 1024 * 1024,  # 32 MiB
+            backupCount=5,  # Rotate through 5 files
+        )
+
+    dt_fmt = '%Y-%m-%d %H:%M:%S'
+    formatter = logging.Formatter('[{asctime}] [{levelname:<8}] {name}: {message}', dt_fmt, style='{')
+    handler.setFormatter(formatter)
+    self.logger.addHandler(handler)

src/Hermes/database.py

@@ -0,0 +1,48 @@
+async def on_connect(self):
+    self.logger.info("Connected")
+
+async def on_disconnect(self):
+    self.logger.info("Disconnected")
+
+async def on_ready(self):
+
+    if not self.ready:
+        self.ready = True
+        self.logger.info("Hermes ready")
+        self.stdout = self.get_channel(810599224718262304)
+        self.guild = self.get_guild(716803899440234506)
+        await self.ready_database()
+        await self.build_database()
+        await self.insert_wireguard_user(1, "pub", 2)
+        await self.read_wireguard_users()
+        try:
+            await self.tree.sync(guild=self.guild) 
+        except Exception as e:
+            print(e)
+    else:
+        self.logger.info("Reconnected")
+
+async def on_message(self, message):
+    if not message.author.bot:#and message.author == self.get_user(309723713857650688)
+        await self.process_commands(message)
+
+#            await message.interaction.response.send_modal(WireguardModal())
+
+
+async def on_error(self, err, *args, **kwargs):
+    
+    if err == "on_command_error":
+        self.logger.debug("on_command_error Something went wrong.")
+    else:
+        raise exc.original
+
+async def on_command_error(self, context, exception):
+
+    if isinstance(exception, CommandNotFound):
+        pass
+    elif hassattr(exception, "original"):
+        self.logger.debug(exception.original)
+        raise exception.original
+    else:
+        self.logger.debug(exception)
+        raise exception

src/Hermes/logging.py

@@ -0,0 +1,33 @@
+import jinja2
+# maybe put to extension or module?
+async def insert_wireguard_user(self, user_id:int, pub_key:str, date:int):
+    statement = '''INSERT INTO WIREGUARD_USERS VALUES(?, ?, ?)''' 
+    try:
+        self.db_conn.execute(statement, (user_id, pub_key, date))
+        self.logger.info(f"{(user_id, pub_key, date)} inserted into database.")
+    except Exception as e:
+        self.logger.warn(f"Could not insert to database!\n{e}")
+
+async def read_wireguard_users(self):
+    statement = '''SELECT * FROM WIREGUARD_USERS''' 
+    try:
+        temp = self.db_conn.execute(statement)
+        return temp
+        for row in self.cursor.fetchall():
+            pass # parse
+    except Exception as e:
+        self.logger.warn(f"Could not read from database!\n{e}")
+
+def generate_wg_conf(self, db_select_outpout):
+    env = jinja2.Environment()
+    template = env.get_template("Wireguard.conf")
+    return template.render(HOST={}, PEERS={})
+
+#atomicity..?
+async def update_wireguard_conf(self):
+    with self.SSH_CLIENT.connect():
+        with self.SSH_CLIENT.open_sftp() as SFTP_conn:
+            with SFTP_conn.file(self.wireguard_conf_path, mode='w') as wg_conf:
+                entries = read_wireguard_users()
+                wg_conf_string = generate_wg_conf(entries)
+                wg_conf.write(wg_conf_string)

src/Hermes/on_.py

@@ -0,0 +1,67 @@
+import asyncio, os
+from discord.ext.commands import Bot as BotBase
+from discord import Intents, ui, app_commands
+from logging.handlers import RotatingFileHandler
+from discord.ext.commands import CommandNotFound, command
+
+from src.Embeds.Wireguard import WireguardMenu
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from datetime import datetime
+#https://www.youtube.com/watch?v=4EIy0bw7s-s&list=PLYeOw6sTSy6ZGyygcbta7GcpI8a5-Cooc&index=5
+
+from sqlite3 import connect
+from src.backend.sqlite import with_commit, scriptexec
+
+
+class Hermes(BotBase):
+
+    def __init__(self, *args, **kwargs):
+
+        self.prefix = "+"
+        self.guild = None
+        self.scheduler = AsyncIOScheduler()
+        self.ready = False
+        self.cog_prefix = "src.cogs."
+
+        self.DB_PATH = "data/database.db"
+        self.DB_WIREGUARD_SCHEMA = "data/build.sql"
+        self.db_conn = None
+        self.cursor = None
+#        intents = Intents.default()
+#        intents.message_content = True
+        super().__init__(command_prefix=self.prefix,
+                        intents=Intents.all(),
+                        *args,
+                        **kwargs)
+        
+    async def sync_tree(self):
+        try:
+            synced = await self.tree.sync()
+            if synced:
+                self.logger.info("Tree synced")
+            else:
+                self.logger.warning("Tree not synced!")
+        except Exception as e:
+            self.logger.warning(f"Could not sync tree!\n{e}")
+            raise e
+
+    def run(self):
+        with open("token", "r") as token_fh:
+            self.token = token_fh.read()
+        self.start_logging()
+        self.load_cogs()
+        self.logger.info("Hermess run")
+        super().run(self.token, reconnect=True)
+    
+    from src.Hermes.cogs import load_cogs
+    from src.Hermes.logging import start_logging
+    from src.Hermes.on_ import on_connect, on_disconnect, on_ready, on_message, on_error, on_command_error
+    from src.Hermes.database import build_database \
+                             ,ready_database
+
+    from src.Hermes.wireguard import insert_wireguard_user \
+                             ,read_wireguard_users
+
+
+    

src/Hermes/wireguard.py

@@ -1,11 +1,16 @@
 from discord import ui, app_commands, TextStyle
 
-class WireguardModal(ui.Modal, title = "Wireguard Modal"):
-    name = ui.TextInput(label = "name")
-#    def __init__(self):
-#        self.name = ui.TextInput(label = "name")
-#        super().__init__()
-#        self.add_item()
+class WireguardModal(ui.Modal, title = "Wireguard Configuration"):
+    wg_pub_key = ui.TextInput(label = "Wireguard public key:")
 
     async def on_submit(self, interaction):
-        pass
+        print("WG MODAL INPUT: " + str(self.wg_pub_key))
+        await interaction.response.defer()
+    
+    def insert_wireguard_user(db_conn, user_id:int, pub_key:str, date:int):
+        statement = '''INSERT INTO WIREGUARD_USERS VALUES(?, ?, ?)''' 
+        try:
+            self.db_conn.execute((user_id, pub_key, date))
+            self.logger.info(f"{(user_id, pub_key, date)} is inserted into wireguard users db.")
+        except:
+            self.logger.warn("Error when inserting into wg db!")

src/HermesBot.py

@@ -0,0 +1,23 @@
+from os.path import isfile
+from sqlite3 import connect
+
+def with_commit(func):
+    def inner(*args, **kwargs):
+        func(*args, **kwargs)
+        commit()
+    return inner
+
+@with_commit
+def build():
+    if isfile(BUILD_PATH):
+        scriptexec(SQL_PATH)
+
+def commit():
+    db_conn.commit()
+
+def close():
+    db_conn.close()
+
+def scriptexec(cursor, path):
+    with open(path, 'r', encoding="utf-8") as script:
+        cursor.executescript(script.read())