django-simpletask5 0.2.0__tar.gz → 0.2.2__tar.gz

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-simpletask5
-Version: 0.2.0
+Version: 0.2.2
 Summary: Lightweight async task execution framework for Django
 Author-email: rRR0VrFP <rrr0vrfp@qq.com>
 Maintainer-email: rRR0VrFP <rrr0vrfp@qq.com>
@@ -29,6 +29,7 @@ Requires-Dist: django-app-requires>=0.3.6
 Requires-Dist: django-admin-dashboards>=0.1.1
 Requires-Dist: django-checkbox-normalize>=0.2.2
 Requires-Dist: django-tabbed-changeform-admin>=0.1.9
+Requires-Dist: django-static-fontawesome>=5.0.2
 Requires-Dist: cryptography>=48.0.0
 Requires-Dist: croniter>=6.2.2
 Requires-Dist: requests>=2.34.2
@@ -50,7 +51,8 @@ Dynamic: license-file
 - **自定义事件** — 通过 `task.trigger('event_name')` 触发任意事件
 - **灵活的执行器映射** — 不同事件可绑定不同的执行器类
 - **队列路由** — 不同事件可路由到不同优先级队列
-- **重试与超时** — 失败自动重试（指数退避），支持超时检测
+- **重试与超时** — 失败自动重试（指数退避），支持执行超时与 Pickup 超时两种检测
+- **拒绝回退** — 执行器可通过 `RejectException` 拒绝当前任务，消息自动重新入队等待下次调度
 - **加密字段** — 敏感数据自动加密存储
 - **Cron 调度** — 内置 crontab 守护进程，支持代码注册与数据库覆盖
 - **归档统计** — 已完成执行记录自动归档为加密 JSONL，并生成日统计
@@ -134,6 +136,19 @@ DJANGO_SIMPLETASK_RABBITMQ_PASSWORD = 'guest'
 
 ### 分布式锁
 
+默认使用 Django 缓存中的 Redis 连接，只需配置好 Django 的 `CACHES`：
+
+```python
+CACHES = {
+    'default': {
+        'BACKEND': 'django_redis.cache.RedisCache',
+        'LOCATION': 'redis://127.0.0.1:6379/1',
+    },
+}
+```
+
+如需自定义锁引擎或连接参数：
+
 ```python
 DJANGO_SIMPLETASK_LOCK_CONFIG = {
     'global_lock_engine_class': 'globallock.redis_global_lock.RedisGlobalLock',
@@ -149,17 +164,22 @@ DJANGO_SIMPLETASK_LOCK_TIMEOUT = 600  # 锁超时时间（秒）
 ### 队列路由
 
 ```python
-DJANGO_SIMPLETASK_DEFAULT_QUEUE = 'django_simpletask5.queue.default'          # 默认队列
-DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = 'django_simpletask5.queue.high_priority'  # 高优先级队列
+DJANGO_SIMPLETASK_DEFAULT_QUEUE = 'myproject:django-simpletask5:queue:default'          # 默认队列
+DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = 'myproject:django-simpletask5:queue:high_priority'  # 高优先级队列
 ```
 
 ### 执行与重试
 
 ```python
-DJANGO_SIMPLETASK_DEFAULT_MAX_RETRIES = 3        # 默认最大重试次数
-DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS = 600  # 默认执行超时时间（秒）
+DJANGO_SIMPLETASK_DEFAULT_MAX_RETRIES = 3                  # 默认最大重试次数
+DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS = 600            # 默认执行超时（秒），任务开始执行后的超时限制
+DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS = 3600    # 默认 Pickup 超时（秒），等待 Worker 消费的时间限制
 ```
 
+框架区分两种超时：
+- **执行超时**（`timeout_seconds`）— 任务进入 `running` 状态后，必须在指定时间内完成，否则被 `StatusCheckExecutor` 标记超时。适用于保护实际执行不 hang 死。
+- **Pickup 超时**（`pickup_timeout_seconds`）— 任务创建后等待 Worker 消费的时间上限，也用于被拒绝回退后等待重新调度的保护。通常设得比执行超时更长，因为排队等待时间不可控。
+
 ### 归档
 
 ```python
