Merge pull request #49 from adator85/dev

unsubscribe before unload

README.md

@@ -32,34 +32,30 @@ Il permet aux opérateurs de gérer efficacement un canal, tout en offrant aux u
         - Système d'exploitation Linux (Windows non supporté)
         - Un server UnrealIRCD corréctement configuré
         - Python version 3.10 ou supérieure
-```bash
-        # Bash
+
+    Bash:
         $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
-        # Renommer le fichier exemple_configuration.json en configuration.json
-        # Configurer le fichier configuration.json
+        - Renommer le fichier exemple_configuration.json en configuration.json
+        - Configurer le fichier configuration.json
         $ python3 main.py
-```
+
 Si votre configuration est bonne, votre service est censé etre connecté a votre réseau IRC
 Pour Les prochains lancement de defender vous devez utiliser la commande suivante:
 
-```bash
-    # Bash
+    Bash:
         $ systemctl --user [start | stop | restart | status] defender
-```
+
 # Installation manuelle:
-```bash
-    # Bash
+    Bash:
         $ git clone https://github.com/adator85/IRC_DEFENDER_MODULES.git
         $ cd IRC_DEFENDER_MODULES
         $ python3 -m venv .pyenv
         $ source .pyenv/bin/activate
-    (pyenv)$ pip install sqlalchemy, psutil, requests, faker, unrealircd_rpc_py
-
-    # Créer un service nommé "defender.service" 
-    # pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
-    # Si le dossier n'existe pas il faut les créer
+        (pyenv)$ pip install sqlalchemy, psutil, requests, faker
+        - Créer un service nommé "defender.service" pour votre service et placer le dans "/PATH/TO/USER/.config/systemd/user/"
+        - Si le dossier n'existe pas il faut les créer
         $ sudo systemctl --user start defender
-```
+
 # Configuration
 ```
     SERVEUR (Serveur)

core/base.py

@@ -1,21 +1,8 @@
-import os
-import re
-import json
-import time
-import random
-import socket
-import hashlib
-import logging
-import threading
-import ipaddress
-
-import ast
-import requests
-
+import time, threading, os, random, socket, hashlib, ipaddress, logging, requests, json, re, ast
 from dataclasses import fields
 from typing import Union, Literal
 from base64 import b64decode, b64encode
-from datetime import datetime, timedelta, timezone
+from datetime import datetime
 from sqlalchemy import create_engine, Engine, Connection, CursorResult
 from sqlalchemy.sql import text
 from core.loadConf import ConfigDataModel
@@ -119,11 +106,7 @@ class Base:
         Cette fonction retourne un UNIXTIME de type 12365456
         Return: Current time in seconds since the Epoch (int)
         """
-        cet_offset = timezone(timedelta(hours=2))
-        now_cet = datetime.now(cet_offset)
-        unixtime_cet = int(now_cet.timestamp())
         unixtime = int( time.time() )
-
         return unixtime
 
     def get_datetime(self) -> str:

core/connection.py

@@ -2,10 +2,10 @@ import socket
 import ssl
 import traceback
 from ssl import SSLSocket
-from typing import Union
 from core.loadConf import Config
 from core.Model import Clones
 from core.base import Base
+from typing import Union
 
 class Connection:
 

core/installation.py

@@ -1,8 +1,8 @@
-import os
-from sys import exit
 from dataclasses import dataclass
 from subprocess import check_call, run, CalledProcessError, PIPE
 from platform import python_version, python_version_tuple
+from sys import exit
+import os
 
 class Install:
 

core/irc.py

@@ -1,17 +1,10 @@
-import sys
-import socket
-import threading
-import ssl
-import re
-import importlib
-import time
-import traceback
+import ssl, re, importlib, sys, time, threading, socket, traceback
 from ssl import SSLSocket
 from datetime import datetime, timedelta
-from typing import Union
+from typing import Union, Literal
 from core.loadConf import Config
-from core.base import Base
 from core.Model import User, Admin, Channel, Clones
+from core.base import Base
 
 class Irc:
 
@@ -499,39 +492,6 @@ class Irc:
             self.Base.logs.error(f"Something went wrong with a module you want to load : {e}")
             self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :[ {self.Config.COLORS.red}ERROR{self.Config.COLORS.black} ]: {e}")
 
-    def unload_module(self, mod_name: str) -> bool:
-        """Unload a module
-
-        Args:
-            mod_name (str): Module name ex mod_defender
-
-        Returns:
-            bool: True if success
-        """
-        try:
-            module_name = mod_name.lower()                              # Le nom du module. exemple: mod_defender
-            class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
-
-            if class_name in self.loaded_classes:
-                self.loaded_classes[class_name].unload()
-                for level, command in self.loaded_classes[class_name].commands_level.items():
-                    # Supprimer la commande de la variable commands
-                    for c in self.loaded_classes[class_name].commands_level[level]:
-                        self.commands.remove(c)
-                        self.commands_level[level].remove(c)
-
-                del self.loaded_classes[class_name]
-
-                # Supprimer le module de la base de données
-                self.Base.db_delete_module(module_name)
-
-                self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
-                return True
-
-        except Exception as err:
-            self.Base.logs.error(f"General Error: {err}")
-            return False
-
     def insert_db_admin(self, uid:str, level:int) -> None:
 
         if self.User.get_User(uid) is None:
@@ -1037,9 +997,7 @@ class Irc:
                                     recieved_unixtime = int(arg[1].replace('\x01',''))
                                     current_unixtime = self.Base.get_unixtime()
                                     ping_response = current_unixtime - recieved_unixtime
-
-                                    self.send2socket(f'PONG :{recieved_unixtime}')
-                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {recieved_unixtime} secs\x01')
+                                    self.send2socket(f':{dnickname} NOTICE {user_trigger} :\x01PING {str(ping_response)} secs\x01')
                                     return False
 
                                 if not arg[0].lower() in self.commands:
@@ -1327,6 +1285,7 @@ class Irc:
 
             case 'help':
 
+                help = ''
                 count_level_definition = 0
                 get_admin = self.Admin.get_Admin(uid)
                 if not get_admin is None:
@@ -1341,15 +1300,18 @@ class Irc:
                     if int(user_level) >= int(count_level_definition):
 
                         self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** {self.Config.COLORS.nogc}[ {self.Config.COLORS.green}LEVEL {str(levDef)} {self.Config.COLORS.nogc}] *****************')
+                        count_commands = 0
+                        help = ''
+                        for comm in self.commands_level[count_level_definition]:
 
-                        batch = 7
-                        for i in range(0, len(self.commands_level[count_level_definition]), batch):
-                            groupe = self.commands_level[count_level_definition][i:i + batch]  # Extraire le groupe
-                            batch_commands = ' | '.join(groupe)
-                            self.send2socket(f':{dnickname} NOTICE {fromuser} : {batch_commands}')
+                            help += f"{comm.upper()}"
+                            if int(count_commands) < len(self.commands_level[count_level_definition])-1:
+                                help += ' | '
+                            count_commands += 1
+
+                        self.send2socket(f':{dnickname} NOTICE {fromuser} : {help}')
 
                     count_level_definition += 1
-                    self.send2socket(f':{dnickname} NOTICE {fromuser} : ')
 
                 self.send2socket(f':{dnickname} NOTICE {fromuser} : ***************** FIN DES COMMANDES *****************')
 
@@ -1358,12 +1320,27 @@ class Irc:
                 self.load_module(fromuser, str(cmd[1]))
 
             case 'unload':
-                # unload mod_defender
+                # unload mod_dktmb
                 try:
                     module_name = str(cmd[1]).lower()                              # Le nom du module. exemple: mod_defender
-                    self.unload_module(module_name)
-                except Exception as err:
-                    self.Base.logs.error(f"General Error: {err}")
+                    class_name = module_name.split('_')[1].capitalize()            # Nom de la class. exemple: Defender
+
+                    if class_name in self.loaded_classes:
+                        self.loaded_classes[class_name].unload()
+                        for level, command in self.loaded_classes[class_name].commands_level.items():
+                            # Supprimer la commande de la variable commands
+                            for c in self.loaded_classes[class_name].commands_level[level]:
+                                self.commands.remove(c)
+                                self.commands_level[level].remove(c)
+
+                        del self.loaded_classes[class_name]
+
+                        # Supprimer le module de la base de données
+                        self.Base.db_delete_module(module_name)
+
+                        self.send2socket(f":{self.Config.SERVICE_NICKNAME} PRIVMSG {self.Config.SERVICE_CHANLOG} :Module {module_name} supprimé")
+                except:
+                    self.Base.logs.error(f"Something went wrong with a module you want to load")
 
             case 'reload':
                 # reload mod_dktmb

core/loadConf.py

@@ -1,5 +1,4 @@
-import sys
-import json
+import json, sys
 from os import sep
 from typing import Union, Literal
 from dataclasses import dataclass, field
@@ -86,19 +85,10 @@ class ConfigDataModel:
     """The password of the admin of the service"""
 
     JSONRPC_URL: str
-    """The RPC url, if local https://127.0.0.1:PORT/api should be fine"""
-
     JSONRPC_PATH_TO_SOCKET_FILE: str
-    """The full path of the socket file (/PATH/TO/YOUR/UNREALIRCD/SOCKET/FILE.socket)"""
-
     JSONRPC_METHOD: str
-    """3 methods are available; requests/socket/unixsocket"""
-
     JSONRPC_USER: str
-    """The RPC User defined in your unrealircd.conf"""
-
     JSONRPC_PASSWORD: str
-    """The RPC Password defined in your unrealircd.conf"""
 
     SALON_JAIL: str
     """The JAIL channel (ex. #jail)"""

mods/mod_clone.py

@@ -147,7 +147,7 @@ class Clone():
 
             del clone_to_kill
 
-            # If no more clones then stop this thread
+            # If LIST empty then stop this thread
             if not self.Clone.UID_CLONE_DB:
                 break
 

mods/mod_command.py

@@ -37,8 +37,7 @@ class Command():
             1: ['join', 'part'],
             2: ['owner', 'deowner', 'op', 'deop', 'halfop', 'dehalfop', 'voice', 
                 'devoice', 'opall', 'deopall', 'devoiceall', 'voiceall', 'ban', 
-                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick', 'topic',
-                'wallops', 'globops','gnotice','whois', 'names', 'invite', 'inviteme']
+                'unban','kick', 'kickban', 'umode', 'svsjoin', 'svspart', 'svsnick']
         }
 
         # Init the module
@@ -92,7 +91,7 @@ class Command():
             )
         '''
 
-        # self.Base.db_execute_query(table_logs)
+        self.Base.db_execute_query(table_logs)
         return None
 
     def __load_module_configuration(self) -> None:
@@ -162,27 +161,6 @@ class Command():
 
     def cmd(self, data:list) -> None:
 
-        service_id = self.Config.SERVICE_ID                 # Defender serveur id
-        dnickname = self.Config.SERVICE_NICKNAME
-        dchanlog = self.Config.SERVICE_CHANLOG
-        red = self.Config.COLORS.red
-        nogc = self.Config.COLORS.nogc
-        cmd = list(data).copy()
-
-        if len(cmd) < 2:
-            return None
-
-        match cmd[1]:
-            # [':irc.deb.biz.st', '403', 'Dev-PyDefender', '#Z', ':No', 'such', 'channel']
-            case '403' | '401':
-                try:
-                    message = ' '.join(cmd[2:])
-                    self.Irc.send2socket(f":{dnickname} PRIVMSG {dchanlog} :[{red}ERROR MSG{nogc}] {message}")
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
         return None
 
     def _hcmds(self, user:str, channel: any, cmd: list, fullcmd: list = []) -> None:
@@ -599,163 +577,6 @@ class Command():
                 except Exception as err:
                     self.Logs.warning(f'Unknown Error: {str(err)}')
 
-            case 'topic':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    chan = str(cmd[1])
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} TOPIC #channel THE_TOPIC_MESSAGE")
-                        return None
-
-                    topic_msg = ' '.join(cmd[2:]).strip()
-
-                    if topic_msg:
-                        self.Irc.send2socket(f':{dnickname} TOPIC {chan} :{topic_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the topic")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'wallops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} WALLOPS THE_WALLOPS_MESSAGE")
-                        return None
-
-                    wallops_msg = ' '.join(cmd[1:]).strip()
-
-                    if wallops_msg:
-                        self.Irc.send2socket(f':{dnickname} WALLOPS {wallops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the wallops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'globops':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} GLOBOPS THE_GLOBOPS_MESSAGE")
-                        return None
-
-                    globops_msg = ' '.join(cmd[1:]).strip()
-
-                    if globops_msg:
-                        self.Irc.send2socket(f':{dnickname} GLOBOPS {globops_msg} ({dnickname})')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the globops message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'gnotice':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} THE_GLOBAL_NOTICE_MESSAGE")
-                        return None
-
-                    gnotice_msg = ' '.join(cmd[1:]).strip()
-
-                    if gnotice_msg:
-                        self.Irc.send2socket(f':{dnickname} NOTICE $*.* :[{self.Config.COLORS.red}GLOBAL NOTICE{self.Config.COLORS.nogc}] {gnotice_msg}')
-                    else:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :You need to specify the global notice message")
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'whois':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    nickname = str(cmd[1])
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} WHOIS {nickname}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'names':
-                try:
-                    if len(cmd) == 1:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL")
-                        return None
-
-                    chan = str(cmd[1])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} NAMES {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'invite':
-                try:
-                    if len(cmd) < 3:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #CHANNEL NICKNAME")
-                        return None
-
-                    chan = str(cmd[1])
-                    nickname = str(cmd[2])
-
-                    if not self.Base.Is_Channel(chan):
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :The channel must start with #")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel nickname")
-                        return None
-
-                    if self.User.get_nickname(nickname) is None:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :Nickname not found !")
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()} #channel NICKNAME")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {nickname} {chan}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
-            case 'inviteme':
-                try:
-                    if len(cmd) == 0:
-                        self.Irc.send2socket(f":{dnickname} NOTICE {fromuser} :/msg {dnickname} {str(cmd[0]).upper()}")
-                        return None
-
-                    self.Irc.send2socket(f':{dnickname} INVITE {fromuser} {self.Config.SERVICE_CHANLOG}')
-
-                except KeyError as ke:
-                    self.Base.logs.error(ke)
-                except Exception as err:
-                    self.Logs.warning(f'Unknown Error: {str(err)}')
-
             case 'umode':
                 try:
                     # .umode nickname +mode

mods/mod_defender.py

@@ -1,12 +1,7 @@
-import socket
-import json
-import time
-import re
-import psutil
-import requests
 from dataclasses import dataclass, fields, field
 from datetime import datetime
 from typing import Union
+import re, socket, psutil, requests, json, time
 from sys import exit
 from core.irc import Irc
 from core.Model import User

mods/mod_jsonrpc.py

@@ -59,20 +59,13 @@ class Jsonrpc():
         self.__load_module_configuration()
         # End of mandatory methods you can start your customization #
 
-        self.UnrealIrcdRpcLive: Live = Live(path_to_socket_file=self.Config.JSONRPC_PATH_TO_SOCKET_FILE,
-                       callback_object_instance=self,
-                       callback_method_name='callback_sent_to_irc'
-                       )
-
+        self.UnrealIrcdRpcLive: Live = None
         self.Rpc: Loader = Loader(
             req_method=self.Config.JSONRPC_METHOD,
             url=self.Config.JSONRPC_URL,
             username=self.Config.JSONRPC_USER,
             password=self.Config.JSONRPC_PASSWORD
         )
-
-        self.subscribed = False
-
         if self.Rpc.Error.code != 0:
             self.Irc.sendPrivMsg(f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.Rpc.Error.message}", self.Config.SERVICE_CHANLOG)
 
@@ -121,9 +114,12 @@ class Jsonrpc():
 
     def thread_start_jsonrpc(self):
 
+        self.UnrealIrcdRpcLive = Live(path_to_socket_file=self.Config.JSONRPC_PATH_TO_SOCKET_FILE,
+                       callback_object_instance=self,
+                       callback_method_name='callback_sent_to_irc'
+                       )
         if self.UnrealIrcdRpcLive.Error.code == 0:
             self.UnrealIrcdRpcLive.subscribe()
-            self.subscribed = True
         else:
             self.Irc.sendPrivMsg(f"[{self.Config.COLORS.red}ERROR{self.Config.COLORS.nogc}] {self.UnrealIrcdRpcLive.Error.message}", self.Config.SERVICE_CHANLOG)
 
@@ -152,7 +148,6 @@ class Jsonrpc():
         self.Base.db_update_core_config(self.module_name, self.ModConfig, param_key, param_value)
 
     def unload(self) -> None:
-        if self.UnrealIrcdRpcLive.Error.code != -1:
         self.UnrealIrcdRpcLive.unsubscribe()
         return None
 
@@ -203,22 +198,23 @@ class Jsonrpc():
                             if uid_to_get is None:
                                 return None
 
-                            rpc = self.Rpc
+                            rpc = Loader(
+                                req_method=self.Config.JSONRPC_METHOD,
+                                url=self.Config.JSONRPC_URL,
+                                username=self.Config.JSONRPC_USER,
+                                password=self.Config.JSONRPC_PASSWORD
+                                )
 
                             UserInfo = rpc.User.get(uid_to_get)
                             if rpc.Error.code != 0:
                                 self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :{rpc.Error.message}')
                                 return None
 
-                            chan_list = []
-                            for chan in UserInfo.channels:
-                                chan_list.append(chan["name"])
-
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :UID                  : {UserInfo.id}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :NICKNAME             : {UserInfo.name}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :USERNAME             : {UserInfo.username}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :REALNAME             : {UserInfo.realname}')
-                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CHANNELS             : {chan_list}')
+                            self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :CHANNELS             : {UserInfo.channels}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :SECURITY GROUP       : {UserInfo.security_groups}')
                             self.Irc.send2socket(f':{dnickname} NOTICE {fromuser} :REPUTATION           : {UserInfo.reputation}')
 

version.json

@@ -1,3 +1,3 @@
 {
-    "version": "5.3.2"
+    "version": "5.3.1"
 }