django-simpletask5 0.2.6__tar.gz → 0.2.7__tar.gz

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-simpletask5
-Version: 0.2.6
+Version: 0.2.7
 Summary: Lightweight async task execution framework for Django
 Author-email: rRR0VrFP <rrr0vrfp@qq.com>
 Maintainer-email: rRR0VrFP <rrr0vrfp@qq.com>
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: globallock>=0.1.4
+Requires-Dist: globallock>=0.2.0
 Requires-Dist: django-safe-fields>=0.2.3
 Requires-Dist: django-app-requires>=0.3.6
 Requires-Dist: django-admin-dashboards>=0.1.1
@@ -143,6 +143,7 @@ DJANGO_SIMPLETASK_BROKER_URL = 'amqp://guest:guest@127.0.0.1:5672//'
 # DJANGO_SIMPLETASK_REDIS_MQ_HOST = '127.0.0.1'       # MESSAGE_QUEUE_TYPE='redis' 时
 # DJANGO_SIMPLETASK_REDIS_MQ_PORT = 6379
 # DJANGO_SIMPLETASK_REDIS_MQ_DB = 0
+# DJANGO_SIMPLETASK_REDIS_MQ_PASSWORD = None          # Redis MQ 需认证时设置
 
 # ── 分布式锁与 Worker 注册中心（Redis）────────────────────────
 # 默认锁引擎 DjangoRedisGlobalLock 复用 CACHES['default']，需为 Redis 缓存
@@ -153,13 +154,16 @@ CACHES = {
         'OPTIONS': {'CLIENT_CLASS': 'django_redis.client.DefaultClient'},
     },
 }
-# 如需独立连接参数（锁与 Worker 注册中心共用同一 host/port/db）：
+# 如需独立连接参数（锁与 Worker 注册中心共用同一 host/port/db/password）：
 # DJANGO_SIMPLETASK_LOCK_CONFIG = {
 #     'global_lock_engine_class': 'globallock.redis_global_lock.RedisGlobalLock',
-#     'global_lock_engine_options': {'host': '127.0.0.1', 'port': 6379, 'db': 0},
+#     'global_lock_engine_options': {'host': '127.0.0.1', 'port': 6379, 'db': 0,
+#                                    'password': '<redis 密码，无需认证可省略>'},
 # }
-DJANGO_SIMPLETASK_LOCK_TIMEOUT = 600                 # 锁超时（秒）
-DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL = 60           # 锁续期间隔（秒）
+# 注：globallock>=0.2.0 已取消按 timeout 自动释放的概念。锁的有效期由
+# lockman/lock 作用域自行管理，作用域未结束前锁持续有效（内置看门狗自动续期），
+# 锁在 `with` 块退出或进程消亡时自动释放。已移除 DJANGO_SIMPLETASK_LOCK_TIMEOUT
+# 与 DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL，请勿再配置这两项。
 
 # ── Key 前缀与队列路由 ───────────────────────────────────────
 DJANGO_SIMPLETASK_KEY_PREFIX = 'myproject'           # Redis key 前缀，默认取 ROOT_URLCONF 首段
@@ -209,11 +213,9 @@ django_app_requires_patch_all()
 | `DJANGO_SIMPLETASK_BROKER_URL` | `None` | **优先级最高**，设置后忽略下方 MQ 类型/连接参数。生产建议统一使用完整 URL，便于复用云厂商连接串与凭据管理 |
 | `DJANGO_SIMPLETASK_MESSAGE_QUEUE_TYPE` | `'memory'` | `memory` 仅用于开发调试；**生产必须改为 `rabbitmq` 或 `redis`**，否则消息不持久化、跨进程 Worker 无法消费 |
 | `DJANGO_SIMPLETASK_RABBITMQ_HOST/PORT/USER/PASSWORD` | `127.0.0.1 / 5672 / guest / guest` | 类型为 `rabbitmq` 且未设 `BROKER_URL` 时生效。生产务必更换默认 `guest` 凭据 |
-| `DJANGO_SIMPLETASK_REDIS_MQ_HOST/PORT/DB` | `127.0.0.1 / 6379 / 0` | 类型为 `redis` 时生效。建议与锁/缓存使用**不同 db**，避免 key 冲突与互相阻塞 |
+| `DJANGO_SIMPLETASK_REDIS_MQ_HOST/PORT/DB/PASSWORD` | `127.0.0.1 / 6379 / 0 / None` | 类型为 `redis` 时生效。建议与锁/缓存使用**不同 db**，避免 key 冲突与互相阻塞。Redis 需认证时设置 `PASSWORD` |
 | `CACHES['default']` | — | 默认锁引擎 `DjangoRedisGlobalLock` 依赖它，**必须配置为 Redis 缓存** |
