diff --git a/serveur_flask.py b/serveur_flask.py index 7cb3435..0126fa4 100644 --- a/serveur_flask.py +++ b/serveur_flask.py @@ -12,17 +12,18 @@ app = Flask(__name__) PROJECT_PATH = "/home/discord/Bot/Kuby" WEBHOOK_SECRET = "Nois2" PROCESS_NAME = "kuby" +# Ton webhook de logs Discord DISCORD_LOG_URL = "https://discord.com/api/webhooks/1482148910888652910/IA9CcOWtjGswbuxMaOu_6uaclv5zojZo4ttxtV6RYyZzJ9gW7BF7xp_Zv3oPIjYEuh8o" -# Chemin absolu vers le binaire PM2 (Ă©vite l'erreur 127 command not found) +# Chemin vers PM2 PM2_BINARY = "/home/discord/.nvm/versions/node/v24.15.0/bin/pm2" -# Bot Local Proxy +# Bot Local Proxy (Relai vers le Cog de ton bot) BOT_LOCAL_URL = "http://127.0.0.1:5001/bot_event" def send_discord_log(status, message, color, author=None, commit_msg=None): embed = { - "title": f"🚀 Kuby V2 : {status}", + "title": f"🚀 Kuby V2 [Forgejo] : {status}", "description": message, "color": color, "timestamp": datetime.now(timezone.utc).isoformat(), @@ -36,7 +37,7 @@ def send_discord_log(status, message, color, author=None, commit_msg=None): payload = {"embeds": [embed]} try: - requests.post(DISCORD_LOG_URL, json=payload, timeout=10) # ✅ AugmentĂ© de 5s Ă  10s + requests.post(DISCORD_LOG_URL, json=payload, timeout=10) except Exception as e: print(f"[!] Erreur envoi Discord : {e}") @@ -58,29 +59,15 @@ def run_mep_logic(author, commit_msg, branch="main"): os.chdir(target_path) - # 1. GIT + # 1. GIT (Va maintenant pull depuis ton Forgejo auto-hĂ©bergĂ©) subprocess.run(["git", "fetch", "origin"], check=True) subprocess.run(["git", "reset", "--hard", f"origin/{branch}"], check=True) - # 2. RSYNC (si on utilise le fallback de dĂ©pĂŽt) + # 2. RSYNC (Fallback) if use_rsync: subprocess.run(["rsync", "-a", "--exclude=.git", "--exclude=venv", "--exclude=.venv", "--exclude=__pycache__", f"{target_path}/", f"{PROJECT_PATH}/"], check=True) - # ⚡ Migration automatique GitLab tracking - send_discord_log("MIGRATION", "Migration GitLab tracking en cours...", 16776960, author, commit_msg) - try: - subprocess.run( - ["python3", os.path.join(target_path, "scripts", "migrate_gitlab_tracking.py")], - cwd=target_path, - check=True, - capture_output=True, - text=True - ) - send_discord_log("MIGRATION", "✅ Migration GitLab tracking terminĂ©e.", 3066993, author, commit_msg) - except subprocess.CalledProcessError as e: - send_discord_log("ERREUR MIGRATION", f"❌ Migration GitLab Ă©chouĂ©e: {e.stderr}", 15158332, author, commit_msg) - - # 3. PM2 (AppelĂ© directement via son chemin absolu pour corriger l'erreur 127) + # 3. PM2 Restart subprocess.run( [PM2_BINARY, "restart", PROCESS_NAME], check=True, @@ -89,26 +76,24 @@ def run_mep_logic(author, commit_msg, branch="main"): ) duration = (datetime.now() - start_time).total_seconds() - msg = f"✅ **DĂ©ploiement rĂ©ussi en {duration:.2f}s**\nLe bot est Ă  jour et redĂ©marrĂ©." + msg = f"✅ **DĂ©ploiement rĂ©ussi en {duration:.2f}s**\nLe bot est Ă  jour sur Forgejo et redĂ©marrĂ©." send_discord_log("VALIDÉ", msg, 3066993, author, commit_msg) except subprocess.CalledProcessError as e: - # Capture spĂ©cifique si une commande systĂšme (comme Git ou PM2) crash - error_stderr = e.stderr if e.stderr else "Pas de log d'erreur disponible (stderr vide)." + error_stderr = e.stderr if e.stderr else "Pas de log d'erreur disponible." error_msg = f"❌ **ERREUR de commande (Status {e.returncode})**\nCommande : `{ ' '.join(e.cmd) }`\n\n**DĂ©tails :**\n```\n{error_stderr}\n```" send_discord_log("ÉCHEC", error_msg, 15158332, author, commit_msg) except Exception as e: - # Capture globale pour le reste du script Python error_msg = f"❌ **ERREUR de dĂ©ploiement**\n```python\n{str(e)}\n```" send_discord_log("ÉCHEC", error_msg, 15158332, author, commit_msg) @app.route('/deploy', methods=['POST']) def deploy(): - # SĂ©curitĂ© - if request.headers.get('X-Gitlab-Token') != WEBHOOK_SECRET: + # ⚡ MODIFICATION : Forgejo envoie son token secret dans 'X-Gitea-Token' + if request.headers.get('X-Gitea-Token') != WEBHOOK_SECRET: abort(403) - # Extraction des infos GitLab + # Extraction des infos (La structure des commits est identique Ă  GitLab) data = request.json author = "Inconnu" commit_msg = "Pas de message" @@ -121,34 +106,32 @@ def deploy(): ref = data.get('ref', 'refs/heads/main') branch = ref.split('/')[-1] if ref else 'main' - # Threading pour rĂ©pondre vite Ă  GitLab + # Threading inchangĂ© pour rĂ©pondre instantanĂ©ment Ă  Forgejo threading.Thread(target=run_mep_logic, args=(author, commit_msg, branch)).start() return {"status": "accepted"}, 202 -@app.route('/gitlab_webhook', methods=['POST']) -def gitlab_webhook(): - # Protection par Token uniquement (anti-crawler gĂ©rĂ© par le secret) - received_token = request.headers.get('X-Gitlab-Token') +# Nouvelle route renommĂ©e pour la clartĂ©, accepte aussi l'ancienne au cas oĂč +@app.route('/forgejo_webhook', methods=['POST']) +@app.route('/gitlab_webhook', methods=['POST']) +def forgejo_webhook(): + # ⚡ MODIFICATION : SĂ©curitĂ© via l'en-tĂȘte Forgejo + received_token = request.headers.get('X-Gitea-Token') - # Log de debug pour voir ce que GitLab envoie vs ce qu'on attend - print(f"[DEBUG] Webhook reçu. Token attendu: '{WEBHOOK_SECRET}', Token reçu: '{received_token}'") + print(f"[DEBUG] Webhook d'Ă©vĂ©nements reçu. Token reçu: '{received_token}'") if received_token != WEBHOOK_SECRET: - abort(403) # ChangĂ© en 403 pour diffĂ©rencier une route non trouvĂ©e d'un accĂšs refusĂ© + abort(403) - # TransfĂ©rer la payload au bot Discord localement sur le port 5001 + # Relai direct de la payload de l'Ă©vĂ©nement (tickets, commentaires) vers ton bot local au port 5001 payload = request.json try: - # On tente de relayer au bot discord. Timeout lĂ©gĂšrement augmentĂ© pour plus de stabilitĂ©. - # On ne passe plus de token interne pour simplifier comme demandĂ©. requests.post(BOT_LOCAL_URL, json=payload, timeout=5) except Exception as e: print(f"[!] Erreur de relais vers le bot Discord : {e}") - # On renvoie 200 Ă  GitLab quand mĂȘme car GitLab n'a pas Ă  savoir l'Ă©tat interne return {"status": "received"}, 200 if __name__ == '__main__': - print(f"[*] Webhook opĂ©rationnel. En attente de push ou d'events...") + print(f"[*] Webhook Forgejo opĂ©rationnel sur le port 5000. PrĂȘt pour les MEP !") app.run(host='0.0.0.0', port=5000) \ No newline at end of file diff --git a/utils/forgejo_client.py b/utils/forgejo_client.py new file mode 100644 index 0000000..d66e61b --- /dev/null +++ b/utils/forgejo_client.py @@ -0,0 +1,151 @@ +import aiohttp +import os +import logging +from datetime import datetime, timedelta, timezone +from typing import Optional, List + +# Logger interne mis Ă  jour pour Forgejo +forgejo_internal_logger = logging.getLogger("ForgejoClient") +forgejo_internal_logger.setLevel(logging.INFO) + +class ForgejoClient: + def __init__(self): + self.token = os.getenv("FORGEJO_TOKEN") + self.owner = os.getenv("FORGEJO_OWNER") # Exemple: "Gameur" + self.repo = os.getenv("FORGEJO_REPO") # Exemple: "kuby" + self.assignee = os.getenv("FORGEJO_ASSIGNEE") # Nom d'utilisateur (optionnel) + + # URL de base automatique via ton Tailscale + self.base_url = os.getenv("FORGEJO_URL", "https://omegakubeserv.tail951d2f.ts.net").rstrip("/") + + # Construction de l'URL de l'API v1 standard de Forgejo/Gitea + if "api/v1" not in self.base_url: + self.api_url = f"{self.base_url}/api/v1/repos/{self.owner}/{self.repo}/issues" + else: + self.api_url = f"{self.base_url}/repos/{self.owner}/{self.repo}/issues" + + async def create_issue(self, title: str, description: str, labels: Optional[List[str]] = None) -> Optional[dict]: + """ + CrĂ©e un ticket sur Forgejo. + """ + if not self.token or not self.owner or not self.repo: + if not hasattr(self, '_config_warned'): + print("⚠ L'intĂ©gration Forgejo n'est pas configurĂ©e.") + self._config_warned = True + return None + + headers = { + "Authorization": f"token {self.token}", + "Content-Type": "application/json" + } + + # Payload au format Forgejo (JSON) + payload = { + "title": title, + "body": description, # 'description' devient 'body' + "labels": labels if labels else [] # Devient une vraie liste [] + } + + if self.assignee: + payload["assignees"] = [self.assignee] # Liste de pseudos strings + + async with aiohttp.ClientSession() as session: + try: + # Forgejo attend du JSON strict (json=payload) + async with session.post(self.api_url, headers=headers, json=payload) as response: + if response.status == 201: + result = await response.json() + # Forgejo renvoie l'URL dans 'html_url' au lieu de 'web_url' + forgejo_internal_logger.info(f"✅ Forgejo issue crĂ©Ă©e : {result.get('html_url')}") + return result + else: + error_text = await response.text() + forgejo_internal_logger.error(f"❌ Échec de la crĂ©ation : {response.status} - {error_text}") + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur de connexion Ă  l'API Forgejo : {e}") + return None + + async def find_issue_by_title(self, title: str, state: str = "open") -> Optional[dict]: + """ + Recherche un ticket par son titre exact et son Ă©tat (open/closed). + """ + if not self.token or not self.owner or not self.repo: + return None + + headers = {"Authorization": f"token {self.token}"} + # GitLab utilise 'opened', Forgejo utilise 'open' + forgejo_state = "open" if state == "opened" else state + + params = { + "q": title, + "state": forgejo_state + } + + async with aiohttp.ClientSession() as session: + try: + async with session.get(self.api_url, headers=headers, params=params) as response: + if response.status == 200: + issues = await response.json() + for issue in issues: + if issue.get("title") == title: + return issue + return None + else: + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur lors de la recherche Forgejo : {e}") + return None + + async def get_closed_issues(self) -> List[dict]: + """ + RĂ©cupĂšre les tickets rĂ©cemment fermĂ©s (depuis 24h). + """ + if not self.token or not self.owner or not self.repo: + return [] + + headers = {"Authorization": f"token {self.token}"} + # Forgejo utilise 'since' au format ISO pour filtrer par date + yesterday = (datetime.now(timezone.utc) - timedelta(days=1)).isoformat() + + params = { + "state": "closed", + "since": yesterday + } + + async with aiohttp.ClientSession() as session: + try: + async with session.get(self.api_url, headers=headers, params=params) as response: + if response.status == 200: + return await response.json() + else: + error_text = await response.text() + forgejo_internal_logger.error(f"❌ Erreur rĂ©cupĂ©ration tickets fermĂ©s : {response.status} - {error_text}") + return [] + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur connexion API Forgejo : {e}") + return [] + + async def get_issue(self, issue_number: int) -> Optional[dict]: + """ + RĂ©cupĂšre un ticket spĂ©cifique via son numĂ©ro (ID interne). + """ + if not self.token or not self.owner or not self.repo: + return None + + headers = {"Authorization": f"token {self.token}"} + url = f"{self.api_url}/{issue_number}" + + async with aiohttp.ClientSession() as session: + try: + async with session.get(url, headers=headers) as response: + if response.status == 200: + return await response.json() + else: + return None + except Exception as e: + forgejo_internal_logger.error(f"❌ Erreur connexion API Forgejo : {e}") + return None + +# Instance unique +gitlab_client = ForgejoClient() # Nom conservĂ© pour Ă©viter de rĂ©Ă©crire les imports du bot \ No newline at end of file diff --git a/utils/gitlab_client.py b/utils/gitlab_client.py deleted file mode 100644 index 40d7993..0000000 --- a/utils/gitlab_client.py +++ /dev/null @@ -1,143 +0,0 @@ -import aiohttp -import os -import logging -from datetime import datetime, timedelta -from typing import Optional, List - -# Use a separate logger to avoid infinite loops if GitLab reporting fails -gitlab_internal_logger = logging.getLogger("GitLabClient") -gitlab_internal_logger.setLevel(logging.INFO) -# We don't add handlers here, it will just log to console through hierarchy or be silent if needed - -class GitLabClient: - def __init__(self): - self.token = os.getenv("GITLAB_TOKEN") - self.project_id = os.getenv("GITLAB_PROJECT_ID") - self.assignee_id = os.getenv("GITLAB_ASSIGNEE_ID") - self.base_url = os.getenv("GITLAB_URL", "https://gitlab.com").rstrip("/") - # Ensure base_url only contains the schema and domain for the API endpoint - if "api/v4" not in self.base_url: - parts = self.base_url.split("/") - api_base = "/".join(parts[:3]) # Gets https://gitlab.com - self.api_url = f"{api_base}/api/v4/projects/{self.project_id}/issues" - else: - self.api_url = f"{self.base_url}/projects/{self.project_id}/issues" - - async def create_issue(self, title: str, description: str, labels: Optional[List[str]] = None) -> Optional[dict]: - """ - Creates an issue on GitLab. - """ - if not self.token or not self.project_id: - # Use a print or a lower level log to avoid triggering the GitLab logger itself - # which could cause an infinite loop if this were an ERROR log. - if not hasattr(self, '_config_warned'): - print("⚠ GitLab integration is not configured. GitLab issues will not be created.") - self._config_warned = True - return None - - headers = { - "PRIVATE-TOKEN": self.token - } - - data = { - "title": title, - "description": description, - "labels": ",".join(labels) if labels else "" - } - - if self.assignee_id: - data["assignee_ids"] = [self.assignee_id] - - async with aiohttp.ClientSession() as session: - try: - async with session.post(self.api_url, headers=headers, data=data) as response: - if response.status == 201: - result = await response.json() - gitlab_internal_logger.info(f"✅ GitLab issue created: {result.get('web_url')}") - return result - else: - error_text = await response.text() - gitlab_internal_logger.error(f"❌ Failed to create GitLab issue: {response.status} - {error_text}") - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return None - - async def find_issue_by_title(self, title: str, state: str = "opened") -> Optional[dict]: - """ - Searches for an issue by its exact title and state. - """ - if not self.token or not self.project_id: - return None - - headers = {"PRIVATE-TOKEN": self.token} - params = { - "search": title, - "state": state - } - - async with aiohttp.ClientSession() as session: - try: - # search param is fuzzy on GitLab, so we must double-check for exact match - async with session.get(self.api_url, headers=headers, params=params) as response: - if response.status == 200: - issues = await response.json() - for issue in issues: - if issue.get("title") == title: - return issue - return None - else: - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error searching GitLab issues: {e}") - return None - - async def get_closed_issues(self) -> List[dict]: - """ - Fetches recently closed issues. - """ - if not self.token or not self.project_id: - return [] - - headers = {"PRIVATE-TOKEN": self.token} - params = { - "state": "closed", - "updated_after": (datetime.now() - timedelta(days=1)).isoformat() - } - - async with aiohttp.ClientSession() as session: - try: - async with session.get(self.api_url, headers=headers, params=params) as response: - if response.status == 200: - return await response.json() - else: - error_text = await response.text() - gitlab_internal_logger.error(f"❌ Failed to fetch closed issues: {response.status} - {error_text}") - return [] - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return [] - - async def get_issue(self, issue_iid: int) -> Optional[dict]: - """ - Fetches a specific issue by its internal ID (IID). - """ - if not self.token or not self.project_id: - return None - - headers = {"PRIVATE-TOKEN": self.token} - url = f"{self.base_url}/api/v4/projects/{self.project_id}/issues/{issue_iid}" - - async with aiohttp.ClientSession() as session: - try: - async with session.get(url, headers=headers) as response: - if response.status == 200: - return await response.json() - else: - return None - except Exception as e: - gitlab_internal_logger.error(f"❌ Error connecting to GitLab API: {e}") - return None - -# Instance unique -gitlab_client = GitLabClient()