@@ -235,6 +255,33 @@ class OrderCreateExecutor(BaseExecutor):
         return 'ok'
 ```
 
+执行器可以通过 `executor_class` 属性覆盖超时配置：
+
+```python
+class OrderCreateExecutor(BaseExecutor):
+    timeout_seconds = 300                       # 执行超时 5 分钟
+    pickup_timeout_seconds = 1800               # Pickup 超时 30 分钟
+```
+
+### 拒绝回退
+
+执行器在执行过程中遇到临时条件不满足（如资源上限），可以抛出 `RejectException` 拒绝本次执行：
+
+```python
+from django_simpletask5.executors.exceptions import RejectException
+
+class MyExecutor(BaseExecutor):
+    def execute(self, execution: TaskExecution) -> str | None:
+        if not self._can_proceed():
+            raise RejectException('Resource limit reached, try again later')
+```
+
+框架捕获后会：
+- 调用 `message.reject(requeue=True)` 将消息放回队列尾部，下次重新调度
+- `TaskExecution` 状态恢复为 `pending`，`started_at` 清空，等待下次 Worker 消费
+- **不消耗**重试次数
+- 刷新 `expire_time`（使用 Pickup 超时），防止被 `StatusCheckExecutor` 误回收
+
 ### 3. 启动 Worker
 
 默认只监听 `default` 队列，`high_priority` 队列需要单独启动 Worker 处理。
@@ -263,6 +310,31 @@ order = OrderTask.objects.get(order_id='ORD-001')
 order.trigger('refund', extra_context={'refund_amount': '50.00'})
 ```
 
+### 6. 抑制异步消息
+
+创建或更新 Task 时，可通过 `_skip_publish` 机制禁止触发 RabbitMQ 消息通知，不会创建 `TaskExecution` 也不发送异步消息。提供四种使用方式：
+
+```python
+# 方式一：设置实例属性
+order = OrderTask(order_id='ORD-001', customer_name='Test', amount=Decimal('100.00'))
+order._skip_publish = True
+order.save()
+
+# 方式二：调用 skip_publish() 方法（支持链式调用）
+order.skip_publish().save()
+
+# 方式三：save 时传入 skip_publish=True
+order.save(skip_publish=True)
+
+# 方式四：构造或 create 时直接传入（推荐）
+OrderTask.objects.create(
+    order_id='ORD-001', customer_name='Test', amount=Decimal('100.00'),
+    skip_publish=True,
+)
+```
+
+`_skip_publish` 是临时实例属性，不会持久化到数据库，后续正常操作不受影响。
+
 ## Cron 任务
 
 ### 在代码中定义 Cron 任务
@@ -315,11 +387,34 @@ Task 模型变更 → Django 信号 → 创建 TaskExecution 并发布到消息
                                                     ↓
 Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保存结果
                                                     ↓
