Create app.py

app.py

@@ -0,0 +1,234 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for
+import asyncio
+import aiohttp
+import os
+import json
+import random
+import string
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+from threading import Lock
+
+app = Flask(__name__)
+
+# Variables globales pour stocker l'état
+creation_in_progress = False
+accounts_being_created = []
+progress_counter = 0
+total_accounts = 0
+accounts_lock = Lock()
+event_loop = None
+background_task = None
+
+def create_random_username(length=8):
+    chars = string.ascii_lowercase + string.digits
+    return ''.join(random.choice(chars) for _ in range(length))
+
+def create_random_password(length=10):
+    chars = string.ascii_letters + string.digits
+    return ''.join(random.choice(chars) for _ in range(length))
+
+async def check_username_availability(session, username):
+    check_url = "https://gabaohub.alwaysdata.net/assets/functions.php"
+    data = {"ajaxCall": "isUsernameTaken", "u": username}
+    headers = {
+        "X-Forwarded-For": "41.158.0.1",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        "Referer": "https://gabaohub.alwaysdata.net/register/"
+    }
+    async with session.post(check_url, data=data, headers=headers) as response:
+        result = await response.text()
+        return result == "0"
+
+async def get_register_page(session):
+    url = "https://gabaohub.alwaysdata.net/register/"
+    headers = {
+        "X-Forwarded-For": "41.158.0.1",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
+    }
+    async with session.get(url, headers=headers) as response:
+        return await response.text()
+
+async def register_account(session, account_info):
+    register_url = "https://gabaohub.alwaysdata.net/register/register.php"
+    headers = {
+        "X-Forwarded-For": "41.158.0.1",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+        "Referer": "https://gabaohub.alwaysdata.net/register/",
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+    await get_register_page(session)
+    async with session.post(register_url, data=account_info, headers=headers, allow_redirects=True) as response:
+        text = await response.text()
+        successful_urls = ["index.php", "dashboard.php", "home", "/"]
+        success = any(url in str(response.url) for url in successful_urls) or "success" in text.lower()
+        return response, success
+
+async def create_single_account(session, account_index, semaphore):
+    global progress_counter, accounts_being_created
+
+    async with semaphore:
+        provinces_villes = {"1": ["1", "2", "3"], "2": ["7", "8"]}
+        try:
+            username = create_random_username(random.randint(6, 10))
+            retries = 0
+            available = False
+            # Retente la vérification sans délai excessif
+            while not available and retries < 3:
+                try:
+                    available = await check_username_availability(session, username)
+                    if not available:
+                        username = create_random_username(random.randint(6, 10))
+                    retries += 1
+                except Exception as e:
+                    print(f"Erreur lors de la vérification du nom d'utilisateur: {str(e)}")
+                    retries += 1
+
+            if not available:
+                with accounts_lock:
+                    accounts_being_created[account_index].update({
+                        "status": "failed",
+                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        "error": "Nom d'utilisateur indisponible"
+                    })
+                    progress_counter += 1
+                return
+
+            password = create_random_password()
+            province = random.choice(list(provinces_villes.keys()))
+            ville = random.choice(provinces_villes[province])
+            account_info = {
+                "visitorCountry": "Gabon",
+                "username": username,
+                "password": password,
+                "password2": password,
+                "province": province,
+                "ville": ville
+            }
+            with accounts_lock:
+                accounts_being_created[account_index].update(account_info)
+
+            try:
+                response, success = await register_account(session, account_info)
+                with accounts_lock:
+                    accounts_being_created[account_index].update({
+                        "status": "success" if success else "failed",
+                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    })
+                    if not success:
+                        accounts_being_created[account_index]["error"] = "Échec de l'enregistrement"
+                    progress_counter += 1
+            except Exception as e:
+                with accounts_lock:
+                    accounts_being_created[account_index].update({
+                        "status": "failed",
+                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        "error": str(e)
+                    })
+                    progress_counter += 1
+
+        except Exception as e:
+            with accounts_lock:
+                accounts_being_created[account_index].update({
+                    "status": "failed",
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "error": str(e)
+                })
+                progress_counter += 1
+
+async def create_accounts_async(num_accounts, concurrency=50):
+    global creation_in_progress, accounts_being_created, progress_counter, total_accounts
+    progress_counter = 0
+    with accounts_lock:
+        accounts_being_created = [{"status": "pending"} for _ in range(num_accounts)]
+
+    # Augmenter la limite du connecteur selon la concurrence souhaitée
+    conn = aiohttp.TCPConnector(limit=concurrency, ssl=False)
+    timeout = aiohttp.ClientTimeout(total=30)
+
+    semaphore = asyncio.Semaphore(concurrency)
+    try:
+        async with aiohttp.ClientSession(connector=conn, timeout=timeout) as session:
+            tasks = [
+                create_single_account(session, i, semaphore)
+                for i in range(num_accounts)
+            ]
+            await asyncio.gather(*tasks, return_exceptions=True)
+    except Exception as e:
+        print(f"Erreur principale pendant la création des comptes: {str(e)}")
+    finally:
+        with open("comptes_gabaohub.json", "w", encoding="utf-8") as f:
+            json.dump(accounts_being_created, f, indent=4, ensure_ascii=False)
+        creation_in_progress = False
+
+def start_background_task(num_accounts, concurrency=50):
+    global event_loop, background_task, creation_in_progress, total_accounts
+    creation_in_progress = True
+    total_accounts = num_accounts
+
+    def run_async_loop():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        global event_loop
+        event_loop = loop
+        try:
+            loop.run_until_complete(create_accounts_async(num_accounts, concurrency))
+        finally:
+            loop.close()
+
+    executor = ThreadPoolExecutor(max_workers=1)
+    background_task = executor.submit(run_async_loop)
+
+@app.route('/')
+def index():
+    accounts_data = []
+    if os.path.exists("comptes_gabaohub.json"):
+        try:
+            with open("comptes_gabaohub.json", "r", encoding="utf-8") as f:
+                accounts_data = json.load(f)
+        except json.JSONDecodeError:
+            accounts_data = []
+    return render_template('index.html', 
+                           creation_in_progress=creation_in_progress,
+                           accounts=accounts_data,
+                           progress=progress_counter,
+                           total=total_accounts)
+
+@app.route('/start', methods=['POST'])
+def start_creation():
+    global creation_in_progress
+    if not creation_in_progress:
+        # Récupère les paramètres ou forcez des valeurs pour tester de grosses requêtes
+        num_accounts = int(request.form.get('num_accounts', 5))
+        concurrency = int(request.form.get('concurrency', 5))
+        num_accounts = 1000000  # Pour tester une charge très importante
+        concurrency  = 50
+        start_background_task(num_accounts, concurrency)
+    return redirect(url_for('index'))
+
+@app.route('/progress')
+def get_progress():
+    return jsonify({
+        'creation_in_progress': creation_in_progress,
+        'progress': progress_counter,
+        'total': total_accounts,
+        'accounts': accounts_being_created
+    })
+
+@app.route('/reset', methods=['POST'])
+def reset():
+    global creation_in_progress, accounts_being_created, progress_counter, total_accounts
+    if not creation_in_progress:
+        with accounts_lock:
+            accounts_being_created = []
+            progress_counter = 0
+            total_accounts = 0
+        if os.path.exists("comptes_gabaohub.json"):
+            os.remove("comptes_gabaohub.json")
+    return redirect(url_for('index'))
+
+if __name__ == '__main__':
+    if not os.path.exists("comptes_gabaohub.json"):
+        with open("comptes_gabaohub.json", "w", encoding="utf-8") as f:
+            json.dump([], f)
+    app.run(debug=True, threaded=True)