Alaea 2.6.0__tar.gz → 2.6.2__tar.gz

alaea-2.6.2/.VERSION

@@ -0,0 +1 @@
+v2.6.2

{alaea-2.6.0 → alaea-2.6.2}/Alaea/Blogging.py

@@ -12,8 +12,8 @@
 from __future__ import annotations
 
 import datetime
-import errno
 import gzip
+import hashlib
 import logging
 import os
 import shutil
@@ -29,10 +29,21 @@ try:
 except ImportError:
     fcntl = None
 
-try:
-    import msvcrt
-except ImportError:
-    msvcrt = None
+if os.name == 'nt':
+    import ctypes
+    from ctypes import wintypes
+
+    _windows_kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+    _windows_kernel32.CreateMutexW.argtypes = [wintypes.LPVOID, wintypes.BOOL, wintypes.LPCWSTR]
+    _windows_kernel32.CreateMutexW.restype = wintypes.HANDLE
+    _windows_kernel32.WaitForSingleObject.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+    _windows_kernel32.WaitForSingleObject.restype = wintypes.DWORD
+    _windows_kernel32.ReleaseMutex.argtypes = [wintypes.HANDLE]
+    _windows_kernel32.ReleaseMutex.restype = wintypes.BOOL
+    _windows_kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+    _windows_kernel32.CloseHandle.restype = wintypes.BOOL
+else:
+    _windows_kernel32 = None
 
 try:
     import zstandard
@@ -70,7 +81,11 @@ def _local_converter(timestamp):
 
 
 class _ProcessSafeRotatingMixin:
-    """为每个日志路径使用一个协作锁，在多进程之间串行执行轮转。"""
+    """通过日志目录锁在多进程之间串行执行写入和轮转。"""
+
+    _WAIT_OBJECT_0 = 0
+    _WAIT_ABANDONED = 0x80
+    _INFINITE = 0xFFFFFFFF
 
     def __init__(self, *args, **kwargs):
         """初始化 handler，并避免 Windows 长期占用当前日志文件。"""
@@ -79,40 +94,65 @@ class _ProcessSafeRotatingMixin:
 
     def _close_windows_stream(self):
         """在 Windows 上关闭日志流，使其他进程能够重命名当前日志文件。"""
-        if msvcrt is not None and self.stream is not None:
+        if _windows_kernel32 is not None and self.stream is not None:
             self.stream.close()
             self.stream = None
 
-    @staticmethod
-    def _acquire_process_lock(lock_stream):
-        """使用当前平台标准库取得跨进程排他锁。"""
+    def _acquire_process_lock(self):
+        """锁定日志目录，返回当前平台用于释放锁的标记和句柄。
+
+        Returns:
+            ``('fcntl', fd)``、``('windows', handle)``，不支持时返回 ``None``。
+
+        Raises:
+            OSError: 无法打开日志目录或取得系统锁时抛出。
+        """
         if fcntl is not None:
-            fcntl.flock(lock_stream.fileno(), fcntl.LOCK_EX)
-            return True
-        if msvcrt is None:
-            return False
-        lock_stream.seek(0, os.SEEK_END)
-        if lock_stream.tell() == 0:
-            lock_stream.write(b'\0')
-            lock_stream.flush()
-        while True:
-            lock_stream.seek(0)
+            directory_fd = os.open(os.path.dirname(self.baseFilename), os.O_RDONLY | getattr(os, 'O_DIRECTORY', 0))
             try:
-                msvcrt.locking(lock_stream.fileno(), msvcrt.LK_NBLCK, 1)
-                return True
-            except OSError as error:
-                if error.errno not in {errno.EACCES, errno.EDEADLK}:
-                    raise
-                time.sleep(0.05)
+                fcntl.flock(directory_fd, fcntl.LOCK_EX)
+            except OSError:
+                os.close(directory_fd)
+                raise
+            return 'fcntl', directory_fd
+        if _windows_kernel32 is None:
+            return None
+        directory = os.path.normcase(os.path.realpath(os.path.dirname(self.baseFilename)))
+        digest = hashlib.sha256(directory.encode('utf-8', errors='surrogatepass')).hexdigest()
+        handle = _windows_kernel32.CreateMutexW(None, False, f'Global\\AlaeaLogRotation-{digest}')
+        if not handle:
+            raise OSError('无法创建 Windows 日志目录互斥量')
+        result = _windows_kernel32.WaitForSingleObject(handle, self._INFINITE)
+        if result not in {self._WAIT_OBJECT_0, self._WAIT_ABANDONED}:
+            _windows_kernel32.CloseHandle(handle)
+            raise OSError(f'无法取得 Windows 日志目录互斥量: {result}')
+        return 'windows', handle
 
     @staticmethod