-| `DJANGO_SIMPLETASK_LOCK_CONFIG` | `None`（默认复用缓存锁） | 需要独立连接参数时显式配置。**注意**：Worker 注册中心（心跳/状态）也读取该配置的 `host/port/db`，未配置时固定连 `127.0.0.1:6379/0` |
-| `DJANGO_SIMPLETASK_LOCK_TIMEOUT` | `600` | 锁自动释放时间，应**大于单任务最长执行时长**；过短会导致长任务执行中被其他 Worker 抢锁 |
-| `DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL` | `60` | 锁续期间隔，应**远小于 `LOCK_TIMEOUT`**（默认 600 的 1/10） |
+| `DJANGO_SIMPLETASK_LOCK_CONFIG` | `None`（默认复用缓存锁） | 需要独立连接参数时显式配置（`global_lock_engine_options` 支持 `host/port/db/password`）。**注意**：Worker 注册中心（心跳/状态）也读取该配置的 `host/port/db/password`，未配置时固定连 `127.0.0.1:6379/0`。globallock>=0.2.0 起锁有效期由 lockman/lock 作用域管理（内置看门狗自动续期），**不再需要配置 `LOCK_TIMEOUT` / `LOCK_RENEW_INTERVAL`** |
 | `DJANGO_SIMPLETASK_KEY_PREFIX` | 自动取 `ROOT_URLCONF` 首段 | 生产建议**显式指定**，多项目共用 Redis 时避免 key 冲突 |
 | `DJANGO_SIMPLETASK_DEFAULT_QUEUE` | `{prefix}:...:queue:default` | 默认队列名。多环境（dev/staging/prod）建议加环境后缀隔离 |
 | `DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE` | `{prefix}:...:queue:high_priority` | 高优先级队列，**需单独启动 Worker 消费** |
@@ -686,6 +688,8 @@ python3 -m pytest django_simpletask5_example/tests
 
 测试套件覆盖 Redis、DB、MQ 连接中断后的自动恢复场景，详见 `django_simpletask5_example/tests/test_resilience_recovery.py`。
 