-失败时自动重试，完成后归档
+失败时自动重试/拒绝时重新入队，完成后归档
 ```
 
 ## Releases
 
+### 0.2.2
+
+- **抑制异步消息** — 新增 `_skip_publish` 机制，创建/更新/删除 Task 时可通过 `skip_publish()` 方法、`save(skip_publish=True)`、构造时传入 `skip_publish=True` 等方式禁止触发 RabbitMQ 消息通知
+- **批量创建触发异步消息** — `TaskQuerySet` + `TaskManager` 接管 `bulk_create`，批量创建 Task 后自动生成 TaskExecution 并推送 MQ；子类覆盖 `objects` 时发出警告提示
+- **分布式锁默认引擎** — 默认使用 `DjangoRedisGlobalLock`，复用 Django `CACHES['default']` 配置（需为 Redis 缓存），无需手动配置 `DJANGO_SIMPLETASK_LOCK_CONFIG`
+- **Redis key 命名统一** — 所有 Redis key 格式规范为 `{项目前缀}:django-simpletask5:{用途}:{id}`，项目前缀从 `ROOT_URLCONF` 自动提取，也可通过 `DJANGO_SIMPLETASK_KEY_PREFIX` 显式覆盖
+- **CronJob 管理增强** — 新增 `app_label` 字段（自动检测），列表页展示并支持过滤
+- **内置 CronJob 重命名** — Status Check → Task Timeout Detection，Retry Timeout → Retry Failed Tasks，Ping/Pong → Health Check 等
+- **Dashboard 重做** — 新增今日失败卡片，成功率按 90%/80% 分绿色/橙色/红色三级，卡片颜色统一使用 info 蓝色
+- **Pending/Running 显示修复** — 改为展示 `pending / running` 双值而非仅 pending
+- **成功率显示优化** — `(22/25)` 与 `88%` 同行显示，字号缩小颜色淡化，高度对齐
+- **Redis 不可达降级** — Worker 数量显示 `-` 而非 `0`，区分无数据与异常
+- **按钮优化** — 改用 Font Awesome 图标，统一 `min-width` 对齐，title 改为中文描述
+- **翻译补充** — 补充 Run/Activate/Deactivate 及所有内置 CronJob 名称的中文翻译
+- **新增依赖** — `django-static-fontawesome` 用于按钮图标
+- **示例应用** — 示例 cronjobs 模块在 AppConfig.ready() 中导入确保注册生效
+
+### 0.2.1
+
+- **拒绝回退机制** — 新增 `RejectException`，执行器可抛出该异常拒绝当前任务，消息自动重新入队等待下次调度，不消耗重试次数
+- **区分两种超时** — 引入 `pickup_timeout_seconds`（等待 Worker 消费超时）与 `timeout_seconds`（执行超时）两种超时配置，`expire_time` 改用 Pickup 超时计算，超时检测更精准
+- **文档更新** — README 补充拒绝回退机制的使用说明和两种超时的详细解释
+
 ### 0.2.0
 
 - **破坏性变更**: 移除 `Task` 模型上的自定义主键，`task_id` 不再是主键字段，改为 `unique=True` 的唯一标识字段。所有 `Task` 子模型将自动获得 Django 默认的自增 `id` 主键。已有数据库需要迁移处理。

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/README.md

@@ -11,7 +11,8 @@
 - **自定义事件** — 通过 `task.trigger('event_name')` 触发任意事件
 - **灵活的执行器映射** — 不同事件可绑定不同的执行器类
 - **队列路由** — 不同事件可路由到不同优先级队列
-- **重试与超时** — 失败自动重试（指数退避），支持超时检测
+- **重试与超时** — 失败自动重试（指数退避），支持执行超时与 Pickup 超时两种检测
+- **拒绝回退** — 执行器可通过 `RejectException` 拒绝当前任务，消息自动重新入队等待下次调度
 - **加密字段** — 敏感数据自动加密存储
 - **Cron 调度** — 内置 crontab 守护进程，支持代码注册与数据库覆盖
 - **归档统计** — 已完成执行记录自动归档为加密 JSONL，并生成日统计
@@ -95,6 +96,19 @@ DJANGO_SIMPLETASK_RABBITMQ_PASSWORD = 'guest'
 
 ### 分布式锁
 
+默认使用 Django 缓存中的 Redis 连接，只需配置好 Django 的 `CACHES`：
+
+```python
+CACHES = {
+    'default': {
+        'BACKEND': 'django_redis.cache.RedisCache',
+        'LOCATION': 'redis://127.0.0.1:6379/1',
+    },
+}
+```
+
+如需自定义锁引擎或连接参数：
+
 ```python
 DJANGO_SIMPLETASK_LOCK_CONFIG = {
     'global_lock_engine_class': 'globallock.redis_global_lock.RedisGlobalLock',
@@ -110,17 +124,22 @@ DJANGO_SIMPLETASK_LOCK_TIMEOUT = 600  # 锁超时时间（秒）
 ### 队列路由
 
 ```python
-DJANGO_SIMPLETASK_DEFAULT_QUEUE = 'django_simpletask5.queue.default'          # 默认队列
-DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = 'django_simpletask5.queue.high_priority'  # 高优先级队列
+DJANGO_SIMPLETASK_DEFAULT_QUEUE = 'myproject:django-simpletask5:queue:default'          # 默认队列
+DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = 'myproject:django-simpletask5:queue:high_priority'  # 高优先级队列
 ```
 
 ### 执行与重试
 
 ```python
-DJANGO_SIMPLETASK_DEFAULT_MAX_RETRIES = 3        # 默认最大重试次数
-DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS = 600  # 默认执行超时时间（秒）
+DJANGO_SIMPLETASK_DEFAULT_MAX_RETRIES = 3                  # 默认最大重试次数
+DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS = 600            # 默认执行超时（秒），任务开始执行后的超时限制
+DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS = 3600    # 默认 Pickup 超时（秒），等待 Worker 消费的时间限制
 ```
 
+框架区分两种超时：
+- **执行超时**（`timeout_seconds`）— 任务进入 `running` 状态后，必须在指定时间内完成，否则被 `StatusCheckExecutor` 标记超时。适用于保护实际执行不 hang 死。
+- **Pickup 超时**（`pickup_timeout_seconds`）— 任务创建后等待 Worker 消费的时间上限，也用于被拒绝回退后等待重新调度的保护。通常设得比执行超时更长，因为排队等待时间不可控。
+
 ### 归档
 
 ```python
@@ -196,6 +215,33 @@ class OrderCreateExecutor(BaseExecutor):
         return 'ok'
 ```
 
+执行器可以通过 `executor_class` 属性覆盖超时配置：
+
+```python
+class OrderCreateExecutor(BaseExecutor):
+    timeout_seconds = 300                       # 执行超时 5 分钟
+    pickup_timeout_seconds = 1800               # Pickup 超时 30 分钟
+```
+
+### 拒绝回退
+
+执行器在执行过程中遇到临时条件不满足（如资源上限），可以抛出 `RejectException` 拒绝本次执行：
+
+```python
+from django_simpletask5.executors.exceptions import RejectException
+
+class MyExecutor(BaseExecutor):
+    def execute(self, execution: TaskExecution) -> str | None:
+        if not self._can_proceed():
+            raise RejectException('Resource limit reached, try again later')
+```
+
+框架捕获后会：
+- 调用 `message.reject(requeue=True)` 将消息放回队列尾部，下次重新调度
+- `TaskExecution` 状态恢复为 `pending`，`started_at` 清空，等待下次 Worker 消费
+- **不消耗**重试次数
+- 刷新 `expire_time`（使用 Pickup 超时），防止被 `StatusCheckExecutor` 误回收
+
 ### 3. 启动 Worker
 
 默认只监听 `default` 队列，`high_priority` 队列需要单独启动 Worker 处理。
@@ -224,6 +270,31 @@ order = OrderTask.objects.get(order_id='ORD-001')
 order.trigger('refund', extra_context={'refund_amount': '50.00'})
 ```
 
+### 6. 抑制异步消息
+
+创建或更新 Task 时，可通过 `_skip_publish` 机制禁止触发 RabbitMQ 消息通知，不会创建 `TaskExecution` 也不发送异步消息。提供四种使用方式：
+
+```python
+# 方式一：设置实例属性
+order = OrderTask(order_id='ORD-001', customer_name='Test', amount=Decimal('100.00'))
+order._skip_publish = True
+order.save()
+
+# 方式二：调用 skip_publish() 方法（支持链式调用）
+order.skip_publish().save()
+
+# 方式三：save 时传入 skip_publish=True
+order.save(skip_publish=True)
+
+# 方式四：构造或 create 时直接传入（推荐）
+OrderTask.objects.create(
+    order_id='ORD-001', customer_name='Test', amount=Decimal('100.00'),
+    skip_publish=True,
+)
+```
+
+`_skip_publish` 是临时实例属性，不会持久化到数据库，后续正常操作不受影响。
+
 ## Cron 任务
 
 ### 在代码中定义 Cron 任务
@@ -276,11 +347,34 @@ Task 模型变更 → Django 信号 → 创建 TaskExecution 并发布到消息
                                                     ↓
 Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保存结果
                                                     ↓
-失败时自动重试，完成后归档
+失败时自动重试/拒绝时重新入队，完成后归档
 ```
 
 ## Releases
 
+### 0.2.2
+
+- **抑制异步消息** — 新增 `_skip_publish` 机制，创建/更新/删除 Task 时可通过 `skip_publish()` 方法、`save(skip_publish=True)`、构造时传入 `skip_publish=True` 等方式禁止触发 RabbitMQ 消息通知
+- **批量创建触发异步消息** — `TaskQuerySet` + `TaskManager` 接管 `bulk_create`，批量创建 Task 后自动生成 TaskExecution 并推送 MQ；子类覆盖 `objects` 时发出警告提示
+- **分布式锁默认引擎** — 默认使用 `DjangoRedisGlobalLock`，复用 Django `CACHES['default']` 配置（需为 Redis 缓存），无需手动配置 `DJANGO_SIMPLETASK_LOCK_CONFIG`
+- **Redis key 命名统一** — 所有 Redis key 格式规范为 `{项目前缀}:django-simpletask5:{用途}:{id}`，项目前缀从 `ROOT_URLCONF` 自动提取，也可通过 `DJANGO_SIMPLETASK_KEY_PREFIX` 显式覆盖
+- **CronJob 管理增强** — 新增 `app_label` 字段（自动检测），列表页展示并支持过滤
+- **内置 CronJob 重命名** — Status Check → Task Timeout Detection，Retry Timeout → Retry Failed Tasks，Ping/Pong → Health Check 等
+- **Dashboard 重做** — 新增今日失败卡片，成功率按 90%/80% 分绿色/橙色/红色三级，卡片颜色统一使用 info 蓝色
+- **Pending/Running 显示修复** — 改为展示 `pending / running` 双值而非仅 pending
+- **成功率显示优化** — `(22/25)` 与 `88%` 同行显示，字号缩小颜色淡化，高度对齐
+- **Redis 不可达降级** — Worker 数量显示 `-` 而非 `0`，区分无数据与异常
+- **按钮优化** — 改用 Font Awesome 图标，统一 `min-width` 对齐，title 改为中文描述
+- **翻译补充** — 补充 Run/Activate/Deactivate 及所有内置 CronJob 名称的中文翻译
+- **新增依赖** — `django-static-fontawesome` 用于按钮图标
+- **示例应用** — 示例 cronjobs 模块在 AppConfig.ready() 中导入确保注册生效
+
+### 0.2.1
+
+- **拒绝回退机制** — 新增 `RejectException`，执行器可抛出该异常拒绝当前任务，消息自动重新入队等待下次调度，不消耗重试次数
+- **区分两种超时** — 引入 `pickup_timeout_seconds`（等待 Worker 消费超时）与 `timeout_seconds`（执行超时）两种超时配置，`expire_time` 改用 Pickup 超时计算，超时检测更精准
+- **文档更新** — README 补充拒绝回退机制的使用说明和两种超时的详细解释
+
 ### 0.2.0
 
 - **破坏性变更**: 移除 `Task` 模型上的自定义主键，`task_id` 不再是主键字段，改为 `unique=True` 的唯一标识字段。所有 `Task` 子模型将自动获得 Django 默认的自增 `id` 主键。已有数据库需要迁移处理。

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/django_simpletask5/__init__.py

@@ -3,6 +3,7 @@ default_app_config = 'django_simpletask5.apps.DjangoSimpletask5Config'
 app_requires = [
     'django_admin_dashboards',
     'django_safe_fields',
+    'django_static_fontawesome',
     'django_tabbed_changeform_admin',
     'django_checkbox_normalize',
 ]

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/django_simpletask5/admin.py

@@ -3,6 +3,7 @@ import json
 from django import forms
 from django.contrib import admin
 from django.http import HttpResponseRedirect, Http404
+from django.middleware.csrf import get_token
 from django.urls import path, reverse
 from django.utils.html import format_html, mark_safe
 from django.utils.translation import gettext_lazy as _
@@ -225,6 +226,7 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
     form = CronJobForm
     list_display = [
         "display_name",
+        "app_label",
         "cron_expression",
         "is_active",
         "is_modified_by_user",
@@ -232,9 +234,14 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
         "action_buttons",
     ]
     readonly_fields = ["created_at", "updated_at"]
-    list_filter = ["is_active", "is_modified_by_user"]
+    list_filter = ["is_active", "is_modified_by_user", "app_label"]
     search_fields = ["display_name", "uid", "executor_class"]
 
+    class Media:
+        css = {
+            "all": ("fontawesome/css/all.min.css",),
+        }
+
     fieldsets = [
         (None, {
             "fields": ["uid", "display_name", "executor_class", "cron_expression", "description", "created_at", "updated_at"],
@@ -261,6 +268,10 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
     def get_queryset(self, request):
         return super().get_queryset(request)
 
+    def changelist_view(self, request, extra_context=None):
+        self._admin_request = request
+        return super().changelist_view(request, extra_context=extra_context)
+
     def get_urls(self):
         urls = super().get_urls()
         custom_urls = [
@@ -311,39 +322,45 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
             reverse('admin:django_simpletask5_cronjob_changelist')
         )
 
+    _btn_base = "padding:3px 8px;border-radius:3px;border:none;cursor:pointer;margin-right:4px;font-size:12px;min-width:68px"
+
+    def _csrf_token_input(self):
+        token = get_token(self._admin_request) if hasattr(self, '_admin_request') else ''
+        return f'<input type="hidden" name="csrfmiddlewaretoken" value="{token}">'
+
     def action_buttons(self, obj):
         run_url = reverse('admin:django_simpletask5_cronjob_run', args=[obj.pk])
         toggle_url = reverse('admin:django_simpletask5_cronjob_toggle_active', args=[obj.pk])
-        csrf_token = '"{{ csrf_token }}"'
+        csrf_input = self._csrf_token_input()
 
         buttons = []
         buttons.append(
             f'<form style="display:inline" method="post" action="{run_url}">'
-            f'<input type="hidden" name="csrfmiddlewaretoken" value={csrf_token}>'
-            f'<button type="submit" style="background:#17a2b8;color:#fff;padding:3px 8px;border-radius:3px;border:none;cursor:pointer;margin-right:4px;font-size:12px" title="{_("Execute now")}">'
-            f'<i class="ri-play-line"></i> {_("Run")}</button></form>'
+            f'{csrf_input}'
+            f'<button type="submit" style="background:#17a2b8;color:#fff;{self._btn_base}" title="{_("Click to run this cronjob")}">'
+            f'<i class="fas fa-play"></i> {_("Run")}</button></form>'
         )
         if obj.is_active:
             btn_style = "background:#ffc107;color:#000"
-            btn_title = _("Deactivate")
-            btn_icon = "ri-pause-line"
+            btn_title = _("Click to deactivate this cronjob")
+            btn_icon = "fas fa-pause"
             btn_label = _("Deactivate")
         else:
             btn_style = "background:#28a745;color:#fff"
-            btn_title = _("Activate")
-            btn_icon = "ri-play-circle-line"
+            btn_title = _("Click to activate this cronjob")
+            btn_icon = "fas fa-play-circle"
             btn_label = _("Activate")
         buttons.append(
             f'<form style="display:inline" method="post" action="{toggle_url}">'
-            f'<input type="hidden" name="csrfmiddlewaretoken" value={csrf_token}>'
-            f'<button type="submit" style="{btn_style};padding:3px 8px;border-radius:3px;border:none;cursor:pointer;margin-right:4px;font-size:12px" title="{btn_title}">'
+            f'{csrf_input}'
+            f'<button type="submit" style="{btn_style};{self._btn_base}" title="{btn_title}">'
             f'<i class="{btn_icon}"></i> {btn_label}</button></form>'
         )
         delete_url = reverse('admin:django_simpletask5_cronjob_delete', args=[obj.pk])
         buttons.append(
-            f'<a class="button" style="background:#dc3545;color:#fff;padding:3px 8px;border-radius:3px;text-decoration:none;margin-right:4px;font-size:12px" '
-            f'href="{delete_url}" title="{_("Delete")}">'
-            f'<i class="ri-delete-bin-line"></i> {_("Delete")}</a>'
+            f'<a class="button" style="background:#dc3545;color:#fff;padding:3px 8px;border-radius:3px;text-decoration:none;margin-right:4px;font-size:12px;min-width:68px;display:inline-block;text-align:center" '
+            f'href="{delete_url}" title="{_("Click to delete this cronjob")}">'
+            f'<i class="fas fa-trash"></i> {_("Delete")}</a>'
         )
         return mark_safe(''.join(buttons))
 

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/django_simpletask5/core/cronjob_registry.py

@@ -10,7 +10,17 @@ logger = logging.getLogger(__name__)
 _CRONJOB_REGISTRY = {}
 
 
-def register_cronjob(uid, display_name, cron_expression, executor_class, context=None, description='', is_active=True):
+def register_cronjob(uid, display_name, cron_expression, executor_class, context=None, description='', is_active=True, app_label=''):
+    if not app_label:
+        import inspect
+        frame = inspect.currentframe()
+        try:
+            caller_frame = frame.f_back
+            caller_module = inspect.getmodule(caller_frame)
+            if caller_module and caller_module.__name__:
+                app_label = caller_module.__name__.split('.')[0]
+        finally:
+            del frame
     _CRONJOB_REGISTRY[uid] = {
         'display_name': display_name,
         'cron_expression': cron_expression,
@@ -18,6 +28,7 @@ def register_cronjob(uid, display_name, cron_expression, executor_class, context
         'context': json.dumps(context) if context else None,
         'description': description,
         'is_active': is_active,
+        'app_label': app_label,
     }
 
 
@@ -56,6 +67,7 @@ def sync_cronjobs():
                 cronjob.context = config.get('context')
                 cronjob.description = config.get('description', '')
                 cronjob.is_active = config.get('is_active', True)
+                cronjob.app_label = config.get('app_label', '')
                 if cronjob.next_run_time is None:
                     cronjob.next_run_time = _compute_next_run_time(config['cron_expression'])
                 cronjob.save()
@@ -68,6 +80,7 @@ def sync_cronjobs():
                 context=config.get('context'),
                 description=config.get('description', ''),
                 is_active=config.get('is_active', True),
+                app_label=config.get('app_label', ''),
                 is_modified_by_user=False,
                 next_run_time=_compute_next_run_time(config['cron_expression']),
             )
@@ -80,35 +93,35 @@ def register_builtin_cronjobs():
 
     register_cronjob(
         uid='simpletask_status_check',
-        display_name=_('Status Check'),
+        display_name=_('Task Timeout Detection'),
         cron_expression='* * * * *',
         executor_class='django_simpletask5.executors.status_check.StatusCheckExecutor',
         description='Scan long-running pending/running tasks and mark them as timeout',
     )
     register_cronjob(
         uid='simpletask_retry_timeout',
-        display_name=_('Retry Timeout'),
+        display_name=_('Retry Failed Tasks'),
         cron_expression='* * * * *',
         executor_class='django_simpletask5.executors.retry_timeout.RetryTimeoutExecutor',
         description='Retry timeout tasks that still have retry attempts remaining',
     )
     register_cronjob(
         uid='simpletask_archive',
-        display_name=_('Archive'),
+        display_name=_('Execution Archive'),
         cron_expression='0 2 * * *',
         executor_class='django_simpletask5.executors.archive.ArchiveExecutor',
         description='Archive previous day TaskExecution records',
     )
     register_cronjob(
         uid='simpletask_purge_expired',
-        display_name=_('Purge Expired'),
+        display_name=_('Purge Expired Records'),
         cron_expression='0 3 * * *',
         executor_class='django_simpletask5.executors.archive.PurgeExpiredExecutor',
         description='Purge expired TaskExecution records beyond retention days',
     )
     register_cronjob(
         uid='simpletask_ping_pong',
-        display_name=_('Ping / Pong'),
+        display_name=_('Health Check'),
         cron_expression='* * * * *',
         executor_class='django_simpletask5.executors.ping_pong.PingPongExecutor',
         description='Ping pong health check',

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/django_simpletask5/core/defaults.py

@@ -1,9 +1,25 @@
 from django.conf import settings
 
+
+def _compute_key_prefix() -> str:
+    custom = getattr(settings, 'DJANGO_SIMPLETASK_KEY_PREFIX', None)
+    if custom is not None:
+        return custom
+    root_urlconf = getattr(settings, 'ROOT_URLCONF', None)
+    if root_urlconf:
+        return root_urlconf.split('.')[0]
+    return 'default'
+
+
+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_DEFAULT_MAX_RETRIES = getattr(settings, 'DJANGO_SIMPLETASK_DEFAULT_MAX_RETRIES', 3)
 DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS = getattr(settings, 'DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS', 600)
+DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS = getattr(settings, 'DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS', 3600)
 
 DJANGO_SIMPLETASK_ARCHIVE_PATH = getattr(settings, 'DJANGO_SIMPLETASK_ARCHIVE_PATH', 'django_simpletask5_archives')
 DJANGO_SIMPLETASK_ARCHIVE_SALT = getattr(settings, 'DJANGO_SIMPLETASK_ARCHIVE_SALT', 'django-simpletask5-archive')
@@ -11,8 +27,8 @@ DJANGO_SIMPLETASK_ARCHIVE_RETENTION_DAYS = getattr(settings, 'DJANGO_SIMPLETASK_
 
 DJANGO_SIMPLETASK_CRONJOB_AUTO_SYNC = getattr(settings, 'DJANGO_SIMPLETASK_CRONJOB_AUTO_SYNC', True)
 
-DJANGO_SIMPLETASK_DEFAULT_QUEUE = getattr(settings, 'DJANGO_SIMPLETASK_DEFAULT_QUEUE', 'django_simpletask5.queue.default')
-DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = getattr(settings, 'DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE', 'django_simpletask5.queue.high_priority')
+DJANGO_SIMPLETASK_DEFAULT_QUEUE = getattr(settings, 'DJANGO_SIMPLETASK_DEFAULT_QUEUE', f'{DJANGO_SIMPLETASK_KEY_PREFIX}:django-simpletask5:queue:default')
+DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = getattr(settings, 'DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE', f'{DJANGO_SIMPLETASK_KEY_PREFIX}:django-simpletask5:queue:high_priority')
 
 DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS = getattr(settings, 'DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS', False)
 DJANGO_SIMPLETASK_SCRIPT_WHITELIST = getattr(settings, 'DJANGO_SIMPLETASK_SCRIPT_WHITELIST', [])

django_simpletask5-0.2.2/django_simpletask5/core/lock.py

@@ -0,0 +1,22 @@
+import logging
+
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+
+def _default_lock_config():
+    return {
+        'global_lock_engine_class': 'globallock.django_redis_global_lock.DjangoRedisGlobalLock',
+        'global_lock_engine_options': {
+            'redis-cache-name': 'default',
+        },
+    }
+
+
+def get_lock_manager():
+    from globallock import GlobalLockManager
+    config = getattr(settings, 'DJANGO_SIMPLETASK_LOCK_CONFIG', None)
+    if config is None:
+        config = _default_lock_config()
+    return GlobalLockManager(config)

{django_simpletask5-0.2.0 → django_simpletask5-0.2.2}/django_simpletask5/core/message_queue.py

@@ -1,5 +1,6 @@
 import logging
 import socket
+import time
 
 from django.conf import settings
 from kombu import Connection, Exchange, Queue, Producer, Consumer
@@ -53,32 +54,29 @@ class KombuQueue:
                     retry=True,
                 )
 
-    def consume(self, queue_name, callback, auto_ack=True):
-        retry_delay = 1
-        while not self._stopped:
-            try:
-                with Connection(_get_broker_url()) as conn:
-                    conn.connect()
-                    queue = Queue(queue_name, self._exchange, routing_key=queue_name, durable=True)
+    def consume(self, queue_name, callback, auto_ack=True, poll_callback=None, poll_interval=60):
+        with Connection(_get_broker_url()) as conn:
+            conn.connect()
+            queue = Queue(queue_name, self._exchange, routing_key=queue_name, durable=True)
 
-                    with Consumer(
-                        conn,
-                        queues=[queue],
-                        callbacks=[lambda body, msg: self._on_message(body, msg, callback, auto_ack)],
-                        accept=['json'],
-                    ):
-                        retry_delay = 1
-                        while not self._stopped:
-                            try:
-                                conn.drain_events(timeout=0.5)
-                            except socket.timeout:
-                                continue
-            except Exception as e:
-                if not self._stopped:
-                    logger.debug('Consumer connection lost: %s, reconnecting in %ss...', e, retry_delay)
-                    import time as _time
-                    _time.sleep(retry_delay)
-                    retry_delay = min(retry_delay * 2, 10)
+            with Consumer(
+                conn,
+                queues=[queue],
+                callbacks=[lambda body, msg: self._on_message(body, msg, callback, auto_ack)],
+                accept=['json'],
+            ):
+                last_poll = time.time()
+                while not self._stopped:
+                    try:
+                        conn.drain_events(timeout=0.5)
+                    except socket.timeout:
+                        pass
+                    if poll_callback and time.time() - last_poll >= poll_interval:
+                        try:
+                            poll_callback()
+                        except Exception:
+                            logger.exception('Poll callback failed')
+                        last_poll = time.time()
 
     @staticmethod
     def _on_message(body, message, callback, auto_ack):