-    def _release_process_lock(lock_stream):
-        """使用当前平台标准库释放跨进程排他锁。"""
-        if fcntl is not None:
-            fcntl.flock(lock_stream.fileno(), fcntl.LOCK_UN)
-        elif msvcrt is not None:
-            lock_stream.seek(0)
-            msvcrt.locking(lock_stream.fileno(), msvcrt.LK_UNLCK, 1)
+    def _release_process_lock(lock_token):
+        """释放并关闭当前平台的日志目录锁。
+
+        Args:
+            lock_token: ``_acquire_process_lock`` 返回的平台标记和句柄。
+
+        Returns:
+            None。
+
+        Raises:
+            OSError: 系统拒绝释放锁时抛出。
+        """
+        lock_kind, handle = lock_token
+        if lock_kind == 'fcntl':
+            try:
+                fcntl.flock(handle, fcntl.LOCK_UN)
+            finally:
+                os.close(handle)
+            return
+        try:
+            if not _windows_kernel32.ReleaseMutex(handle):
+                raise OSError('无法释放 Windows 日志目录互斥量')
+        finally:
+            _windows_kernel32.CloseHandle(handle)
 
     def _reopen_replaced_stream(self):
         """其他进程替换当前日志文件后，重新打开日志流。
@@ -171,37 +211,29 @@ class _ProcessSafeRotatingMixin:
         Raises:
             不额外抛出异常；当前平台没有文件锁或锁不可用时回退到标准 handler 行为。
         """
-        if fcntl is None and msvcrt is None:
+        if fcntl is None and _windows_kernel32 is None:
             super().emit(record)
             return
         self._close_windows_stream()
         try:
-            lock_stream = open(f'{self.baseFilename}.rotate.lock', 'a+b')
+            lock_token = self._acquire_process_lock()
         except OSError:
             super().emit(record)
             self._close_windows_stream()
             return
-        with lock_stream:
+        if lock_token is None:
+            super().emit(record)
+            return
+        try:
+            self._reopen_replaced_stream()
+            self._synchronize_timed_rollover()
+            super().emit(record)
+        finally:
+            self._close_windows_stream()
             try:
-                acquired = self._acquire_process_lock(lock_stream)
+                self._release_process_lock(lock_token)
             except OSError:
-                super().emit(record)
-                self._close_windows_stream()
-                return
-            if not acquired:
-                super().emit(record)
-                self._close_windows_stream()
-                return
-            try:
-                self._reopen_replaced_stream()
-                self._synchronize_timed_rollover()
-                super().emit(record)
-            finally:
-                self._close_windows_stream()
-                try:
-                    self._release_process_lock(lock_stream)
-                except OSError:
-                    pass
+                pass
 
 
 class _ProcessSafeRotatingFileHandler(_ProcessSafeRotatingMixin, RotatingFileHandler):

{alaea-2.6.0 → alaea-2.6.2}/Alaea/storage.py