+**测试输出约定**：单元测试中对预期会触发的错误（如无效 UUID 校验、毒消息丢弃、消费者断连、执行器加载失败等）所输出的错误日志，必须在测试内屏蔽，避免污染测试输出。统一使用 `django_simpletask5_example.tests.suppress_expected_errors` 上下文管理器（整体禁用日志）或 `patch.object(..., 'logger')`（断言同时校验日志）进行屏蔽。
+
 ## 架构
 
 ```
@@ -698,6 +702,14 @@ Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保
 
 ## Releases
 
+### 0.2.7
+
+- **运行中任务回收机制重构** — 取消原先按 `expire_time` 将 running 直接判为超时的语义；`StatusCheckExecutor` 仅兜底回收长期未被 Worker 获取的 pending。新增 `core/reclaim`，由 crontab 每 ~5 秒基于执行锁探测运行中任务：锁已过期（执行器异常退出）即快速重投或直接置失败，降低孤儿任务滞留时间
+- **重试不再搁浅任务** — 失败重试先落库 `retry` 再发布重试消息，发布失败则 requeue 当前消息，杜绝任务永久停在无人处理的 `retry` 状态；KombuQueue 依据 AMQP `x-death` 上限丢弃毒消息，避免无限 requeue 造成的队头阻塞与空转
+- **消费者重连提示** — Worker 断连重连成功后输出 `Consumer connection restored` 恢复日志，便于运维确认消费通道已恢复
+- **安全与健壮性加固** — broker 账号/密码按百分号编码、脚本白名单按路径段边界匹配、signals 快照按实例隔离，覆盖相关回归测试
+- **新增测试约定** — 单元测试中对预期触发（如无效 UUID 校验、毒消息丢弃、消费者断连、执行器加载失败等）产生的错误日志必须屏蔽输出，统一使用 `django_simpletask5_example.tests.suppress_expected_errors` 或替换 logger，保证测试输出干净可读；本次同步清理全部此类预期错误日志
+
 ### 0.2.6
 
 - **新增 `canceled` 状态** — 取消已发布但未执行的任务改为独立的终态 `canceled`（原复用 `failed`），Worker 消费到已取消消息时直接跳过；Admin 取消操作、归档/清理/统计（新增 `canceled_count`）、Dashboard 状态图均纳入该状态，取消与执行失败可清晰区分
@@ -714,7 +726,7 @@ Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保
 
 - **破坏性变更**: `TaskExecution` 主键由 `execution_id`（UUID）改为默认自增 `id`，`execution_id` 变为 `unique=True` 的唯一标识字段。已有数据库需要执行迁移 `0010_taskexecution_id_alter_taskexecution_execution_id`
 - **定期存活日志** — Worker 与 Crontab 主循环在长时间无消息/无任务时按 `DJANGO_SIMPLETASK_LOG_INTERVAL`（默认 300 秒）定期输出存活日志，并统一带时间戳格式，便于运维确认进程未死循环
-- **MQ 日志降噪** — MQ 消费/发布异常及 Redis 连接失败、锁续期失败改为 `error`/`warning` 级别且无堆栈（默认按间隔节流），避免刷屏；提供 `--debug` 时输出完整堆栈
+- **MQ 日志降噪** — MQ 消费/发布异常及 Redis 连接失败改为 `error`/`warning` 级别且无堆栈（默认按间隔节流），避免刷屏；提供 `--debug` 时输出完整堆栈。注：此处所指的"锁续期失败"是 0.2.4 版本引入的自定义锁续期机制，自 globallock>=0.2.0 起该机制已**移除**，改由 globallock 内置看门狗在 lockman/lock 作用域内自动续期，无需（也无从）单独记录续期失败日志
 - **新增配置** — `DJANGO_SIMPLETASK_LOG_INTERVAL` 控制死循环存活日志与异常节流日志的输出间隔（秒）
 
 ### 0.2.3

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/README.md

@@ -103,6 +103,7 @@ DJANGO_SIMPLETASK_BROKER_URL = 'amqp://guest:guest@127.0.0.1:5672//'
 # DJANGO_SIMPLETASK_REDIS_MQ_HOST = '127.0.0.1'       # MESSAGE_QUEUE_TYPE='redis' 时
 # DJANGO_SIMPLETASK_REDIS_MQ_PORT = 6379
 # DJANGO_SIMPLETASK_REDIS_MQ_DB = 0
+# DJANGO_SIMPLETASK_REDIS_MQ_PASSWORD = None          # Redis MQ 需认证时设置
 
 # ── 分布式锁与 Worker 注册中心（Redis）────────────────────────
 # 默认锁引擎 DjangoRedisGlobalLock 复用 CACHES['default']，需为 Redis 缓存
@@ -113,13 +114,16 @@ CACHES = {
         'OPTIONS': {'CLIENT_CLASS': 'django_redis.client.DefaultClient'},
     },
 }
-# 如需独立连接参数（锁与 Worker 注册中心共用同一 host/port/db）：
+# 如需独立连接参数（锁与 Worker 注册中心共用同一 host/port/db/password）：
 # DJANGO_SIMPLETASK_LOCK_CONFIG = {
 #     'global_lock_engine_class': 'globallock.redis_global_lock.RedisGlobalLock',
-#     'global_lock_engine_options': {'host': '127.0.0.1', 'port': 6379, 'db': 0},
+#     'global_lock_engine_options': {'host': '127.0.0.1', 'port': 6379, 'db': 0,
+#                                    'password': '<redis 密码，无需认证可省略>'},
 # }
-DJANGO_SIMPLETASK_LOCK_TIMEOUT = 600                 # 锁超时（秒）
-DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL = 60           # 锁续期间隔（秒）
+# 注：globallock>=0.2.0 已取消按 timeout 自动释放的概念。锁的有效期由
+# lockman/lock 作用域自行管理，作用域未结束前锁持续有效（内置看门狗自动续期），
+# 锁在 `with` 块退出或进程消亡时自动释放。已移除 DJANGO_SIMPLETASK_LOCK_TIMEOUT
+# 与 DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL，请勿再配置这两项。
 
 # ── Key 前缀与队列路由 ───────────────────────────────────────
 DJANGO_SIMPLETASK_KEY_PREFIX = 'myproject'           # Redis key 前缀，默认取 ROOT_URLCONF 首段
@@ -169,11 +173,9 @@ django_app_requires_patch_all()
 | `DJANGO_SIMPLETASK_BROKER_URL` | `None` | **优先级最高**，设置后忽略下方 MQ 类型/连接参数。生产建议统一使用完整 URL，便于复用云厂商连接串与凭据管理 |
 | `DJANGO_SIMPLETASK_MESSAGE_QUEUE_TYPE` | `'memory'` | `memory` 仅用于开发调试；**生产必须改为 `rabbitmq` 或 `redis`**，否则消息不持久化、跨进程 Worker 无法消费 |
 | `DJANGO_SIMPLETASK_RABBITMQ_HOST/PORT/USER/PASSWORD` | `127.0.0.1 / 5672 / guest / guest` | 类型为 `rabbitmq` 且未设 `BROKER_URL` 时生效。生产务必更换默认 `guest` 凭据 |
-| `DJANGO_SIMPLETASK_REDIS_MQ_HOST/PORT/DB` | `127.0.0.1 / 6379 / 0` | 类型为 `redis` 时生效。建议与锁/缓存使用**不同 db**，避免 key 冲突与互相阻塞 |
+| `DJANGO_SIMPLETASK_REDIS_MQ_HOST/PORT/DB/PASSWORD` | `127.0.0.1 / 6379 / 0 / None` | 类型为 `redis` 时生效。建议与锁/缓存使用**不同 db**，避免 key 冲突与互相阻塞。Redis 需认证时设置 `PASSWORD` |
 | `CACHES['default']` | — | 默认锁引擎 `DjangoRedisGlobalLock` 依赖它，**必须配置为 Redis 缓存** |
-| `DJANGO_SIMPLETASK_LOCK_CONFIG` | `None`（默认复用缓存锁） | 需要独立连接参数时显式配置。**注意**：Worker 注册中心（心跳/状态）也读取该配置的 `host/port/db`，未配置时固定连 `127.0.0.1:6379/0` |
-| `DJANGO_SIMPLETASK_LOCK_TIMEOUT` | `600` | 锁自动释放时间，应**大于单任务最长执行时长**；过短会导致长任务执行中被其他 Worker 抢锁 |
-| `DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL` | `60` | 锁续期间隔，应**远小于 `LOCK_TIMEOUT`**（默认 600 的 1/10） |
+| `DJANGO_SIMPLETASK_LOCK_CONFIG` | `None`（默认复用缓存锁） | 需要独立连接参数时显式配置（`global_lock_engine_options` 支持 `host/port/db/password`）。**注意**：Worker 注册中心（心跳/状态）也读取该配置的 `host/port/db/password`，未配置时固定连 `127.0.0.1:6379/0`。globallock>=0.2.0 起锁有效期由 lockman/lock 作用域管理（内置看门狗自动续期），**不再需要配置 `LOCK_TIMEOUT` / `LOCK_RENEW_INTERVAL`** |
 | `DJANGO_SIMPLETASK_KEY_PREFIX` | 自动取 `ROOT_URLCONF` 首段 | 生产建议**显式指定**，多项目共用 Redis 时避免 key 冲突 |
 | `DJANGO_SIMPLETASK_DEFAULT_QUEUE` | `{prefix}:...:queue:default` | 默认队列名。多环境（dev/staging/prod）建议加环境后缀隔离 |
 | `DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE` | `{prefix}:...:queue:high_priority` | 高优先级队列，**需单独启动 Worker 消费** |
@@ -646,6 +648,8 @@ python3 -m pytest django_simpletask5_example/tests
 
 测试套件覆盖 Redis、DB、MQ 连接中断后的自动恢复场景，详见 `django_simpletask5_example/tests/test_resilience_recovery.py`。
 
+**测试输出约定**：单元测试中对预期会触发的错误（如无效 UUID 校验、毒消息丢弃、消费者断连、执行器加载失败等）所输出的错误日志，必须在测试内屏蔽，避免污染测试输出。统一使用 `django_simpletask5_example.tests.suppress_expected_errors` 上下文管理器（整体禁用日志）或 `patch.object(..., 'logger')`（断言同时校验日志）进行屏蔽。
+
 ## 架构
 
 ```
