手机上运行的网盘代码

精品源码1周前更新 小编
6 0

除了文件移动没有外，基础功能都是有的，应该没有bug吧。在Termux上运行，附带Termux的安卓安装包。
具体信息请看视频：https://b23.tv/Zm823vt
代码地址：
手机上运行的网盘代码

[Python] 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3.  

  4. import os

  5. import sys

  6. import json

  7. import asyncio

  8. import socket

  9. import hashlib

  10. import mimetypes

  11. import uuid

  12. import shutil

  13. import re

  14. import time

  15. import subprocess

  16. from datetime import datetime, timedelta

  17. from pathlib import Path

  18. from urllib.parse import unquote, quote

  19. from typing import Dict, List, Optional, Tuple

  20.  

  21. # -------------------- 自动安装依赖 --------------------

  22. def ensure_dependencies():

  23.     required = {

  24.         'aiohttp': 'aiohttp',

  25.         'aiofiles': 'aiofiles',

  26.         'aiosqlite': 'aiosqlite',

  27.         'netifaces': 'netifaces',

  28.     }

  29.     for module, package in required.items():

  30.         try:

  31.             __import__(module)

  32.         except ImportError:

  33.             print(f"[*] 缺少依赖: {package}，正在安装...")

  34.             try:

  35.                 subprocess.check_call(

  36.                     [sys.executable, "-m", "pip", "install", package]

  37.                 )

  38.                 print(f"[+] {package} 安装成功")

  39.             except Exception as e:

  40.                 print(f"[-] 安装失败: {e}，请手动安装 {package}")

  41.                 sys.exit(1)

  42.  

  43. ensure_dependencies()

  44.  

  45. import aiohttp

  46. from aiohttp import web

  47. try:

  48.     from aiohttp.client_exceptions import ClientDisconnectedError

  49. except ImportError:

  50.     try:

  51.         from aiohttp import ClientDisconnectedError

  52.     except ImportError:

  53.         from aiohttp import ClientError as ClientDisconnectedError

  54. import aiofiles

  55. import aiofiles.os

  56. import aiosqlite

  57.  

  58. mimetypes.init()

  59.  

  60.  

  61. # -------------------- 日志记录器 --------------------

  62. class Logger:

  63.     def __init__(self, log_file='cloud_drive.log'):

  64.         self.log_file = log_file

  65.         log_dir = os.path.dirname(log_file)

  66.         if log_dir and not os.path.exists(log_dir):

  67.             os.makedirs(log_dir, exist_ok=True)

  68.         self._write_startup_marker()

  69.         self.download_requests: Dict[str, set] = {}

  70.  

  71.     def _write_startup_marker(self):

  72.         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

  73.         marker = f"\n{'='*60}\n程序启动时间: {timestamp}\n{'='*60}\n"

  74.         try:

  75.             with open(self.log_file, 'a', encoding='utf-8') as f:

  76.                 f.write(marker)

  77.         except Exception:

  78.             pass

  79.  

  80.     def _log(self, ip: str, user: str, action: str, details: str = "", status: str = ""):

  81.         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

  82.         parts = [f"[{timestamp}]"]

  83.         if ip:

  84.             parts.append(ip)

  85.         if user:

  86.             parts.append(f"{user} -")

  87.         parts.append(action)

  88.         if details:

  89.             parts.append(details)

  90.         if status:

  91.             parts.append(f"状态{status}")

  92.         log_entry = " ".join(parts)

  93.         print(log_entry)

  94.         try:

  95.             with open(self.log_file, 'a', encoding='utf-8') as f:

  96.                 f.write(log_entry + "\n")

  97.         except Exception:

  98.             pass

  99.  

  100.     def log_access(self, ip, user, path, status):

  101.         if not path:

  102.             path = "/"

  103.         action = "访问成功"

  104.         details = path if path != "/" else "/"

  105.         self._log(ip, user, action, details, str(status))

  106.  

  107.     def log_download(self, ip, user, path, force_download, status, is_range_request=False, request_id=None):

  108.         if is_range_request:

  109.             return

  110.         key = f"{user}:{path}"

  111.         if request_id:

  112.             if key not in self.download_requests:

  113.                 self.download_requests[key] = set()

  114.             if request_id in self.download_requests[key]:

  115.                 return

  116.             self.download_requests[key].add(request_id)

  117.         download_type = "下载" if force_download else "预览"

  118.         action = "文件下载"

  119.         details = f"{path} ({download_type})"

  120.         self._log(ip, user, action, details, str(status))

  121.  

  122.     def log_upload(self, ip, user, file_count, path="", status=200):

  123.         action = "文件上传"

  124.         details = f"{file_count} 个文件"

  125.         if path:

  126.             details += f" {path}"

  127.         self._log(ip, user, action, details, str(status))

  128.  

  129.     def log_create_folder(self, ip, user, path, status=200):

  130.         self._log(ip, user, "创建文件夹成功", path, str(status))

  131.  

  132.     def log_rename(self, ip, user, old_path, new_name, status=200):

  133.         self._log(ip, user, "重命名成功", f"{old_path} -> {new_name}", str(status))

  134.  

  135.     def log_delete(self, ip, user, path, status=200):

  136.         self._log(ip, user, "删除成功", path, str(status))

  137.  

  138.     def log_server_event(self, msg):

  139.         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

  140.         entry = f"[{timestamp}] {msg}"

  141.         print(entry)

  142.         try:

  143.             with open(self.log_file, 'a', encoding='utf-8') as f:

  144.                 f.write(entry + "\n")

  145.         except Exception:

  146.             pass

  147.  

  148.     def log_error(self, ip="", user="", action="", details="", error="", is_range_request=False):

  149.         if is_range_request and error in ["Cannot write to closing transport", "Connection lost"]:

  150.             return

  151.         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

  152.         parts = [f"[{timestamp}]"]

  153.         if ip:

  154.             parts.append(ip)

  155.         if user:

  156.             parts.append(f"{user} -")

  157.         if action:

  158.             parts.append(f"{action}失败")

  159.         if details:

  160.             parts.append(details)

  161.         if error:

  162.             parts.append(f"错误: {error}")

  163.         entry = " ".join(parts)

  164.         print(entry)

  165.         try:

  166.             with open(self.log_file, 'a', encoding='utf-8') as f:

  167.                 f.write(entry + "\n")

  168.         except Exception:

  169.             pass

  170.  

  171.     def log_login_failed(self, ip, username, reason=""):

  172.         self._log(ip, "游客", "登录失败", f"用户名: {username} {reason}".strip(), "401")

  173.  

  174.     def log_register_success(self, ip, username):

  175.         self._log(ip, "游客", "注册成功", f"新用户: {username}", "200")

  176.  

  177.     def log_delete_user_success(self, ip, username, user_id):

  178.         self._log(ip, username, "删除用户成功", f"用户: {username} (ID: {user_id})", "200")

  179.  

  180.     def log_visitor_login_page(self, ip):

  181.         self._log(ip, "游客", "访问登录页面")

  182.  

  183.     def log_visitor_register_page(self, ip):

  184.         self._log(ip, "游客", "访问注册页面")

  185.  

  186.     def clear_download_cache(self):

  187.         if len(self.download_requests) > 1000:

  188.             keys = list(self.download_requests.keys())

  189.             for key in keys[:500]:

  190.                 del self.download_requests[key]

  191.  

  192.  

  193. # -------------------- 云盘服务器 --------------------

  194. class CloudDriveServer:

  195.     def __init__(self, config: dict):

  196.         self.port = config.get('port', 8000)

  197.         self.allow_register = config.get('allow_register', True)

  198.         self.base_dir = Path(__file__).parent.resolve()

  199.         self.uploads_dir = self.base_dir / 'uploads'

  200.         self.db_path = self.base_dir / 'cloud_drive.db'

  201.         self.logger = Logger()

  202.         self.active_connections = set()

  203.         self.is_running = False

  204.         self.site = None

  205.         self.runner = None

  206.         self.app = None

  207.         self.uploads_dir.mkdir(exist_ok=True)

  208.  

  209.     # ---------- 工具方法 ----------

  210.     def hash_password(self, password: str, salt: bytes = None) -> Tuple[str, str]:

  211.         if salt is None:

  212.             salt = hashlib.sha256(os.urandom(60)).digest()

  213.         pwdhash = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)

  214.         return pwdhash.hex(), salt.hex()

  215.  

  216.     def normalize_path(self, path: str) -> str:

  217.         if not path:

  218.             return ''

  219.         path = path.replace('\\', '/')

  220.         path = re.sub(r'/+', '/', path)

  221.         if path.startswith('/'):

  222.             path = path[1:]

  223.         return path.rstrip('/')

  224.  

  225.     def sanitize_path(self, path: str) -> str:

  226.         if not path:

  227.             return path

  228.         cleaned = re.sub(r'[\x00-\x1f\x7f]', '', path)

  229.         cleaned = re.sub(r'[<>:"|?*]', '', cleaned)

  230.         cleaned = re.sub(r'[/\\]{2,}', '/', cleaned)

  231.         cleaned = re.sub(r'\.{2,}', '.', cleaned)

  232.         cleaned = cleaned.strip(' .')

  233.         return cleaned

  234.  

  235.     def preprocess_path(self, raw_path: str) -> str:

  236.         if not raw_path:

  237.             return ''

  238.         try:

  239.             decoded = unquote(raw_path)

  240.         except Exception:

  241.             decoded = raw_path

  242.         normalized = self.normalize_path(decoded)

  243.         cleaned = self.sanitize_path(normalized)

  244.         return cleaned

  245.  

  246.     def is_safe_path(self, base_path: Path, target_path: str) -> Tuple[bool, str]:

  247.         try:

  248.             base = base_path.absolute()

  249.             processed = self.preprocess_path(target_path)

  250.             target = (base / processed).resolve() if processed else base

  251.             safe = target.is_relative_to(base)

  252.             if not safe:

  253.                 self.logger.log_error(action="路径安全检查", details=f"越权: {target_path}")

  254.             return safe, processed

  255.         except Exception as e:

  256.             self.logger.log_error(action="路径安全检查", error=str(e))

  257.             return False, ""

  258.  

  259.     def format_file_size(self, size_bytes: int) -> str:

  260.         if size_bytes == 0:

  261.             return "0 B"

  262.         units = ['B', 'KB', 'MB', 'GB', 'TB']

  263.         unit_index = 0

  264.         while size_bytes >= 1024 and unit_index < len(units) - 1:

  265.             size_bytes /= 1024.0

  266.             unit_index += 1

  267.         if unit_index == 0:

  268.             return f"{int(size_bytes)} {units[unit_index]}"

  269.         else:

  270.             return f"{size_bytes:.1f} {units[unit_index]}"

  271.  

  272.     def get_user_dir(self, username: str) -> Path:

  273.         return self.uploads_dir / username

  274.  

  275.     def read_template(self, template_name: str, context: Dict = None) -> str:

  276.         template_path = self.base_dir / 'templates' / template_name

  277.         try:

  278.             with open(template_path, 'r', encoding='utf-8') as f:

  279.                 content = f.read()

  280.             if context:

  281.                 for key, value in context.items():

  282.                     content = content.replace(f'{{{{ {key} }}}}', str(value))

  283.             return content

  284.         except Exception as e:

  285.             self.logger.log_error(action="读取模板", details=template_name, error=str(e))

  286.             return ''

  287.  

  288.     # -------------------- 网络地址获取 --------------------

  289.     @staticmethod

  290.     def _get_ipv4_by_udp():

  291.         try:

  292.             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

  293.             s.settimeout(1)

  294.             s.connect(('8.8.8.8', 80))

  295.             ip = s.getsockname()[0]

  296.             s.close()

  297.             return ip

  298.         except Exception:

  299.             return None

  300.  

  301.     @staticmethod

  302.     def _get_ipv6_by_udp():

  303.         try:

  304.             s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)

  305.             s.settimeout(1)

  306.             s.connect(('2001:4860:4860::8888', 80))

  307.             ip = s.getsockname()[0]

  308.             s.close()

  309.             if ip == '::1' or ip.startswith('fe80:'):

  310.                 return None

  311.             return ip

  312.         except Exception:

  313.             return None

  314.  

  315.     @staticmethod

  316.     def _get_all_ipv6_from_proc():

  317.         ipv6s = set()

  318.         proc_path = '/proc/net/if_inet6'

  319.         if not os.path.isfile(proc_path):

  320.             return ipv6s

  321.         try:

  322.             with open(proc_path, 'r') as f:

  323.                 for line in f:

  324.                     parts = line.strip().split()

  325.                     if len(parts) < 1:

  326.                         continue

  327.                     hex_str = parts[0]

  328.                     ipv6 = ':'.join(hex_str[i:i+4] for i in range(0, 32, 4))

  329.                     if ipv6 == '::1' or ipv6.startswith('fe80:'):

  330.                         continue

  331.                     ipv6s.add(ipv6)

  332.         except Exception:

  333.             pass

  334.         return ipv6s

  335.  

  336.     @staticmethod

  337.     def _get_all_ipv6_via_command():

  338.         ipv6s = set()

  339.         try:

  340.             result = subprocess.run(['ip', '-6', 'addr', 'show'], capture_output=True, text=True, timeout=5)

  341.             if result.returncode != 0:

  342.                 result = subprocess.run(['ip', 'addr', 'show'], capture_output=True, text=True, timeout=5)

  343.             output = result.stdout

  344.         except Exception:

  345.             try:

  346.                 result = subprocess.run(['ifconfig'], capture_output=True, text=True, timeout=5)

  347.                 output = result.stdout

  348.             except Exception:

  349.                 output = ""

  350.         if output:

  351.             for line in output.splitlines():

  352.                 if 'inet6' not in line:

  353.                     continue

  354.                 m = re.search(r'inet6\s+([0-9a-fA-F:]+)', line)

  355.                 if not m:

  356.                     continue

  357.                 ip = m.group(1).split('/')[0]

  358.                 if (ip == '::1' or ip.startswith('fe80:') or

  359.                     ip.startswith('ff') or ip.startswith('::ffff:')):

  360.                     continue

  361.                 if 'scope host' in line or 'scope link' in line:

  362.                     continue

  363.                 ipv6s.add(ip)

  364.         return ipv6s

  365.  

  366.     @staticmethod

  367.     def _get_all_ipv6_via_netifaces():

  368.         ipv6s = set()

  369.         try:

  370.             import netifaces

  371.             for interface in netifaces.interfaces():

  372.                 addrs = netifaces.ifaddresses(interface).get(netifaces.AF_INET6, [])

  373.                 for addr_info in addrs:

  374.                     ip = addr_info.get('addr', '')

  375.                     if not ip:

  376.                         continue

  377.                     if (ip == '::1' or ip.startswith('fe80:') or

  378.                         ip.startswith('ff') or ip.startswith('::ffff:')):

  379.                         continue

  380.                     ipv6s.add(ip)

  381.         except ImportError:

  382.             pass

  383.         except Exception:

  384.             pass

  385.         return ipv6s

  386.  

  387.     def get_network_addresses(self):

  388.         ipv4_set = set()

  389.         ipv6_set = set()

  390.  

  391.         # IPv4

  392.         udp_ip = self._get_ipv4_by_udp()

  393.         if udp_ip and not udp_ip.startswith('127.'):

  394.             ipv4_set.add(udp_ip)

  395.         try:

  396.             result = subprocess.run(['ip', 'addr', 'show'], capture_output=True, text=True, timeout=5)

  397.             if result.returncode != 0:

  398.                 result = subprocess.run(['ifconfig'], capture_output=True, text=True, timeout=5)

  399.             output = result.stdout

  400.         except Exception:

  401.             try:

  402.                 result = subprocess.run(['ifconfig'], capture_output=True, text=True, timeout=5)

  403.                 output = result.stdout

  404.             except Exception:

  405.                 output = ""

  406.         for m in re.finditer(r'inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)', output):

  407.             ip = m.group(1)

  408.             if not ip.startswith('127.'):

  409.                 ipv4_set.add(ip)

  410.         if not ipv4_set:

  411.             try:

  412.                 hostname = socket.gethostname()

  413.                 for addr in socket.gethostbyname_ex(hostname)[2]:

  414.                     if not addr.startswith('127.'):

  415.                         ipv4_set.add(addr)

  416.             except:

  417.                 pass

  418.  

  419.         # IPv6

  420.         udp_ipv6 = self._get_ipv6_by_udp()

  421.         if udp_ipv6:

  422.             ipv6_set.add(udp_ipv6)

  423.         ipv6_set |= self._get_all_ipv6_from_proc()

  424.         ipv6_set |= self._get_all_ipv6_via_command()

  425.         ipv6_set |= self._get_all_ipv6_via_netifaces()

  426.         try:

  427.             hostname = socket.gethostname()

  428.             for info in socket.getaddrinfo(hostname, None, socket.AF_INET6):

  429.                 ip = info[4][0]

  430.                 if (ip == '::1' or ip.startswith('fe80:') or

  431.                     ip.startswith('ff') or ip.startswith('::ffff:')):

  432.                     continue

  433.                 ipv6_set.add(ip)

  434.         except:

  435.             pass

  436.  

  437.         ipv4_list = sorted(list(ipv4_set), key=lambda x: [int(n) for n in x.split('.')])

  438.         ipv6_list = sorted(list(ipv6_set))

  439.         return ipv4_list, ipv6_list

  440.  

  441.     # ---------- 数据库操作 ----------

  442.     async def init_db(self):

  443.         async with aiosqlite.connect(self.db_path) as db:

  444.             await db.execute('''

  445.                 CREATE TABLE IF NOT EXISTS users (

  446.                     id INTEGER PRIMARY KEY AUTOINCREMENT,

  447.                     username TEXT UNIQUE NOT NULL,

  448.                     password_hash TEXT NOT NULL,

  449.                     salt TEXT NOT NULL,

  450.                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

  451.                     storage_used INTEGER DEFAULT 0

  452.                 )

  453.             ''')

  454.             await db.execute('''

  455.                 CREATE TABLE IF NOT EXISTS sessions (

  456.                     session_id TEXT PRIMARY KEY,

  457.                     user_id INTEGER NOT NULL,

  458.                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

  459.                     expires_at TIMESTAMP NOT NULL,

  460.                     FOREIGN KEY (user_id) REFERENCES users (id)

  461.                 )

  462.             ''')

  463.             await db.commit()

  464.         self.logger.log_server_event("数据库初始化完成")

  465.  

  466.     async def get_user_info(self, user_id: int) -> Optional[Dict]:

  467.         async with aiosqlite.connect(self.db_path) as db:

  468.             cursor = await db.execute(

  469.                 'SELECT username, storage_used FROM users WHERE id = ?', (user_id,)

  470.             )

  471.             result = await cursor.fetchone()

  472.             if result:

  473.                 username, used = result

  474.                 return {

  475.                     'username': username,

  476.                     'used': used,

  477.                     'used_formatted': self.format_file_size(used),

  478.                     'percentage': min(100, (used / (1024**3)) * 100) if used > 0 else 0

  479.                 }

  480.         return None

  481.  

  482.     async def verify_user(self, username: str, password: str) -> Optional[int]:

  483.         async with aiosqlite.connect(self.db_path) as db:

  484.             cursor = await db.execute(

  485.                 'SELECT id, password_hash, salt FROM users WHERE username = ?', (username,)

  486.             )

  487.             user = await cursor.fetchone()

  488.             if user:

  489.                 user_id, stored_hash, salt = user

  490.                 hashed, _ = self.hash_password(password, bytes.fromhex(salt))

  491.                 if hashed == stored_hash:

  492.                     return user_id

  493.         return None

  494.  

  495.     async def create_user(self, username: str, password: str) -> bool:

  496.         if not self.allow_register:

  497.             return False

  498.         try:

  499.             password_hash, salt = self.hash_password(password)

  500.             async with aiosqlite.connect(self.db_path) as db:

  501.                 cursor = await db.execute('SELECT id FROM users WHERE username = ?', (username,))

  502.                 if await cursor.fetchone():

  503.                     return False

  504.                 await db.execute(

  505.                     'INSERT INTO users (username, password_hash, salt) VALUES (?, ?, ?)',

  506.                     (username, password_hash, salt)

  507.                 )

  508.                 user_dir = self.get_user_dir(username)

  509.                 await aiofiles.os.makedirs(str(user_dir), exist_ok=True)

  510.                 await db.commit()

  511.                 return True

  512.         except Exception as e:

  513.             self.logger.log_error(action="创建用户", error=str(e))

  514.             return False

  515.  

  516.     async def create_session(self, user_id: int) -> str:

  517.         session_id = str(uuid.uuid4())

  518.         expires_at = datetime.now() + timedelta(days=1)

  519.         async with aiosqlite.connect(self.db_path) as db:

  520.             await db.execute(

  521.                 'INSERT INTO sessions (session_id, user_id, expires_at) VALUES (?, ?, ?)',

  522.                 (session_id, user_id, expires_at)

  523.             )

  524.             await db.commit()

  525.         return session_id

  526.  

  527.     async def validate_session(self, session_id: str) -> Optional[int]:

  528.         async with aiosqlite.connect(self.db_path) as db:

  529.             cursor = await db.execute(

  530.                 'SELECT user_id FROM sessions WHERE session_id = ? AND expires_at > ?',

  531.                 (session_id, datetime.now())

  532.             )

  533.             result = await cursor.fetchone()

  534.             return result[0] if result else None

  535.  

  536.     async def delete_session(self, session_id: str):

  537.         async with aiosqlite.connect(self.db_path) as db:

  538.             await db.execute('DELETE FROM sessions WHERE session_id = ?', (session_id,))

  539.             await db.commit()

  540.  

  541.     async def delete_user(self, user_id: int):

  542.         async with aiosqlite.connect(self.db_path) as db:

  543.             cursor = await db.execute('SELECT username FROM users WHERE id = ?', (user_id,))

  544.             result = await cursor.fetchone()

  545.             if not result:

  546.                 return

  547.             username = result[0]

  548.             user_dir = self.get_user_dir(username)

  549.             if user_dir.exists():

  550.                 try:

  551.                     shutil.rmtree(str(user_dir))

  552.                 except Exception as e:

  553.                     self.logger.log_error(action="删除用户目录", error=str(e))

  554.             self.logger.log_delete_user_success("127.0.0.1", username, user_id)

  555.             await db.execute('DELETE FROM users WHERE id = ?', (user_id,))

  556.             await db.execute('DELETE FROM sessions WHERE user_id = ?', (user_id,))

  557.             await db.commit()

  558.  

  559.     # ---------- 网络请求处理 ----------

  560.     async def check_auth(self, request):

  561.         session_id = request.cookies.get('session_id')

  562.         if not session_id:

  563.             return None

  564.         user_id = await self.validate_session(session_id)

  565.         if not user_id:

  566.             return None

  567.         async with aiosqlite.connect(self.db_path) as db:

  568.             expires_at = datetime.now() + timedelta(days=1)

  569.             await db.execute(

  570.                 'UPDATE sessions SET expires_at = ? WHERE session_id = ?',

  571.                 (expires_at, session_id)

  572.             )

  573.             await db.commit()

  574.         return user_id

  575.  

  576.     async def handle_index(self, request):

  577.         session_id = request.cookies.get('session_id')

  578.         if session_id and await self.validate_session(session_id):

  579.             return web.HTTPFound('/cloud')

  580.         return web.HTTPFound('/login')

  581.  

  582.     async def handle_login(self, request):

  583.         client_ip = request.remote

  584.         if request.method == 'GET':

  585.             self.logger.log_visitor_login_page(client_ip)

  586.             html = self.read_template('login.html')

  587.             if not html:

  588.                 return web.Response(text='模板缺失', status=500)

  589.             return web.Response(text=html, content_type='text/html')

  590.  

  591.         data = await request.post()

  592.         username = data.get('username', '').strip()

  593.         password = data.get('password', '').strip()

  594.         if not username or not password:

  595.             self.logger.log_login_failed(client_ip, username, "用户名或密码为空")

  596.             html = self.read_template('login.html', {'error': '用户名或密码不能为空'})

  597.             return web.Response(text=html, content_type='text/html')

  598.  

  599.         user_id = await self.verify_user(username, password)

  600.         if user_id:

  601.             session_id = await self.create_session(user_id)

  602.             resp = web.HTTPFound('/cloud')

  603.             resp.set_cookie('session_id', session_id, httponly=True, max_age=86400)

  604.             self.logger.log_access(client_ip, username, '/', 200)

  605.             return resp

  606.         else:

  607.             self.logger.log_login_failed(client_ip, username, "密码错误")

  608.             html = self.read_template('login.html', {'error': '用户名或密码错误'})

  609.             return web.Response(text=html, content_type='text/html')

  610.  

  611.     async def handle_register(self, request):

  612.         client_ip = request.remote

  613.         if request.method == 'GET':

  614.             self.logger.log_visitor_register_page(client_ip)

  615.             if not self.allow_register:

  616.                 html = '''

  617.                 <!DOCTYPE html>

  618.                 <html><head><meta charset="UTF-8"><title>注册关闭</title>

  619.                 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">

  620.                 <style>.error-container{max-width:500px;margin:100px auto;padding:40px;text-align:center;}

  621.                 .error-icon{font-size:64px;color:#dc3545;margin-bottom:20px;}

  622.                 .error-title{font-size:24px;color:#333;margin-bottom:15px;}

  623.                 .error-message{color:#666;margin-bottom:30px;}

  624.                 .error-back-link{color:#007bff;text-decoration:none;}

  625.                 </style></head><body class="bg-gray-100">

  626.                 <div class="error-container"><div class="error-icon"><i class="fas fa-lock"></i></div>

  627.                 <h1 class="error-title">注册功能已关闭</h1>

  628.                 <p class="error-message">请联系管理员获取权限</p>

  629.                 <a href="/" class="error-back-link"><i class="fas fa-arrow-left"></i>返回登录</a></div>

  630.                 </body></html>'''

  631.                 return web.Response(text=html, content_type='text/html')

  632.             return web.Response(text=self.read_template('register.html'), content_type='text/html')

  633.  

  634.         data = await request.post()

  635.         username = data.get('username', '').strip()

  636.         password = data.get('password', '').strip()

  637.         if not username or not password:

  638.             return web.Response(text=self.read_template('register.html', {'error': '用户名或密码不能为空'}), content_type='text/html')

  639.         if len(username) < 3 or len(username) > 20:

  640.             return web.Response(text=self.read_template('register.html', {'error': '用户名长度3-20字符'}), content_type='text/html')

  641.  

  642.         success = await self.create_user(username, password)

  643.         if success:

  644.             user_id = await self.verify_user(username, password)

  645.             session_id = await self.create_session(user_id)

  646.             resp = web.HTTPFound('/cloud')

  647.             resp.set_cookie('session_id', session_id, httponly=True, max_age=86400)

  648.             self.logger.log_register_success(client_ip, username)

  649.             return resp

  650.         else:

  651.             return web.Response(text=self.read_template('register.html', {'error': '用户名已存在'}), content_type='text/html')

  652.  

  653.     async def handle_logout(self, request):

  654.         session_id = request.cookies.get('session_id')

  655.         if session_id:

  656.             await self.delete_session(session_id)

  657.         resp = web.HTTPFound('/login')

  658.         resp.del_cookie('session_id')

  659.         return resp

  660.  

  661.     async def handle_cloud(self, request):

  662.         user_id = await self.check_auth(request)

  663.         if not user_id:

  664.             return web.HTTPFound('/login')

  665.         user_info = await self.get_user_info(user_id)

  666.         if not user_info:

  667.             return web.HTTPFound('/logout')

  668.  

  669.         path_param = request.query.get('path', '')

  670.         search_query = request.query.get('q', '')

  671.         current_path = self.normalize_path(path_param)

  672.         user_dir = self.get_user_dir(user_info['username'])

  673.  

  674.         if current_path and not self.is_safe_path(user_dir, current_path):

  675.             return web.Response(text='路径不安全', status=403)

  676.  

  677.         current_dir = user_dir / current_path if current_path else user_dir

  678.         items = []

  679.  

  680.         if search_query:

  681.             search_query = search_query.lower()

  682.             for root, dirs, files in os.walk(str(user_dir)):

  683.                 rel_root = Path(root).relative_to(user_dir)

  684.                 rel_root_posix = rel_root.as_posix() if str(rel_root) != '.' else ''

  685.                 for d in dirs:

  686.                     if search_query in d.lower():

  687.                         dir_path = rel_root / d

  688.                         try:

  689.                             stat = (user_dir / dir_path).stat()

  690.                             items.append({

  691.                                 'name': d,

  692.                                 'path': dir_path.as_posix(),

  693.                                 'is_dir': True,

  694.                                 'size': '-',

  695.                                 'mtime': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M'),

  696.                                 'search_result': True,

  697.                                 'dir_path': rel_root_posix

  698.                             })

  699.                         except: pass

  700.                 for f in files:

  701.                     if search_query in f.lower():

  702.                         file_path = rel_root / f

  703.                         try:

  704.                             stat = (user_dir / file_path).stat()

  705.                             items.append({

  706.                                 'name': f,

  707.                                 'path': file_path.as_posix(),

  708.                                 'is_dir': False,

  709.                                 'size': self.format_file_size(stat.st_size),

  710.                                 'mtime': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M'),

  711.                                 'search_result': True,

  712.                                 'dir_path': rel_root_posix

  713.                             })

  714.                         except: pass

  715.         else:

  716.             try:

  717.                 if current_dir.exists() and current_dir.is_dir():

  718.                     for item in current_dir.iterdir():

  719.                         try:

  720.                             stat = item.stat()

  721.                             rel = item.relative_to(user_dir)

  722.                             if item.is_dir():

  723.                                 items.append({

  724.                                     'name': item.name,

  725.                                     'path': rel.as_posix(),

  726.                                     'is_dir': True,

  727.                                     'size': '-',

  728.                                     'mtime': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M')

  729.                                 })

  730.                             else:

  731.                                 items.append({

  732.                                     'name': item.name,

  733.                                     'path': rel.as_posix(),

  734.                                     'is_dir': False,

  735.                                     'size': self.format_file_size(stat.st_size),

  736.                                     'mtime': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M')

  737.                                 })

  738.                         except: pass

  739.             except Exception as e:

  740.                 self.logger.log_error(action="读取目录", error=str(e))

  741.  

  742.         items.sort(key=lambda x: (not x['is_dir'], x['name'].lower()))

  743.  

  744.         breadcrumbs = [('根目录', '')]

  745.         if current_path:

  746.             parts = current_path.split('/')

  747.             current = ''

  748.             for part in parts:

  749.                 if part:

  750.                     current += f'{part}/'

  751.                     breadcrumbs.append((part, current.rstrip('/')))

  752.  

  753.         def make_breadcrumbs_html(bcs):

  754.             html = []

  755.             for i, (name, path) in enumerate(bcs):

  756.                 if i > 0:

  757.                     html.append('<li class="separator"><i class="fas fa-chevron-right"></i></li>')

  758.                 if i == len(bcs) - 1:

  759.                     html.append(f'<li><span>{name}</span></li>')

  760.                 else:

  761.                     html.append(f'<li><a href="/cloud?path={quote(path)}">{name}</a></li>')

  762.             return ''.join(html)

  763.  

  764.         def make_file_list_html(items):

  765.             if not items:

  766.                 return '<div class="empty-state"><i class="fas fa-folder-open"></i><h3>文件夹为空</h3></div>'

  767.             html = ['<ul class="file-list">']

  768.             for item in items:

  769.                 url_path = quote(item['path'])

  770.                 raw_path = item['path'].replace("'", "\\'")

  771.                 name_escaped = item['name'].replace("'", "\\'")

  772.                 icon = 'fa-folder' if item['is_dir'] else 'fa-file'

  773.                 link = f'/cloud?path={url_path}' if item['is_dir'] else f'/download/{url_path}'

  774.                 html.append(f'<li class="file-item">')

  775.                 html.append(f'<div class="file-icon"><i class="fas {icon}"></i></div>')

  776.                 html.append(f'<div class="file-info"><div class="file-name"><a href="{link}">{item["name"]}</a></div>')

  777.                 html.append(f'<div class="file-meta"><div class="file-size">{item["size"]}</div><div class="file-time">{item["mtime"]}</div></div></div>')

  778.                 html.append(f'<div class="file-actions">')

  779.                 if not item['is_dir']:

  780.                     html.append(f'<button class="file-action-btn download-btn" onclick="downloadFile(\'{url_path}\')"><i class="fas fa-download"></i></button>')

  781.                 html.append(f'<button class="file-action-btn rename-btn" onclick="showRenameModal(\'{raw_path}\', \'{name_escaped}\')"><i class="fas fa-edit"></i></button>')

  782.                 html.append(f'<button class="file-action-btn delete-btn" onclick="showDeleteConfirm(\'{raw_path}\', \'{name_escaped}\')"><i class="fas fa-trash-alt"></i></button>')

  783.                 html.append('</div></li>')

  784.             html.append('</ul>')

  785.             return ''.join(html)

  786.  

  787.         context = {

  788.             'username': user_info['username'],

  789.             'current_path': current_path,

  790.             'search_query': search_query,

  791.             'used_formatted': user_info['used_formatted'],

  792.             'percentage': user_info['percentage'],

  793.             'breadcrumbs_html': make_breadcrumbs_html(breadcrumbs),

  794.             'file_list_html': make_file_list_html(items)

  795.         }

  796.  

  797.         html = self.read_template('cloud.html', context)

  798.         if not html:

  799.             return web.Response(text='模板缺失', status=500)

  800.  

  801.         self.logger.log_access(request.remote, user_info['username'], f'/{current_path}' if current_path else '/', 200)

  802.         return web.Response(text=html, content_type='text/html')

  803.  

  804.     # -------------------- 文件操作接口 --------------------

  805.     async def handle_download(self, request):

  806.         user_id = await self.check_auth(request)

  807.         if not user_id:

  808.             return web.Response(text='未授权', status=401)

  809.         user_info = await self.get_user_info(user_id)

  810.         if not user_info:

  811.             return web.Response(text='用户不存在', status=404)

  812.  

  813.         filepath = unquote(request.match_info['path'])

  814.         user_dir = self.get_user_dir(user_info['username'])

  815.         file_path = user_dir / filepath

  816.         safe, _ = self.is_safe_path(user_dir, filepath)

  817.         if not safe or not file_path.exists() or not file_path.is_file():

  818.             return web.Response(text='文件不存在', status=404)

  819.  

  820.         force_download = request.query.get('force', '').lower() == 'true'

  821.         file_size = file_path.stat().st_size

  822.         mime_type, _ = mimetypes.guess_type(str(file_path))

  823.         mime_type = mime_type or 'application/octet-stream'

  824.  

  825.         client_ip = request.remote

  826.         range_header = request.headers.get('Range')

  827.         is_range_request = range_header is not None

  828.         request_id = f"{client_ip}:{filepath}:{int(time.time())}"

  829.  

  830.         try:

  831.             response = web.StreamResponse()

  832.             if force_download:

  833.                 filename = file_path.name

  834.                 import urllib.parse

  835.                 encoded_filename = urllib.parse.quote(filename, encoding='utf-8')

  836.                 response.headers['Content-Disposition'] = f'attachment; filename="{encoded_filename}"'

  837.                 response.headers['Content-Type'] = 'application/octet-stream'

  838.             else:

  839.                 response.headers['Content-Type'] = mime_type

  840.             response.headers['Accept-Ranges'] = 'bytes'

  841.  

  842.             if range_header:

  843.                 match = re.match(r'bytes=(\d+)-(\d*)', range_header)

  844.                 if match:

  845.                     start = int(match.group(1))

  846.                     end = int(match.group(2)) if match.group(2) else file_size - 1

  847.                     if start >= file_size or end >= file_size or start > end:

  848.                         return web.Response(status=416)

  849.                     response.set_status(206)

  850.                     response.headers['Content-Range'] = f'bytes {start}-{end}/{file_size}'

  851.                     response.headers['Content-Length'] = str(end - start + 1)

  852.                     await response.prepare(request)

  853.                     chunk_size = 64 * 1024

  854.                     async with aiofiles.open(str(file_path), 'rb') as f:

  855.                         await f.seek(start)

  856.                         remain = end - start + 1

  857.                         while remain > 0:

  858.                             chunk = await f.read(min(chunk_size, remain))

  859.                             if not chunk:

  860.                                 break

  861.                             try:

  862.                                 await response.write(chunk)

  863.                             except (ClientDisconnectedError, ConnectionResetError, asyncio.CancelledError, ConnectionError):

  864.                                 return response

  865.                             remain -= len(chunk)

  866.                     await response.write_eof()

  867.                     return response

  868.  

  869.             response.headers['Content-Length'] = str(file_size)

  870.             await response.prepare(request)

  871.             self.logger.log_download(client_ip, user_info['username'], filepath, force_download, 200, is_range_request, request_id)

  872.  

  873.             chunk_size = 64 * 1024

  874.             async with aiofiles.open(str(file_path), 'rb') as f:

  875.                 while True:

  876.                     chunk = await f.read(chunk_size)

  877.                     if not chunk:

  878.                         break

  879.                     try:

  880.                         await response.write(chunk)

  881.                     except (ClientDisconnectedError, ConnectionResetError, asyncio.CancelledError, ConnectionError):

  882.                         return response

  883.             await response.write_eof()

  884.             return response

  885.  

  886.         except (ClientDisconnectedError, ConnectionResetError, asyncio.CancelledError, ConnectionError):

  887.             return web.Response(status=204)

  888.         except Exception as e:

  889.             self.logger.log_error(client_ip, user_info['username'], "文件下载", filepath, str(e), is_range_request)

  890.             return web.Response(text='下载失败', status=500)

  891.  

  892.     async def handle_upload(self, request):

  893.         user_id = await self.check_auth(request)

  894.         if not user_id:

  895.             return web.Response(text='未授权', status=401)

  896.         user_info = await self.get_user_info(user_id)

  897.         if not user_info:

  898.             return web.Response(text='用户不存在', status=404)

  899.         client_ip = request.remote

  900.  

  901.         try:

  902.             reader = await request.multipart()

  903.         except Exception as e:

  904.             self.logger.log_error(client_ip, user_info['username'], "上传", "解析请求失败", str(e))

  905.             return web.Response(text='请求解析失败', status=400)

  906.  

  907.         user_dir = self.get_user_dir(user_info['username'])

  908.         upload_path = ''

  909.         target_dir = None

  910.         uploaded_files = []

  911.         total_size = 0

  912.  

  913.         while True:

  914.             part = await reader.next()

  915.             if part is None:

  916.                 break

  917.  

  918.             if part.name == 'path':

  919.                 text = await part.text()

  920.                 upload_path = self.normalize_path(text.strip())

  921.                 target_dir = user_dir / upload_path if upload_path else user_dir

  922.                 safe, _ = self.is_safe_path(user_dir, upload_path)

  923.                 if not safe:

  924.                     return web.Response(text='路径不安全', status=403)

  925.                 try:

  926.                     target_dir.mkdir(parents=True, exist_ok=True)

  927.                 except Exception as e:

  928.                     self.logger.log_error(client_ip, user_info['username'], "创建上传目录", str(e))

  929.                     return web.Response(text='无法创建目录', status=500)

  930.  

  931.             elif part.filename:

  932.                 filename = self.sanitize_path(part.filename)

  933.                 if not filename:

  934.                     continue

  935.                 if target_dir is None:

  936.                     target_dir = user_dir

  937.                     target_dir.mkdir(parents=True, exist_ok=True)

  938.  

  939.                 file_path = target_dir / filename

  940.                 counter = 1

  941.                 name, ext = os.path.splitext(filename)

  942.                 while file_path.exists():

  943.                     filename = f"{name}_{counter}{ext}"

  944.                     file_path = target_dir / filename

  945.                     counter += 1

  946.  

  947.                 try:

  948.                     async with aiofiles.open(str(file_path), 'wb') as f:

  949.                         while True:

  950.                             chunk = await part.read_chunk(65536)

  951.                             if not chunk:

  952.                                 break

  953.                             await f.write(chunk)

  954.                             total_size += len(chunk)

  955.                     uploaded_files.append(filename)

  956.                 except Exception as e:

  957.                     self.logger.log_error(client_ip, user_info['username'], "保存文件", filename, str(e))

  958.                     continue

  959.  

  960.         if uploaded_files:

  961.             async with aiosqlite.connect(self.db_path) as db:

  962.                 await db.execute(

  963.                     'UPDATE users SET storage_used = storage_used + ? WHERE id = ?',

  964.                     (total_size, user_id)

  965.                 )

  966.                 await db.commit()

  967.             self.logger.log_upload(client_ip, user_info['username'], len(uploaded_files), upload_path, 200)

  968.  

  969.         return web.json_response({'success': True, 'uploaded_files': uploaded_files})

  970.  

  971.     async def handle_create_folder(self, request):

  972.         user_id = await self.check_auth(request)

  973.         if not user_id:

  974.             return web.json_response({'status': 'error', 'message': '未授权'}, status=401)

  975.         try:

  976.             data = await request.json()

  977.         except:

  978.             return web.json_response({'status': 'error', 'message': '请求格式错误'}, status=400)

  979.         folder_name = data.get('name', '').strip()

  980.         raw_path = data.get('path', '').strip()

  981.         if not folder_name:

  982.             return web.json_response({'status': 'error', 'message': '文件夹名称不能为空'})

  983.         folder_name = self.sanitize_path(folder_name)

  984.         if not folder_name:

  985.             return web.json_response({'status': 'error', 'message': '文件夹名称包含非法字符'})

  986.  

  987.         user_info = await self.get_user_info(user_id)

  988.         if not user_info:

  989.             return web.json_response({'status': 'error', 'message': '用户不存在'}, status=404)

  990.         user_dir = self.get_user_dir(user_info['username'])

  991.         safe, parent_path = self.is_safe_path(user_dir, raw_path)

  992.         if not safe:

  993.             return web.json_response({'status': 'error', 'message': '路径不安全'})

  994.  

  995.         target_dir = user_dir / parent_path if parent_path else user_dir

  996.         folder_path = target_dir / folder_name

  997.         try:

  998.             folder_path.mkdir(exist_ok=False)

  999.             rel_path = folder_path.relative_to(user_dir).as_posix()

  1000.             full_path = f"/{rel_path}" if rel_path else "/"

  1001.             self.logger.log_create_folder(request.remote, user_info['username'], full_path, 200)

  1002.             return web.json_response({'status': 'success'})

  1003.         except FileExistsError:

  1004.             return web.json_response({'status': 'error', 'message': '文件夹已存在'})

  1005.         except Exception as e:

  1006.             self.logger.log_error(request.remote, user_info['username'], "创建文件夹", str(e))

  1007.             return web.json_response({'status': 'error', 'message': str(e)})

  1008.  

  1009.     async def handle_delete(self, request):

  1010.         user_id = await self.check_auth(request)

  1011.         if not user_id:

  1012.             return web.json_response({'status': 'error', 'message': '未授权'}, status=401)

  1013.         try:

  1014.             data = await request.json()

  1015.         except:

  1016.             return web.json_response({'status': 'error', 'message': '请求格式错误'}, status=400)

  1017.         raw_path = data.get('path', '').strip()

  1018.         user_info = await self.get_user_info(user_id)

  1019.         if not user_info:

  1020.             return web.json_response({'status': 'error', 'message': '用户不存在'}, status=404)

  1021.         user_dir = self.get_user_dir(user_info['username'])

  1022.         safe, processed_path = self.is_safe_path(user_dir, raw_path)

  1023.         if not safe:

  1024.             return web.json_response({'status': 'error', 'message': '路径不安全'})

  1025.  

  1026.         full_path = user_dir / processed_path if processed_path else user_dir

  1027.         if not full_path.exists():

  1028.             return web.json_response({'status': 'error', 'message': '文件/文件夹不存在'})

  1029.  

  1030.         try:

  1031.             total_size = 0

  1032.             if full_path.is_file():

  1033.                 total_size = full_path.stat().st_size

  1034.                 full_path.unlink()

  1035.             else:

  1036.                 for file in full_path.rglob('*'):

  1037.                     if file.is_file():

  1038.                         total_size += file.stat().st_size

  1039.                 shutil.rmtree(str(full_path))

  1040.  

  1041.             async with aiosqlite.connect(self.db_path) as db:

  1042.                 await db.execute(

  1043.                     'UPDATE users SET storage_used = MAX(0, storage_used - ?) WHERE id = ?',

  1044.                     (total_size, user_id)

  1045.                 )

  1046.                 await db.commit()

  1047.             self.logger.log_delete(request.remote, user_info['username'], f"/{processed_path}" if processed_path else "/", 200)

  1048.             return web.json_response({'status': 'success'})

  1049.         except Exception as e:

  1050.             self.logger.log_error(request.remote, user_info['username'], "删除", str(e))

  1051.             return web.json_response({'status': 'error', 'message': str(e)})

  1052.  

  1053.     async def handle_rename(self, request):

  1054.         user_id = await self.check_auth(request)

  1055.         if not user_id:

  1056.             return web.json_response({'status': 'error', 'message': '未授权'}, status=401)

  1057.         try:

  1058.             data = await request.json()

  1059.         except:

  1060.             return web.json_response({'status': 'error', 'message': '请求格式错误'}, status=400)

  1061.         old_path = data.get('old_path', '').strip()

  1062.         new_name = data.get('new_name', '').strip()

  1063.         if not old_path or not new_name:

  1064.             return web.json_response({'status': 'error', 'message': '参数不完整'})

  1065.         new_name = self.sanitize_path(new_name)

  1066.         if not new_name:

  1067.             return web.json_response({'status': 'error', 'message': '新名称包含非法字符'})

  1068.  

  1069.         user_info = await self.get_user_info(user_id)

  1070.         if not user_info:

  1071.             return web.json_response({'status': 'error', 'message': '用户不存在'}, status=404)

  1072.         user_dir = self.get_user_dir(user_info['username'])

  1073.         safe, processed_old = self.is_safe_path(user_dir, old_path)

  1074.         if not safe:

  1075.             return web.json_response({'status': 'error', 'message': '路径不安全'})

  1076.  

  1077.         old_full = user_dir / processed_old if processed_old else user_dir

  1078.         new_full = old_full.parent / new_name

  1079.         if not old_full.exists():

  1080.             return web.json_response({'status': 'error', 'message': '目标不存在'})

  1081.         try:

  1082.             old_full.rename(new_full)

  1083.             self.logger.log_rename(request.remote, user_info['username'],

  1084.                                    f"/{processed_old}" if processed_old else "/", new_name, 200)

  1085.             return web.json_response({'status': 'success'})

  1086.         except Exception as e:

  1087.             self.logger.log_error(request.remote, user_info['username'], "重命名", str(e))

  1088.             return web.json_response({'status': 'error', 'message': str(e)})

  1089.  

  1090.     async def handle_storage_info(self, request):

  1091.         user_id = await self.check_auth(request)

  1092.         if not user_id:

  1093.             return web.Response(text='未授权', status=401)

  1094.         info = await self.get_user_info(user_id)

  1095.         if not info:

  1096.             return web.Response(text='用户不存在', status=404)

  1097.         return web.json_response(info)

  1098.  

  1099.     async def handle_delete_account(self, request):

  1100.         user_id = await self.check_auth(request)

  1101.         if not user_id:

  1102.             return web.Response(text='未授权', status=401)

  1103.         try:

  1104.             data = await request.json()

  1105.         except:

  1106.             return web.json_response({'status': 'error', 'message': '请求格式错误'}, status=400)

  1107.         password = data.get('password', '').strip()

  1108.         if not password:

  1109.             return web.json_response({'status': 'error', 'message': '请输入密码'})

  1110.         async with aiosqlite.connect(self.db_path) as db:

  1111.             cursor = await db.execute('SELECT username, password_hash, salt FROM users WHERE id = ?', (user_id,))

  1112.             user = await cursor.fetchone()

  1113.             if not user:

  1114.                 return web.json_response({'status': 'error', 'message': '用户不存在'})

  1115.             username, stored_hash, salt = user

  1116.             hashed, _ = self.hash_password(password, bytes.fromhex(salt))

  1117.             if hashed != stored_hash:

  1118.                 return web.json_response({'status': 'error', 'message': '密码错误'})

  1119.         await self.delete_user(user_id)

  1120.         resp = web.json_response({'status': 'success'})

  1121.         resp.del_cookie('session_id')

  1122.         return resp

  1123.  

  1124.     @web.middleware

  1125.     async def connection_tracker(self, request, handler):

  1126.         self.active_connections.add(id(request))

  1127.         try:

  1128.             return await handler(request)

  1129.         finally:

  1130.             self.active_connections.discard(id(request))

  1131.  

  1132.     # ---------- 启动/停止 ----------

  1133.     async def start_server(self):

  1134.         await self.init_db()

  1135.         self.app = web.Application(middlewares=[self.connection_tracker])

  1136.  

  1137.         self.app.router.add_get('/', self.handle_index)

  1138.         self.app.router.add_get('/login', self.handle_login)

  1139.         self.app.router.add_post('/login', self.handle_login)

  1140.         self.app.router.add_get('/register', self.handle_register)

  1141.         self.app.router.add_post('/register', self.handle_register)

  1142.         self.app.router.add_get('/logout', self.handle_logout)

  1143.         self.app.router.add_get('/cloud', self.handle_cloud)

  1144.         self.app.router.add_post('/upload', self.handle_upload)

  1145.         self.app.router.add_post('/create_folder', self.handle_create_folder)

  1146.         self.app.router.add_post('/delete', self.handle_delete)

  1147.         self.app.router.add_post('/rename', self.handle_rename)

  1148.         self.app.router.add_get('/storage_info', self.handle_storage_info)

  1149.         self.app.router.add_post('/delete_account', self.handle_delete_account)

  1150.         self.app.router.add_get('/download/{path:.+}', self.handle_download)

  1151.         self.app.router.add_static('/static', str(self.base_dir / 'static'))

  1152.  

  1153.         try:

  1154.             sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

  1155.             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

  1156.             sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)

  1157.             sock.bind(('::', self.port))

  1158.             sock.listen(100)

  1159.             self.logger.log_server_event("使用IPv6 socket（兼容IPv4）")

  1160.         except Exception:

  1161.             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

  1162.             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

  1163.             sock.bind(('0.0.0.0', self.port))

  1164.             sock.listen(100)

  1165.  

  1166.         self.runner = web.AppRunner(self.app)

  1167.         await self.runner.setup()

  1168.         self.site = web.SockSite(self.runner, sock)

  1169.         await self.site.start()

  1170.  

  1171.         ipv4_addresses, ipv6_addresses = self.get_network_addresses()

  1172.  

  1173.         self.logger.log_server_event("=" * 50)

  1174.         self.logger.log_server_event("云盘服务器启动成功！")

  1175.         self.logger.log_server_event(f"端口: {self.port}")

  1176.         self.logger.log_server_event(f"允许注册: {'是' if self.allow_register else '否'}")

  1177.         self.logger.log_server_event("访问地址:")

  1178.  

  1179.         if ipv4_addresses:

  1180.             self.logger.log_server_event("[IPv4]")

  1181.             for ip in ipv4_addresses:

  1182.                 self.logger.log_server_event(f"  http://{ip}:{self.port}/")

  1183.         if ipv6_addresses:

  1184.             self.logger.log_server_event("[IPv6]")

  1185.             for ip in ipv6_addresses:

  1186.                 self.logger.log_server_event(f"  http://[{ip}]:{self.port}/")

  1187.         self.logger.log_server_event("[本地]")

  1188.         self.logger.log_server_event(f"  http://127.0.0.1:{self.port}/")

  1189.         self.logger.log_server_event("=" * 50)

  1190.  

  1191.         self.is_running = True

  1192.  

  1193.         async def periodic_cleanup():

  1194.             while self.is_running:

  1195.                 await asyncio.sleep(300)

  1196.                 self.logger.clear_download_cache()

  1197.         asyncio.ensure_future(periodic_cleanup())

  1198.  

  1199.         while self.is_running:

  1200.             await asyncio.sleep(1)

  1201.  

  1202.     async def stop_server(self):

  1203.         self.is_running = False

  1204.         if self.active_connections:

  1205.             self.logger.log_server_event(f'等待 {len(self.active_connections)} 个连接关闭...')

  1206.             wait = 30

  1207.             for _ in range(wait):

  1208.                 if not self.active_connections:

  1209.                     break

  1210.                 await asyncio.sleep(1)

  1211.         if hasattr(self, 'site') and self.site:

  1212.             await self.site.stop()

  1213.             self.site = None

  1214.         if hasattr(self, 'runner') and self.runner:

  1215.             await self.runner.cleanup()

  1216.             self.runner = None

  1217.         if hasattr(self, 'app') and self.app:

  1218.             await self.app.cleanup()

  1219.             self.app = None

  1220.         self.logger.log_server_event('服务器已停止')

  1221.  

  1222.  

  1223. # ---------- 配置加载 ----------

  1224. def load_config():

  1225.     config_path = Path(__file__).parent / 'config.json'

  1226.     defaults = {

  1227.         'port': 8000,

  1228.         'allow_register': 'yes'

  1229.     }

  1230.     config = {}

  1231.     if config_path.exists():

  1232.         try:

  1233.             with open(config_path, 'r', encoding='utf-8') as f:

  1234.                 config = json.load(f)

  1235.         except Exception as e:

  1236.             print(f"配置文件读取失败，使用默认配置: {e}")

  1237.     else:

  1238.         with open(config_path, 'w', encoding='utf-8') as f:

  1239.             json.dump(defaults, f, indent=2, ensure_ascii=False)

  1240.         print(f"已生成配置文件: {config_path}")

  1241.         return defaults

  1242.  

  1243.     for key, val in defaults.items():

  1244.         if key not in config:

  1245.             config[key] = val

  1246.  

  1247.     allow = config.get('allow_register', 'yes')

  1248.     if isinstance(allow, bool):

  1249.         config['allow_register'] = allow

  1250.     elif isinstance(allow, str):

  1251.         config['allow_register'] = allow.lower() in ('yes', 'true', '1', 'y')

  1252.     else:

  1253.         config['allow_register'] = True

  1254.  

  1255.     return config

  1256.  

  1257.  

  1258. async def main():

  1259.     config = load_config()

  1260.     server = CloudDriveServer(config)

  1261.     try:

  1262.         await server.start_server()

  1263.     except asyncio.CancelledError:

  1264.         pass

  1265.     except KeyboardInterrupt:

  1266.         pass

  1267.     except Exception as e:

  1268.         server.logger.log_error(action="服务器运行", error=str(e))

  1269.     finally:

  1270.         await server.stop_server()

  1271.  

  1272.  

  1273. if __name__ == "__main__":

  1274.     try:

  1275.         asyncio.run(main())

  1276.     except KeyboardInterrupt:

  1277.         print("\n服务器已手动停止")
复制代码

下载地址

https://wwamp.lanzouu.com/izuJN3o4ogre

© 版权声明
文章版权归作者所有，未经允许请勿转载。

相关文章

添加小工具
点此为“正文侧边栏”添加小工具