@@ -43,7 +43,7 @@ def run_storage_fallback(storage_mode, auto_methods, operations, fallback_errors
         try:
             result = normalized_operations[method]()
             if logger is not None:
-                logger.info('Storage method succeeded: context=%s, method=%s, wallSeconds=%.2f', context, method, perf_counter() - started_at)
+                logger.debug('Storage method succeeded: context=%s, method=%s, wallSeconds=%.2f', context, method, perf_counter() - started_at)
             return result
         except fallback_errors as error:
             if active_mode != 'AUTO':

{alaea-2.6.0 → alaea-2.6.2}/Alaea.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Alaea
-Version: 2.6.0
+Version: 2.6.2
 Summary: Some simple tools by Christmas
 Author: Christmas
 Author-email: 273519355@qq.com

{alaea-2.6.0 → alaea-2.6.2}/ChangeLog.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## v2.6.2
+
+- `run_storage_fallback` 的成功线路明细由 INFO 调整为 DEBUG，减少 `Storage method succeeded` 高频常规日志；实际失败并降级仍保持 WARNING。
+
+## v2.6.1
+
+- macOS/Linux 使用 `fcntl` 锁定日志目录，Windows 使用由日志目录确定的系统命名互斥量，让不同程序的按时间、按大小及组合日志轮转无额外锁文件地跨进程串行；多个进程在同一时刻压缩共享日志时只轮转一次，Windows 写入后会关闭日志句柄以允许其他进程重命名文件，其他 handler 会同步当前日志和下次轮转时间，避免 `.gz.tmp`/`.zst.tmp` 竞争、重复归档和轮转后日志丢失。
+
 ## v2.6.0
 
 - macOS/Linux 使用 `fcntl`、Windows 使用 `msvcrt`，让按时间、按大小及组合日志轮转通过同路径协作式文件锁跨进程串行；多个进程在同一时刻压缩共享日志时只轮转一次，Windows 写入后会关闭日志句柄以允许其他进程重命名文件，其他 handler 会同步当前日志和下次轮转时间，避免 `.gz.tmp`/`.zst.tmp` 竞争、重复归档和轮转后日志丢失。

{alaea-2.6.0 → alaea-2.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Alaea
-Version: 2.6.0
+Version: 2.6.2
 Summary: Some simple tools by Christmas
 Author: Christmas
 Author-email: 273519355@qq.com

{alaea-2.6.0 → alaea-2.6.2}/setup.py

@@ -8,7 +8,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="Alaea",
-    version="2.6.0",
+    version="2.6.2",
     author="Christmas",
     author_email="273519355@qq.com",
     description="Some simple tools by Christmas",

{alaea-2.6.0 → alaea-2.6.2}/tests/test_core.py

@@ -345,8 +345,11 @@ class UtilityRegressionTest(unittest.TestCase):
             return 'nfs-result'
 
         operations = {'CACHE': unavailable, 'NFS': direct}
-        self.assertEqual(run_storage_fallback('AUTO', ('CACHE', 'NFS'), operations), 'nfs-result')
+        logger = mock.Mock()
+        self.assertEqual(run_storage_fallback('AUTO', ('CACHE', 'NFS'), operations, logger=logger, context='down-gfs-cache'), 'nfs-result')
         self.assertEqual(calls, ['CACHE', 'NFS'])
+        logger.debug.assert_called_once_with('Storage method succeeded: context=%s, method=%s, wallSeconds=%.2f', 'down-gfs-cache', 'NFS', mock.ANY)
+        logger.info.assert_not_called()
         with self.assertRaisesRegex(OSError, 'cache unavailable'):
             run_storage_fallback('CACHE', ('CACHE', 'NFS'), operations)
 

{alaea-2.6.0 → alaea-2.6.2}/tests/test_logging_multiprocess.py

@@ -13,17 +13,34 @@ from Alaea.Blogging import Blog
 blogging = importlib.import_module('Alaea.Blogging')
 
 
-class FakeMsvcrt:
-    """在非 Windows 测试环境中记录 msvcrt 锁调用。"""
+class FakeKernel32:
+    """在非 Windows 测试环境中记录命名互斥量调用。"""
 
-    LK_NBLCK = 1
-    LK_UNLCK = 2
     calls = []
 
     @classmethod
-    def locking(cls, _file_descriptor, mode, byte_count):
-        """记录锁模式和锁定字节数。"""
-        cls.calls.append((mode, byte_count))
+    def CreateMutexW(cls, _attributes, _initial_owner, name):
+        """记录互斥量名称并返回测试句柄。"""
+        cls.calls.append(('create', name))
+        return 42
+
+    @classmethod
+    def WaitForSingleObject(cls, handle, timeout):
+        """记录等待调用并模拟成功取得互斥量。"""
+        cls.calls.append(('wait', handle, timeout))
+        return 0
+
+    @classmethod
+    def ReleaseMutex(cls, handle):
+        """记录释放调用并模拟成功。"""
+        cls.calls.append(('release', handle))
+        return True
+
+    @classmethod
+    def CloseHandle(cls, handle):
+        """记录句柄关闭调用并模拟成功。"""
+        cls.calls.append(('close', handle))
+        return True
 
 
 def emit_after_barrier(log_path: str, rollover_at: int, barrier, message: str) -> None:
@@ -89,11 +106,12 @@ def main() -> None:
         with gzip.open(archives[0], 'rt', encoding='utf-8') as archive:
             archived_log = archive.read()
         assert 'before' in archived_log and 'warmup-first' in archived_log and 'warmup-second' in archived_log
+        assert not list(log_path.parent.glob('*.rotate.lock'))
 
-    original_fcntl, original_msvcrt = blogging.fcntl, blogging.msvcrt
+    original_fcntl, original_kernel32 = blogging.fcntl, blogging._windows_kernel32
     try:
-        blogging.fcntl, blogging.msvcrt = None, FakeMsvcrt
-        FakeMsvcrt.calls = []
+        blogging.fcntl, blogging._windows_kernel32 = None, FakeKernel32
+        FakeKernel32.calls = []
         with tempfile.TemporaryDirectory() as directory:
             log_path = Path(directory) / 'WINDOWS.log'
             blog = Blog(_loger_name='windows-lock-test', _switch_write_bug_log=True, _switch_print_log=False)
@@ -101,11 +119,12 @@ def main() -> None:
             handler = next(item for item in blog.logger.handlers if isinstance(item, RotatingFileHandler))
             blog.logger.error('windows-lock')
             assert handler.stream is None
-            assert FakeMsvcrt.calls == [(FakeMsvcrt.LK_NBLCK, 1), (FakeMsvcrt.LK_UNLCK, 1)]
-            assert log_path.with_name(f'{log_path.name}.rotate.lock').read_bytes()
+            assert [call[0] for call in FakeKernel32.calls] == ['create', 'wait', 'release', 'close']
+            assert FakeKernel32.calls[0][1].startswith('Global\\AlaeaLogRotation-')
+            assert not list(log_path.parent.glob('*.rotate.lock'))
             blog.setup_Blog(switch_write_error_plus_log=False)
     finally:
-        blogging.fcntl, blogging.msvcrt = original_fcntl, original_msvcrt
+        blogging.fcntl, blogging._windows_kernel32 = original_fcntl, original_kernel32
 
 
 if __name__ == '__main__':

alaea-2.6.0/.VERSION

@@ -1 +0,0 @@
-v2.6.0