@@ -658,6 +662,14 @@ Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保
 
 ## Releases
 
+### 0.2.7
+
+- **运行中任务回收机制重构** — 取消原先按 `expire_time` 将 running 直接判为超时的语义；`StatusCheckExecutor` 仅兜底回收长期未被 Worker 获取的 pending。新增 `core/reclaim`，由 crontab 每 ~5 秒基于执行锁探测运行中任务：锁已过期（执行器异常退出）即快速重投或直接置失败，降低孤儿任务滞留时间
+- **重试不再搁浅任务** — 失败重试先落库 `retry` 再发布重试消息，发布失败则 requeue 当前消息，杜绝任务永久停在无人处理的 `retry` 状态；KombuQueue 依据 AMQP `x-death` 上限丢弃毒消息，避免无限 requeue 造成的队头阻塞与空转
+- **消费者重连提示** — Worker 断连重连成功后输出 `Consumer connection restored` 恢复日志，便于运维确认消费通道已恢复
+- **安全与健壮性加固** — broker 账号/密码按百分号编码、脚本白名单按路径段边界匹配、signals 快照按实例隔离，覆盖相关回归测试
+- **新增测试约定** — 单元测试中对预期触发（如无效 UUID 校验、毒消息丢弃、消费者断连、执行器加载失败等）产生的错误日志必须屏蔽输出，统一使用 `django_simpletask5_example.tests.suppress_expected_errors` 或替换 logger，保证测试输出干净可读；本次同步清理全部此类预期错误日志
+
 ### 0.2.6
 
 - **新增 `canceled` 状态** — 取消已发布但未执行的任务改为独立的终态 `canceled`（原复用 `failed`），Worker 消费到已取消消息时直接跳过；Admin 取消操作、归档/清理/统计（新增 `canceled_count`）、Dashboard 状态图均纳入该状态，取消与执行失败可清晰区分
@@ -674,7 +686,7 @@ Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保
 
 - **破坏性变更**: `TaskExecution` 主键由 `execution_id`（UUID）改为默认自增 `id`，`execution_id` 变为 `unique=True` 的唯一标识字段。已有数据库需要执行迁移 `0010_taskexecution_id_alter_taskexecution_execution_id`
 - **定期存活日志** — Worker 与 Crontab 主循环在长时间无消息/无任务时按 `DJANGO_SIMPLETASK_LOG_INTERVAL`（默认 300 秒）定期输出存活日志，并统一带时间戳格式，便于运维确认进程未死循环
-- **MQ 日志降噪** — MQ 消费/发布异常及 Redis 连接失败、锁续期失败改为 `error`/`warning` 级别且无堆栈（默认按间隔节流），避免刷屏；提供 `--debug` 时输出完整堆栈
+- **MQ 日志降噪** — MQ 消费/发布异常及 Redis 连接失败改为 `error`/`warning` 级别且无堆栈（默认按间隔节流），避免刷屏；提供 `--debug` 时输出完整堆栈。注：此处所指的"锁续期失败"是 0.2.4 版本引入的自定义锁续期机制，自 globallock>=0.2.0 起该机制已**移除**，改由 globallock 内置看门狗在 lockman/lock 作用域内自动续期，无需（也无从）单独记录续期失败日志
 - **新增配置** — `DJANGO_SIMPLETASK_LOG_INTERVAL` 控制死循环存活日志与异常节流日志的输出间隔（秒）
 
 ### 0.2.3

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/core/cronjob_registry.py

