🎨 fix the f**king typo and grammar

- 修复所有 typo
- 修复所有语法错误
- 重构 logger 和 config 逻辑

Author: SilianZ

README.md

@@ -79,30 +79,29 @@
 
     ```sh
     docker run -d \
-    -v ${/data/python-openbmclapi}:/python-openbmclapi/bmclapi \
-    -e cluster_id=${cluster_id} \
-    -e cluster_secret=${cluster_secret} \
-    -e public_port=${port} \
-    -v /data/openbmclapi:/opt/openbmclapi/cache \
-    -p ${port}:80 \
+    -v ${/data/python-openbmclapi}:/bmclapi \
+    -e cluster.id=${cluster.id} \
+    -e cluster.secret=${cluster.secret} \
+    -e web.public_port=${web.public_port} \
+    -p ${web.public_port}:80 \
     --restart always \
     --name python-openbmclapi \
     silianz/python-openbmclapi 
     ```
 
     **参数说明：**
 
-    `port` - 对外开放的端口。
+    `web.public_port` - 对外开放的端口。
 
-    `cluster_id` - 即 `CLUSTER_ID`。
+    `cluster.id` - 即 `CLUSTER_ID`。
 
-    `cluster_secret` - 即 `CLUSTER_SECRET`。
+    `cluster.secret` - 即 `CLUSTER_SECRET`。
 
     `/data/python-openbmclapi` - `bmclapi` 文件夹（即缓存 `cache` 文件夹）挂载的路径。
 
 ## 配置文件
 
-```yaml
+```yml
 # 是否不使用 BMCLAPI 分发的证书, 同 CLUSTER_BYOC
 byoc: false
 # OpenBMCLAPI 的 CLUSTER_ID

core/__init__.py

@@ -18,41 +18,56 @@ class Protocol(Enum):
     HTTP = "HTTP"
     Unknown = "Unknown"
     DETECT = "Detect"
+
     @staticmethod
     def get(data: bytes):
-        if b'HTTP/1.1' in data:
+        if b"HTTP/1.1" in data:
             return Protocol.HTTP
         if check_port_key == data:
             return Protocol.DETECT
         return Protocol.Unknown
+
+
 @dataclass
 class ProxyClient:
-    proxy: 'Proxy'
+    proxy: "Proxy"
     origin: Client
     target: Client
-    before: bytes = b''
+    before: bytes = b""
     closed: bool = False
+
     def start(self):
         self._task_origin = Timer.delay(self.process_origin, (), 0)
-        self._task_target = Timer.delay(self.process_target, (), 0) 
+        self._task_target = Timer.delay(self.process_target, (), 0)
+
     async def process_origin(self):
         try:
             self.target.write(self.before)
-            while (buffer := await self.origin.read(IO_BUFFER, timeout=TIMEOUT)) and not self.origin.is_closed() and not self.origin.is_closed():
+            while (
+                (buffer := await self.origin.read(IO_BUFFER, timeout=TIMEOUT))
+                and not self.origin.is_closed()
+                and not self.origin.is_closed()
+            ):
                 self.target.write(buffer)
-                self.before = b''
+                self.before = b""
                 await self.target.writer.drain()
         except:
             ...
         self.close()
+
     async def process_target(self):
         try:
-            while (buffer := await self.target.read(IO_BUFFER, timeout=TIMEOUT)) and not self.target.is_closed() and not self.target.is_closed():
+            while (
+                (buffer := await self.target.read(IO_BUFFER, timeout=TIMEOUT))
+                and not self.target.is_closed()
+                and not self.target.is_closed()
+            ):
                 self.origin.write(buffer)
                 await self.origin.writer.drain()
         except:
             ...
         self.close()
+
     def close(self):
         if not self.closed:
             if not self.origin.is_closed():
@@ -61,47 +76,63 @@ def close(self):
                 self.target.close()
             self.closed = True
         self.proxy.disconnect(self)
+
+
 class Proxy:
     def __init__(self) -> None:
         self._tables: list[ProxyClient] = []
+
     async def connect(self, origin: Client, target: Client, before: bytes):
         client = ProxyClient(self, origin, target, before)
         self._tables.append(client)
         client.start()