@@ -94,10 +94,10 @@ def register_builtin_cronjobs():
 
     register_cronjob(
         uid='simpletask_status_check',
-        display_name=_('Task Timeout Detection'),
+        display_name=_('Pickup Timeout Detection'),
         cron_expression='* * * * *',
         executor_class='django_simpletask5.executors.status_check.StatusCheckExecutor',
-        description='Scan long-running pending/running tasks and mark them as timeout',
+        description='Scan pending tasks that were never picked up and mark them as timeout for retry. Running tasks are not time-limited: orphans are reclaimed by the scheduler based on execution-lock expiry',
     )
     register_cronjob(
         uid='simpletask_retry_timeout',

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/core/defaults.py

@@ -13,9 +13,6 @@ def _compute_key_prefix() -> str:
 
 DJANGO_SIMPLETASK_KEY_PREFIX = _compute_key_prefix()
 
-DJANGO_SIMPLETASK_LOCK_TIMEOUT = getattr(settings, 'DJANGO_SIMPLETASK_LOCK_TIMEOUT', 600)
-DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL = getattr(settings, 'DJANGO_SIMPLETASK_LOCK_RENEW_INTERVAL', 60)
-
 DJANGO_SIMPLETASK_SHUTDOWN_TIMEOUT = getattr(settings, 'DJANGO_SIMPLETASK_SHUTDOWN_TIMEOUT', 30)
 DJANGO_SIMPLETASK_LOG_INTERVAL = getattr(settings, 'DJANGO_SIMPLETASK_LOG_INTERVAL', 300)
 DJANGO_SIMPLETASK_WORKER_HEARTBEAT_INTERVAL = getattr(settings, 'DJANGO_SIMPLETASK_WORKER_HEARTBEAT_INTERVAL', 60)

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/core/message_queue.py

@@ -1,6 +1,7 @@
 import logging
 import socket
 import time
+from urllib.parse import quote
 
 from django.conf import settings
 from kombu import Connection, Exchange, Queue, Producer, Consumer
@@ -10,6 +11,11 @@ from django_simpletask5.core.defaults import DJANGO_SIMPLETASK_LOG_INTERVAL
 logger = logging.getLogger(__name__)
 
 
+def _quote_url_component(value):
+    """URL 编码账号/密码，避免密码含 @ : / % 等保留字符破坏连接串解析。"""
+    return quote(str(value), safe='')
+
+
 def _get_broker_url():
     url = getattr(settings, 'DJANGO_SIMPLETASK_BROKER_URL', None)
     if url:
@@ -20,12 +26,16 @@ def _get_broker_url():
         port = getattr(settings, 'DJANGO_SIMPLETASK_RABBITMQ_PORT', 5672)
         user = getattr(settings, 'DJANGO_SIMPLETASK_RABBITMQ_USER', 'guest')
         pw = getattr(settings, 'DJANGO_SIMPLETASK_RABBITMQ_PASSWORD', 'guest')
+        user = _quote_url_component(user)
+        pw = _quote_url_component(pw)
         return f'amqp://{user}:{pw}@{host}:{port}//'
     if transport == 'redis':
         host = getattr(settings, 'DJANGO_SIMPLETASK_REDIS_MQ_HOST', '127.0.0.1')
         port = getattr(settings, 'DJANGO_SIMPLETASK_REDIS_MQ_PORT', 6379)
         db = getattr(settings, 'DJANGO_SIMPLETASK_REDIS_MQ_DB', 0)
-        return f'redis://{host}:{port}/{db}'
+        pw = getattr(settings, 'DJANGO_SIMPLETASK_REDIS_MQ_PASSWORD', None)
+        auth = f':{_quote_url_component(pw)}@' if pw else ''
+        return f'redis://{auth}{host}:{port}/{db}'
     return 'memory://'
 
 
@@ -89,15 +99,42 @@ class KombuQueue:
         try:
             result = callback(body)
             if result is False:
+                if KombuQueue._exceeds_max_redeliveries(message):
+                    logger.error(
+                        'Dropping message after too many redeliveries (possible poison message): %s',
+                        body,
+                    )
+                    message.ack()
+                    return
                 message.reject(requeue=True)
                 return
         except Exception as e:
             logger.error('Error in message callback: %s', e)
+            if KombuQueue._exceeds_max_redeliveries(message):
+                logger.error('Dropping message after too many redeliveries (possible poison message): %s', body)
+                message.ack()
+                return
             message.reject(requeue=True)
             return
         if auto_ack:
             message.ack()
 
+    @staticmethod
+    def _exceeds_max_redeliveries(message):
+        """判断一条消息是否已被反复重投过多次（AMQP x-death 计数）。
+
+        防止“无法服务/暂时性失败”的消息被无限 requeue 造成队头阻塞与 CPU 空转。
+        非 AMQP 传输（memory / redis）不提供 x-death 头，返回 False 保持原行为。
+        """
+        limit = getattr(settings, 'DJANGO_SIMPLETASK_MAX_REQUEUE_DELIVERIES', 100)
+        headers = getattr(message, 'headers', None) or {}
+        x_death = headers.get('x-death') or []
+        total = 0
+        for entry in x_death:
+            if isinstance(entry, dict):
+                total += int(entry.get('count', 0) or 0)
+        return total >= limit
+
     def stop(self):
         self._stopped = True
 

django_simpletask5-0.2.7/django_simpletask5/core/reclaim.py

@@ -0,0 +1,189 @@
+"""基于执行锁的孤儿任务快速回收。
+
+设计语义（globallock>=0.2.0 起）：
+- 任务被 worker 获取（status='running'）后，worker 持有该执行对应的分布式锁，
+  并由 globallock 的看门狗线程自动续期。只要执行器进程存活，锁就一直有效，
+  任务可以无限期运行，不受任何“任务超时”限制。
+- 只有当执行器异常退出（进程被杀/崩溃）时，锁才会在 TTL 后自动过期。
+  锁过期即代表执行器已异常退出，此时任务需要被回收：
+  - 仍有重试次数 -> 状态置为 retry、retry_count+1 并立即重新投递
+  - 重试耗尽     -> 状态置为 failed
+- 回收在 crontab 调度进程的每次 tick（约 5 秒）内直接执行，保证快速回收，
+  不依赖分钟级的 cron 执行器。
+"""
+
+import logging
+from datetime import timedelta
+
+from django.conf import settings
+from django.utils import timezone
+
+from django_simpletask5.models import TaskExecution
+
+logger = logging.getLogger(__name__)
+
+# 仅回收“开始运行已超过该时长”的任务，避免对刚被 worker 获取的任务做无谓探测
+RECLAIM_STARTED_AGE_SECONDS = 35
+# 单次 tick 最多探测的 running 任务数，防止异常情况下拖慢调度
+RECLAIM_SCAN_LIMIT = 200
+# globallock 默认锁 key 前缀（与 globallock.constants 保持一致，允许被配置覆盖）
+_DEFAULT_LOCK_KEY_PREFIX = '_glocks:'
+
+
+def _lock_config():
+    config = getattr(settings, 'DJANGO_SIMPLETASK_LOCK_CONFIG', None)
+    if not config:
+        from django_simpletask5.core.lock import _default_lock_config
+        config = _default_lock_config()
+    return config
+
+
+def _execution_lock_name(execution_id):
+    from django_simpletask5.core.defaults import DJANGO_SIMPLETASK_KEY_PREFIX
+    return f'{DJANGO_SIMPLETASK_KEY_PREFIX}:django-simpletask5:execution:{execution_id}'
+
+
+def _lock_key_prefix(config):
+    return config.get('global_lock_key_prefix', _DEFAULT_LOCK_KEY_PREFIX)
+
+
+def _get_probe_client():
+    """返回用于探测执行锁的 redis 客户端。
+
+    仅支持 redis 家族的锁引擎（DjangoRedisGlobalLock / RedisGlobalLock），
+    其它引擎（etcd / zookeeper 等）无法低成本探测，返回 None 表示跳过回收。
+    """
+    config = _lock_config()
+    engine = config.get('global_lock_engine_class', '')
+    options = config.get('global_lock_engine_options', {}) or {}
+    try:
+        if engine.endswith('.django_redis_global_lock.DjangoRedisGlobalLock'):
+            from django_redis import get_redis_connection
+            return get_redis_connection(options.get('redis-cache-name', 'default'))
+        if engine.endswith('.redis_global_lock.RedisGlobalLock'):
+            import redis as _redis
+            return _redis.Redis(
+                host=options.get('host', '127.0.0.1'),
+                port=options.get('port', 6379),
+                db=options.get('db', 0),
+                password=options.get('password', None) or None,
+                decode_responses=True,
+                socket_connect_timeout=3,
+            )
+    except Exception:
+        logger.exception('Failed to build execution-lock probe client')
+    return None
+
+
+def _execution_lock_exists(client, execution_id):
+    key = _lock_key_prefix(_lock_config()) + _execution_lock_name(execution_id)
+    return bool(client.exists(key))
+
+
+def _publish_requeue(execution):
+    """向默认队列重新投递一次该 execution 的消息。
+
+    单次尝试即可：crontab 每 ~5s 会再次进入回收流程，失败的任务下一轮会重试。
+    """
+    from django_simpletask5.core.defaults import DJANGO_SIMPLETASK_DEFAULT_QUEUE
+    from django_simpletask5.core.message_queue import get_message_queue
+
+    message = {
+        'execution_id': str(execution.execution_id),
+        'task_id': str(execution.task_id) if execution.task_id else None,
+        'trigger_event': execution.trigger_event,
+        'executor_class': execution.executor_class,
+    }
+    try:
+        get_message_queue().publish(
+            routing_key=DJANGO_SIMPLETASK_DEFAULT_QUEUE,
+            message=message,
+        )
+        return True
+    except Exception as e:
+        logger.warning('Reclaim: failed to republish execution %s: %s', execution.execution_id, e)
+        return False
+
+
+def reclaim_orphaned_executions(publish=None):
+    """扫描 status='running' 且执行锁已过期（执行器异常退出）的任务并回收。
+
+    publish 参数可注入，便于测试；默认使用 _publish_requeue。
+
+    返回统计 dict：{scanned, requeued, failed, skipped, publish_failures, supported}
+    """
+    from django.db import close_old_connections
+
+    close_old_connections()
+    stats = {
+        'scanned': 0,
+        'requeued': 0,
+        'failed': 0,
+        'skipped': 0,
+        'publish_failures': 0,
+        'supported': False,
+    }
+    if publish is None:
+        publish = _publish_requeue
+
+    client = _get_probe_client()
+    if client is None:
+        return stats
+    stats['supported'] = True
+
+    cutoff = timezone.now() - timedelta(seconds=RECLAIM_STARTED_AGE_SECONDS)
+    try:
+        running = list(
+            TaskExecution.objects.filter(
+                status='running',
+                started_at__isnull=False,
+                started_at__lte=cutoff,
+            ).order_by('started_at')[:RECLAIM_SCAN_LIMIT]
+        )
+    except Exception:
+        logger.exception('Reclaim: failed to query running executions')
+        return stats
+
+    for record in running:
+        stats['scanned'] += 1
+        try:
+            locked = _execution_lock_exists(client, record.execution_id)
+        except Exception:
+            logger.warning('Reclaim: lock probe failed for execution %s, will retry next tick', record.execution_id)
+            continue
+        if locked:
+            stats['skipped'] += 1
+            continue
+
+        try:
+            record = TaskExecution.objects.get(pk=record.pk)
+        except TaskExecution.DoesNotExist:
+            continue
+        if record.status != 'running':
+            stats['skipped'] += 1
+            continue
+
+        reason = 'Executor lost its execution lock (abnormal exit), reclaimed by scheduler'
+
+        if record.retry_count < record.max_retries:
+            if not publish(record):
+                stats['publish_failures'] += 1
+                continue
+            record.status = 'retry'
+            record.retry_count += 1
+            record.error_message = reason
+            record.save(update_fields=['status', 'retry_count', 'error_message', 'updated_at'])
+            stats['requeued'] += 1
+            logger.info('Reclaim: requeued orphaned running execution %s (attempt %d/%d)',
+                        record.execution_id, record.retry_count, record.max_retries)
+        else:
+            record.status = 'failed'
+            record.error_message = reason + ', no retry attempts remaining'
+            record.finished_at = timezone.now()
+            record.save(update_fields=['status', 'error_message', 'finished_at', 'updated_at'])
+            stats['failed'] += 1
+            logger.warning('Reclaim: failed orphaned running execution %s (retries exhausted)',
+                           record.execution_id)
+
+    close_old_connections()
+    return stats

django_simpletask5-0.2.7/django_simpletask5/core/security.py

@@ -0,0 +1,31 @@
+"""脚本白名单的路径判定工具。
+
+按“路径段”边界匹配：只有白名单条目本身或其**目录**下（不含前缀同名兄弟目录）
+的脚本才被允许，避免 ``/safe/scripts`` 误放行 ``/safe/scripts_evil/run.sh`` 之类。
+"""
+
+import os
+
+
+def is_allowed_script_path(script_path, whitelist):
+    """判断脚本路径是否位于白名单目录内或与白名单文件一致。
+
+    - 白名单为空 -> 不限制（True）。
+    - 白名单条目可以是目录或文件：
+      - 目录：允许该目录及其全部子目录下的脚本；
+      - 文件：仅允许与该文件路径完全一致的脚本。
+    """
+    if not whitelist:
+        return True
+    if not script_path:
+        return False
+    abs_path = os.path.abspath(script_path)
+    for entry in whitelist:
+        base = os.path.abspath(entry)
+        if abs_path == base:
+            return True
+        if base == os.sep:
+            return True
+        if abs_path.startswith(base.rstrip(os.sep) + os.sep):
+            return True
+    return False

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/core/signals.py

@@ -16,6 +16,26 @@ class _DeleteIntercepted(Exception):
 _pre_save_data = threading.local()
 
 
+def _init_snapshot_store():
+    if not hasattr(_pre_save_data, 'snapshots'):
+        _pre_save_data.snapshots = {}
+
+
+def _store_snapshot(instance, snapshot):
+    """按实例保存 pre_save 快照。
+
+    以 id(instance) 为键，使得同一线程内嵌套/连续的多次保存互不串扰，
+    每个实例在 post_save 时只取回属于它自己的快照。
+    """
+    _init_snapshot_store()
+    _pre_save_data.snapshots[id(instance)] = snapshot
+
+
+def _pop_snapshot(instance):
+    _init_snapshot_store()
+    return _pre_save_data.snapshots.pop(id(instance), None)
+
+
 @receiver(pre_save)
 def handle_task_pre_save(sender, instance, **kwargs):
     if not _is_task_subclass(sender):
@@ -23,11 +43,12 @@ def handle_task_pre_save(sender, instance, **kwargs):
     if instance.pk and not getattr(instance, '_skip_pre_save_snapshot', False):
         try:
             old = sender.objects.get(pk=instance.pk)
-            _pre_save_data.data = _model_to_dict(old)
+            snapshot = _model_to_dict(old)
         except sender.DoesNotExist:
-            _pre_save_data.data = None
+            snapshot = None
     else:
-        _pre_save_data.data = None
+        snapshot = None
+    _store_snapshot(instance, snapshot)
 
 
 @receiver(post_save)
@@ -40,7 +61,7 @@ def handle_task_post_save(sender, instance, created, **kwargs):
             trigger_event='create',
         )
     else:
-        old_data = getattr(_pre_save_data, 'data', None)
+        old_data = _pop_snapshot(instance)
         new_data = _model_to_dict(instance)
         if old_data:
             changed_fields = _get_changed_fields(old_data, new_data)

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/dashboards.py

@@ -45,7 +45,6 @@ class TaskDashboard(Dashboard):
         pending = TaskExecution.objects.filter(status="pending").count()
         running = TaskExecution.objects.filter(status="running").count()
         active_cronjobs = CronJob.objects.filter(is_active=True).count()
-        total_cronjobs = CronJob.objects.count()
         archives_count = TaskExecutionArchive.objects.count()
         failed_today = TaskExecution.objects.filter(
             created_at__date=today, status="failed"
@@ -54,8 +53,6 @@ class TaskDashboard(Dashboard):
         worker_stats = _get_worker_stats()
         worker_redis_available = worker_stats["redis_available"]
         worker_total = worker_stats["total"] if worker_redis_available else None
-        worker_idle = worker_stats["by_status"].get("idle", 0) if worker_redis_available else None
-        worker_running_count = worker_stats["by_status"].get("running", 0) if worker_redis_available else None
 
         success_rate = None
         if total_today > 0:

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/executors/bash_script.py

@@ -34,12 +34,10 @@ class BashScriptExecutor(BaseExecutor):
         env = params.get('env', {})
 
         if script_path:
+            from django_simpletask5.core.security import is_allowed_script_path
             script_whitelist = getattr(settings, 'DJANGO_SIMPLETASK_SCRIPT_WHITELIST', [])
-            if script_whitelist:
-                abs_path = os.path.abspath(script_path)
-                allowed = any(abs_path.startswith(os.path.abspath(p)) for p in script_whitelist)
-                if not allowed:
-                    raise RuntimeError('Script path not in whitelist')
+            if not is_allowed_script_path(script_path, script_whitelist):
+                raise RuntimeError('Script path not in whitelist')
             with open(script_path, 'r') as f:
                 script = f.read()
 

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/executors/python_script.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import os
 
 from django.conf import settings
 
@@ -31,12 +30,10 @@ class PythonScriptExecutor(BaseExecutor):
         args = params.get('args', [])
 
         if script_path:
+            from django_simpletask5.core.security import is_allowed_script_path
             script_whitelist = getattr(settings, 'DJANGO_SIMPLETASK_SCRIPT_WHITELIST', [])
-            if script_whitelist:
-                abs_path = os.path.abspath(script_path)
-                allowed = any(abs_path.startswith(os.path.abspath(p)) for p in script_whitelist)
-                if not allowed:
-                    raise RuntimeError('Script path not in whitelist')
+            if not is_allowed_script_path(script_path, script_whitelist):
+                raise RuntimeError('Script path not in whitelist')
             with open(script_path, 'r') as f:
                 script = f.read()
 

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/executors/retry_timeout.py

@@ -21,7 +21,6 @@ logger = logging.getLogger(__name__)
 class RetryTimeoutExecutor(BaseExecutor):
     def execute(self, execution: TaskExecution, task=None) -> str | None:
         from functools import partial
-        from django_simpletask5.core.publisher import _publish_message
 
         timeout_records = TaskExecution.objects.filter(
             status='timeout',

{django_simpletask5-0.2.6 → django_simpletask5-0.2.7}/django_simpletask5/executors/status_check.py

@@ -10,9 +10,19 @@ logger = logging.getLogger(__name__)
 
 
 class StatusCheckExecutor(BaseExecutor):
+    """Pickup-timeout detection for tasks that were never acquired.
+
+    语义（globallock>=0.2.0 起）：
+    - 从未被 worker 获取的 pending 任务超过 pickup 期限（expire_time）后，视为
+      消息丢失的兜底，标记为 timeout，由 RetryTimeoutExecutor 重新投递。
+    - 已被获取（running）的任务**不再**依据 expire_time 判超时：只要执行器进程
+      存活（执行锁被自动续期），任务即可无限期运行；执行器异常退出导致的孤儿
+      running 任务由 core.reclaim（crontab 高频回收）基于执行锁过期来回收。
+    """
+
     def execute(self, execution: TaskExecution, task=None) -> str | None:
         overdue = TaskExecution.objects.filter(
-            status__in=['pending', 'running'],
+            status='pending',
             expire_time__lt=Now(),
         )
 
@@ -20,7 +30,7 @@ class StatusCheckExecutor(BaseExecutor):
         for exec_record in overdue:
             exec_record.status = 'timeout'
             exec_record.error_message = json.dumps({
-                'reason': 'Status check timeout',
+                'reason': 'Pickup timeout',
             })
             exec_record.save(update_fields=['status', 'error_message', 'updated_at'])
             count += 1