+
     def disconnect(self, client: ProxyClient):
         if client not in self._tables:
             return
         self._tables.remove(client)
 
+
 ssl_server: Optional[asyncio.Server] = None
 server: Optional[asyncio.Server] = None
 proxy: Proxy = Proxy()
 restart = False
 check_port_key = os.urandom(8)
-PORT: int = Config.get("web.port") 
-TIMEOUT: int = Config.get("advanced.timeout") 
+PORT: int = Config.get("web.port")
+TIMEOUT: int = Config.get("advanced.timeout")
 SSL_PORT: int = Config.get("web.ssl_port")
 PROTOCOL_HEADER_BYTES = Config.get("advanced.header_bytes")
 IO_BUFFER: int = Config.get("advanced.io_buffer")
 
+
 async def _handle_ssl(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
     return await _handle_process(Client(reader, writer), True)
 
+
 async def _handle(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
     return await _handle_process(Client(reader, writer))
 
+
 async def _handle_process(client: Client, ssl: bool = False):
     global ssl_server
     proxying = False
     try:
-        while (header := await client.read(PROTOCOL_HEADER_BYTES, timeout=30)) and not client.is_closed():
+        while (
+            header := await client.read(PROTOCOL_HEADER_BYTES, timeout=30)
+        ) and not client.is_closed():
             protocol = Protocol.get(header)
             if protocol == Protocol.DETECT:
                 client.write(check_port_key)
                 await client.writer.drain()
                 break
             if protocol == Protocol.Unknown and not ssl and ssl_server:
-                target = Client(*(await asyncio.open_connection("127.0.0.1", ssl_server.sockets[0].getsockname()[1])))
+                target = Client(
+                    *(
+                        await asyncio.open_connection(
+                            "127.0.0.1", ssl_server.sockets[0].getsockname()[1]
+                        )
+                    )
+                )
                 proxying = True
                 await proxy.connect(client, target, header)
                 break
@@ -117,40 +148,64 @@ async def _handle_process(client: Client, ssl: bool = False):
         logger.debug(traceback.format_exc())
     if not proxying and not client.is_closed():
         client.close()
+
+
 async def check_ports():
     global ssl_server, server, client_side_ssl, restart, check_port_key
     while 1:
         ports: list[tuple[asyncio.Server, ssl.SSLContext | None]] = []
-        for service in ((server, None), (ssl_server, client_side_ssl if get_loads() != 0 else None)):
+        for service in (
+            (server, None),
+            (ssl_server, client_side_ssl if get_loads() != 0 else None),
+        ):
             if not service[0]:
                 continue
             ports.append((service[0], service[1]))
         closed = False
         for port in ports:
             try:
-                client = Client(*(await asyncio.open_connection('127.0.0.1', port[0].sockets[0].getsockname()[1], ssl=port[1])))
+                client = Client(
+                    *(
+                        await asyncio.open_connection(
+                            "127.0.0.1",
+                            port[0].sockets[0].getsockname()[1],
+                            ssl=port[1],
+                        )
+                    )
+                )
                 client.write(check_port_key)
                 await client.writer.drain()
                 key = await client.read(len(check_port_key), 5)
             except:
-                logger.warn(f"Port {port[0].sockets[0].getsockname()[1]} is shutdown now! Now restarting the port!")
+                logger.warn(
+                    f"Port {port[0].sockets[0].getsockname()[1]} has been closed! Reopening..."
+                )
                 logger.error(traceback.format_exc())
                 closed = True
         if closed:
             restart = True
             for port in ports:
                 port[0].close()
         await asyncio.sleep(5)
+
+
 async def main():
     global ssl_server, server, server_side_ssl, restart
     await web.init()
     Timer.delay(check_ports, (), 5)
     while 1:
         try:
             server = await asyncio.start_server(_handle, port=PORT)
-            ssl_server = await asyncio.start_server(_handle_ssl, port=0 if SSL_PORT == PORT else SSL_PORT, ssl=server_side_ssl if get_loads() != 0 else None)
-            logger.info(f"Listening server on {PORT}")
-            logger.info(f"Listening server on {ssl_server.sockets[0].getsockname()[1]} Loaded certificates: {get_loads()}")
+            ssl_server = await asyncio.start_server(
+                _handle_ssl,
+                port=0 if SSL_PORT == PORT else SSL_PORT,
+                ssl=server_side_ssl if get_loads() != 0 else None,
+            )
+            logger.info(f"Listening server on port {PORT}.")
+            logger.info(
+                f"Listening server on {ssl_server.sockets[0].getsockname()[1]}."
+            )
+            logger.info(f"Loaded {get_loads()} certificates!")
             async with server, ssl_server:
                 await asyncio.gather(server.serve_forever(), ssl_server.serve_forever())
         except asyncio.CancelledError:
@@ -159,8 +214,8 @@ async def main():
                     server.close()
                 restart = False
             else:
-                logger.info("Shutdown web service")
-                await web.close()
+                logger.info("Shutting down web service...")
+                web.close()
                 break
         except:
             if server:
@@ -170,4 +225,4 @@ async def main():
 
 
 def init():
-    asyncio.run(main())
+    asyncio.run(main())

core/api.py

@@ -18,14 +18,20 @@ class BMCLAPIFile:
     path: str
     hash: str
     size: int
-    def __hash__(self):  
+
+    def __hash__(self):
         return int.from_bytes(bytes.fromhex(self.hash))
-  
-    def __eq__(self, other):  
-        if isinstance(other, BMCLAPIFile):  
-            return self.hash == other.hash and self.size == other.size and self.path == other.path  
+
+    def __eq__(self, other):
+        if isinstance(other, BMCLAPIFile):
+            return (
+                self.hash == other.hash
+                and self.size == other.size
+                and self.path == other.path
+            )
         return False
 
+
 @dataclass
 class File:
     path: Path | str
@@ -34,53 +40,67 @@ class File:
     last_hit: float = 0
     last_access: float = 0
     data: Optional[io.BytesIO] = None
+
     def is_url(self):
         if not isinstance(self.path, str):
             return False
         return self.path.startswith("http://") or self.path.startswith("https://")
+
     def get_path(self) -> str | Path:
         return self.path
+
     def get_data(self):
         if not self.data:
             return io.BytesIO()
         return io.BytesIO(zlib.decompress(self.data.getbuffer()))
+
     def set_data(self, data: io.BytesIO | memoryview | bytes):
         if not isinstance(data, io.BytesIO):
             data = io.BytesIO(data)
         self.data = io.BytesIO(zlib.compress(data.getbuffer()))
 
+
 class Storage(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     async def get(self, file: str) -> File:
         """
-            return 
-                type: Path, str
-                Path: Local File
-                str: url
+        return
+            type: Path, str
+            Path: Local File
+            str: url
         """
         raise NotImplementedError
+
     @abc.abstractmethod
     async def exists(self, hash: str) -> bool:
         raise NotImplementedError
+
     @abc.abstractmethod
     async def get_size(self, hash: str) -> int:
         raise NotImplementedError
+
     @abc.abstractmethod
     async def write(self, hash: str, io: io.BytesIO) -> int:
         raise NotImplementedError
+
     @abc.abstractmethod
-    async def check_missing_files(self, pbar: tqdm, files: list[BMCLAPIFile]) -> list[BMCLAPIFile]:
+    async def check_missing_files(
+        self, pbar: tqdm, files: list[BMCLAPIFile]
+    ) -> list[BMCLAPIFile]:
         raise NotImplementedError
+
     @abc.abstractmethod
     async def get_files(self, dir: str) -> list[str]:
         raise NotImplementedError
+
     @abc.abstractmethod
     async def get_files_size(self, dir: str) -> int:
         raise NotImplementedError
+
     @abc.abstractmethod
     async def removes(self, hashs: list[str]) -> int:
         raise NotImplementedError
- 
+
 
 def get_hash(org):
     if len(org) == 32:
@@ -97,4 +117,4 @@ async def get_file_hash(org: str, path: Path):
                 break
             hash.update(data)
             await asyncio.sleep(0.001)
-    return hash.hexdigest() == org
+    return hash.hexdigest() == org