django-simpletask5 0.1.4__tar.gz → 0.2.1__tar.gz

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-simpletask5
-Version: 0.1.4
+Version: 0.2.1
 Summary: Lightweight async task execution framework for Django
 Author-email: rRR0VrFP <rrr0vrfp@qq.com>
 Maintainer-email: rRR0VrFP <rrr0vrfp@qq.com>
@@ -50,7 +50,8 @@ Dynamic: license-file
 - **自定义事件** — 通过 `task.trigger('event_name')` 触发任意事件
 - **灵活的执行器映射** — 不同事件可绑定不同的执行器类
 - **队列路由** — 不同事件可路由到不同优先级队列
-- **重试与超时** — 失败自动重试（指数退避），支持超时检测
+- **重试与超时** — 失败自动重试（指数退避），支持执行超时与 Pickup 超时两种检测
+- **拒绝回退** — 执行器可通过 `RejectException` 拒绝当前任务，消息自动重新入队等待下次调度
 - **加密字段** — 敏感数据自动加密存储
 - **Cron 调度** — 内置 crontab 守护进程，支持代码注册与数据库覆盖
 - **归档统计** — 已完成执行记录自动归档为加密 JSONL，并生成日统计
@@ -156,10 +157,15 @@ DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = '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
@@ -177,6 +183,9 @@ DJANGO_SIMPLETASK_CRONJOB_AUTO_SYNC = True  # 是否自动将代码注册的 Cro
 ### 安全
 
 ```python
+# 是否启用 Python/Shell 脚本执行器（默认关闭，开启有安全风险）
+DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS = False
+
 # 脚本执行白名单（空列表表示不限制）
 DJANGO_SIMPLETASK_SCRIPT_WHITELIST = ['/path/to/allowed/scripts']
 
@@ -187,6 +196,8 @@ DJANGO_SIMPLETASK_ERROR_MSG_PASSWORD = None  # 错误信息加密密码
 DJANGO_SIMPLETASK_CONTEXT_PASSWORD = None    # 上下文数据加密密码
 ```
 
+> 注意：`DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS` 设为 `True` 后，还需为用户/组授予 `django_simpletask5 | Cron job | Can use script executors` 权限，非超级管理员无法创建 Python/Shell 脚本执行器类型的定时任务。
+
 ## 快速开始
 
 ### 1. 定义任务模型
@@ -230,6 +241,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 处理。
@@ -310,11 +348,34 @@ Task 模型变更 → Django 信号 → 创建 TaskExecution 并发布到消息
                                                     ↓
 Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保存结果
                                                     ↓
-失败时自动重试，完成后归档
+失败时自动重试/拒绝时重新入队，完成后归档
 ```
 
 ## Releases
 
+### 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` 主键。已有数据库需要迁移处理。
+- **统计维度调整**: `TaskExecutionStat` 的统计维度由 `task_model` 改为 `executor_class`，统一覆盖有模型任务和 Cron 定时任务两种场景。对应 API `_update_stats()` 按 `executor_class` 分组聚合。
+- **Admin 优化**: CronJob 列表页移除 `executor_class` 列避免表格撑开；TaskExecutionStat 列表页新增 `executor_class` 列、`created_at` 设为只读修复详情页错误。
+- **测试修复**: 修复 `TransactionTestCase` + `on_commit` 在 SQLite 共享内存连接下因 `TestCase` 残留原子块导致回调不执行的兼容性问题；Redis MQ / RabbitMQ E2E 集成测试全部通过。
+
+### 0.1.5
+
+- **安全加固** — 新增 `DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS` 配置项（默认关闭），启用后才可执行 Python/Shell 脚本；新增 `can_use_script_executors` 权限，仅有此权限或超级管理员的用户才能在 Admin 中创建脚本执行器类型的 CronJob
+- **Bug 修复** — 修复 `RetryTimeoutExecutor` 中 lambda 晚绑定导致所有回调引用最后一个记录的问题
+- **Admin 安全** — 操作按钮（立即执行、启用/禁用）从 GET 参数改为 POST 请求，附带 CSRF 保护
+- **性能优化** — `RetryTimeoutExecutor` 改为批量 update + 按 ID 分发消息推送
+- **Admin 增强** — `TaskExecutionAdmin` 新增 `executor_class` 过滤、`error_message` 搜索、批量重试失败任务、批量取消待处理任务
+- **数据索引** — 添加 `(status, expire_time)` 和 `(is_active, next_run_time)` 复合索引；`trigger_event`、`executor_class`、`task_id`、`created_at` 添加单字段索引
+- **代码规范** — `bash_script.py`、`python_script.py`、`simple_request.py` 补充缺失的 logger；移除废弃的 `allow_tags` 属性
+
 ### 0.1.4
 
 - **修复打包** — `pyproject.toml` 添加 `package-data` 配置，打包时包含 locale po/mo 文件，修复 i18n 翻译不生效的问题

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/README.md

@@ -11,7 +11,8 @@
 - **自定义事件** — 通过 `task.trigger('event_name')` 触发任意事件
 - **灵活的执行器映射** — 不同事件可绑定不同的执行器类
 - **队列路由** — 不同事件可路由到不同优先级队列
-- **重试与超时** — 失败自动重试（指数退避），支持超时检测
+- **重试与超时** — 失败自动重试（指数退避），支持执行超时与 Pickup 超时两种检测
+- **拒绝回退** — 执行器可通过 `RejectException` 拒绝当前任务，消息自动重新入队等待下次调度
 - **加密字段** — 敏感数据自动加密存储
 - **Cron 调度** — 内置 crontab 守护进程，支持代码注册与数据库覆盖
 - **归档统计** — 已完成执行记录自动归档为加密 JSONL，并生成日统计
@@ -117,10 +118,15 @@ DJANGO_SIMPLETASK_HIGH_PRIORITY_QUEUE = '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
@@ -138,6 +144,9 @@ DJANGO_SIMPLETASK_CRONJOB_AUTO_SYNC = True  # 是否自动将代码注册的 Cro
 ### 安全
 
 ```python
+# 是否启用 Python/Shell 脚本执行器（默认关闭，开启有安全风险）
+DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS = False
+
 # 脚本执行白名单（空列表表示不限制）
 DJANGO_SIMPLETASK_SCRIPT_WHITELIST = ['/path/to/allowed/scripts']
 
@@ -148,6 +157,8 @@ DJANGO_SIMPLETASK_ERROR_MSG_PASSWORD = None  # 错误信息加密密码
 DJANGO_SIMPLETASK_CONTEXT_PASSWORD = None    # 上下文数据加密密码
 ```
 
+> 注意：`DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS` 设为 `True` 后，还需为用户/组授予 `django_simpletask5 | Cron job | Can use script executors` 权限，非超级管理员无法创建 Python/Shell 脚本执行器类型的定时任务。
+
 ## 快速开始
 
 ### 1. 定义任务模型
@@ -191,6 +202,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 处理。
@@ -271,11 +309,34 @@ Task 模型变更 → Django 信号 → 创建 TaskExecution 并发布到消息
                                                     ↓
 Worker 消费消息 → 获取分布式锁 → 加载执行器 → 执行并保存结果
                                                     ↓
-失败时自动重试，完成后归档
+失败时自动重试/拒绝时重新入队，完成后归档
 ```
 
 ## Releases
 
+### 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` 主键。已有数据库需要迁移处理。
+- **统计维度调整**: `TaskExecutionStat` 的统计维度由 `task_model` 改为 `executor_class`，统一覆盖有模型任务和 Cron 定时任务两种场景。对应 API `_update_stats()` 按 `executor_class` 分组聚合。
+- **Admin 优化**: CronJob 列表页移除 `executor_class` 列避免表格撑开；TaskExecutionStat 列表页新增 `executor_class` 列、`created_at` 设为只读修复详情页错误。
+- **测试修复**: 修复 `TransactionTestCase` + `on_commit` 在 SQLite 共享内存连接下因 `TestCase` 残留原子块导致回调不执行的兼容性问题；Redis MQ / RabbitMQ E2E 集成测试全部通过。
+
+### 0.1.5
+
+- **安全加固** — 新增 `DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS` 配置项（默认关闭），启用后才可执行 Python/Shell 脚本；新增 `can_use_script_executors` 权限，仅有此权限或超级管理员的用户才能在 Admin 中创建脚本执行器类型的 CronJob
+- **Bug 修复** — 修复 `RetryTimeoutExecutor` 中 lambda 晚绑定导致所有回调引用最后一个记录的问题
+- **Admin 安全** — 操作按钮（立即执行、启用/禁用）从 GET 参数改为 POST 请求，附带 CSRF 保护
+- **性能优化** — `RetryTimeoutExecutor` 改为批量 update + 按 ID 分发消息推送
+- **Admin 增强** — `TaskExecutionAdmin` 新增 `executor_class` 过滤、`error_message` 搜索、批量重试失败任务、批量取消待处理任务
+- **数据索引** — 添加 `(status, expire_time)` 和 `(is_active, next_run_time)` 复合索引；`trigger_event`、`executor_class`、`task_id`、`created_at` 添加单字段索引
+- **代码规范** — `bash_script.py`、`python_script.py`、`simple_request.py` 补充缺失的 logger；移除废弃的 `allow_tags` 属性
+
 ### 0.1.4
 
 - **修复打包** — `pyproject.toml` 添加 `package-data` 配置，打包时包含 locale po/mo 文件，修复 i18n 翻译不生效的问题

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/django_simpletask5/admin.py

@@ -2,8 +2,9 @@ import json
 
 from django import forms
 from django.contrib import admin
-from django.http import HttpResponseRedirect
-from django.urls import reverse
+from django.http import HttpResponseRedirect, Http404
+from django.urls import path, reverse
+from django.utils.html import format_html, mark_safe
 from django.utils.translation import gettext_lazy as _
 from django_checkbox_normalize.admin import DjangoCheckboxNormalizeAdmin
 from django_tabbed_changeform_admin.admin import DjangoTabbedChangeformAdmin
@@ -15,6 +16,11 @@ from django_simpletask5.core.executor_scanner import (
     get_executor_schema_map,
 )
 
+SCRIPT_EXECUTOR_CLASSES = {
+    'django_simpletask5.executors.bash_script.BashScriptExecutor',
+    'django_simpletask5.executors.python_script.PythonScriptExecutor',
+}
+
 
 class ExecutorClassWidget(forms.Select):
     def __init__(self, attrs=None):
@@ -58,6 +64,7 @@ class CronJobForm(forms.ModelForm):
     )
 
     def __init__(self, *args, **kwargs):
+        self.request = kwargs.pop('request', None)
         super().__init__(*args, **kwargs)
         if self.instance and self.instance.pk:
             self.fields['uid'].disabled = True
@@ -75,6 +82,16 @@ class CronJobForm(forms.ModelForm):
             except Exception:
                 pass
 
+    def clean_executor_class(self):
+        executor_class = self.cleaned_data.get("executor_class", "")
+        if executor_class in SCRIPT_EXECUTOR_CLASSES:
+            if self.request and not (self.request.user.is_superuser or self.request.user.has_perm('django_simpletask5.can_use_script_executors')):
+                raise forms.ValidationError(
+                    _('You do not have permission to use script executors (Python/Shell). '
+                      'Only superusers and users with the "can_use_script_executors" permission can do so.')
+                )
+        return executor_class
+
     def clean_context(self):
         raw = self.cleaned_data.get("context")
         if not raw:
@@ -125,7 +142,6 @@ class TaskExecutionAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdm
 
     @admin.display(description=_("Execution ID"))
     def short_execution_id(self, obj):
-        from django.utils.html import format_html
         full = str(obj.execution_id)
         short = full[:8]
         copied_text = _("Copied!")
@@ -136,8 +152,8 @@ class TaskExecutionAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdm
             'setTimeout(function(){{t.textContent=o;}},800);}}.bind(this)).catch(function(){{}})">{}</span>',
             full, full, copied_text, short
         )
-    list_filter = ["status", "trigger_event", "created_at"]
-    search_fields = ["execution_id", "task_id", "executor_class"]
+    list_filter = ["status", "trigger_event", "executor_class", "created_at"]
+    search_fields = ["execution_id", "task_id", "executor_class", "error_message"]
     readonly_fields = [
         "execution_id", "task_id", "task_model", "trigger_event", "executor_class", "status",
         "result", "error_message", "context", "total_tasks_count", "done_tasks_count",
@@ -145,6 +161,7 @@ class TaskExecutionAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdm
         "started_at", "finished_at", "created_at", "updated_at",
     ]
     ordering = ["-created_at"]
+    actions = ["retry_selected", "cancel_selected"]
 
     def has_add_permission(self, request):
         return False
@@ -185,6 +202,23 @@ class TaskExecutionAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdm
     def retry_info(self, obj):
         return f"{obj.retry_count}/{obj.max_retries}"
 
+    @admin.action(description=_("Retry selected failed tasks"))
+    def retry_selected(self, request, queryset):
+        from django_simpletask5.core.publisher import _publish_message
+        count = 0
+        for exec_record in queryset.filter(status__in=['failed', 'timeout']):
+            exec_record.status = 'retry'
+            exec_record.retry_count += 1
+            exec_record.save(update_fields=['status', 'retry_count', 'updated_at'])
+            _publish_message(exec_record)
+            count += 1
+        self.message_user(request, _("%d execution(s) have been re-queued.") % count)
+
+    @admin.action(description=_("Cancel selected pending tasks"))
+    def cancel_selected(self, request, queryset):
+        updated = queryset.filter(status='pending').update(status='failed')
+        self.message_user(request, _("%d execution(s) have been cancelled.") % updated)
+
 
 @admin.register(CronJob)
 class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
@@ -192,7 +226,6 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
     list_display = [
         "display_name",
         "cron_expression",
-        "executor_class",
         "is_active",
         "is_modified_by_user",
         "updated_at",
@@ -228,62 +261,102 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
     def get_queryset(self, request):
         return super().get_queryset(request)
 
-    def action_buttons(self, obj):
-        from django.utils.html import format_html
-        from django.urls import reverse
+    def get_urls(self):
+        urls = super().get_urls()
+        custom_urls = [
+            path(
+                '<path:object_id>/run/',
+                self.admin_site.admin_view(self._run_cronjob_view),
+                name='django_simpletask5_cronjob_run',
+            ),
+            path(
+                '<path:object_id>/toggle-active/',
+                self.admin_site.admin_view(self._toggle_active_view),
+                name='django_simpletask5_cronjob_toggle_active',
+            ),
+        ]
+        return custom_urls + urls
 
-        changelist_url = reverse('admin:django_simpletask5_cronjob_changelist')
+    def _run_cronjob_view(self, request, object_id):
+        if request.method != 'POST':
+            return HttpResponseRedirect(
+                reverse('admin:django_simpletask5_cronjob_changelist')
+            )
+        try:
+            cronjob = CronJob.objects.get(pk=object_id)
+            from django_simpletask5.management.commands.django_simpletask_crontab import Command as CrontabCommand
+            cmd = CrontabCommand()
+            cmd._trigger_cronjob(cronjob)
+            self.message_user(request, _('Cronjob "%s" triggered.') % cronjob.display_name)
+        except CronJob.DoesNotExist:
+            raise Http404()
+        return HttpResponseRedirect(
+            reverse('admin:django_simpletask5_cronjob_changelist')
+        )
+
+    def _toggle_active_view(self, request, object_id):
+        if request.method != 'POST':
+            return HttpResponseRedirect(
+                reverse('admin:django_simpletask5_cronjob_changelist')
+            )
+        try:
+            cronjob = CronJob.objects.get(pk=object_id)
+            cronjob.is_active = not cronjob.is_active
+            cronjob.save(update_fields=['is_active'])
+            status = _('activated') if cronjob.is_active else _('deactivated')
+            self.message_user(request, _('Cronjob "%s" %s.') % (cronjob.display_name, status))
+        except CronJob.DoesNotExist:
+            raise Http404()
+        return HttpResponseRedirect(
+            reverse('admin:django_simpletask5_cronjob_changelist')
+        )
+
+    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 }}"'
 
         buttons = []
         buttons.append(
-            f'<a class="button" style="background:#17a2b8;color:#fff;padding:3px 8px;border-radius:3px;text-decoration:none;margin-right:4px;font-size:12px" '
-            f'href="{changelist_url}?action=run&id={obj.pk}" title="立即执行">'
-            f'<i class="ri-play-line"></i> 执行</a>'
+            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>'
         )
         if obj.is_active:
-            buttons.append(
-                f'<a class="button" style="background:#ffc107;color:#000;padding:3px 8px;border-radius:3px;text-decoration:none;margin-right:4px;font-size:12px" '
-                f'href="{changelist_url}?action=toggle-active&id={obj.pk}" title="禁用">'
-                f'<i class="ri-pause-line"></i> 禁用</a>'
-            )
+            btn_style = "background:#ffc107;color:#000"
+            btn_title = _("Deactivate")
+            btn_icon = "ri-pause-line"
+            btn_label = _("Deactivate")
         else:
-            buttons.append(
-                f'<a class="button" style="background:#28a745;color:#fff;padding:3px 8px;border-radius:3px;text-decoration:none;margin-right:4px;font-size:12px" '
-                f'href="{changelist_url}?action=toggle-active&id={obj.pk}" title="启用">'
-                f'<i class="ri-play-circle-line"></i> 启用</a>'
-            )
+            btn_style = "background:#28a745;color:#fff"
+            btn_title = _("Activate")
+            btn_icon = "ri-play-circle-line"
+            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'<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="删除">'
-            f'<i class="ri-delete-bin-line"></i> 删除</a>'
+            f'href="{delete_url}" title="{_("Delete")}">'
+            f'<i class="ri-delete-bin-line"></i> {_("Delete")}</a>'
         )
-        return format_html(''.join(buttons))
+        return mark_safe(''.join(buttons))
 
-    action_buttons.short_description = _("操作")
-    action_buttons.allow_tags = True
+    action_buttons.short_description = _("Actions")
 
-    def changelist_view(self, request, extra_context=None):
-        action = request.GET.get('action')
-        object_id = request.GET.get('id')
-        if action and object_id:
-            from django_simpletask5.models import CronJob
-            try:
-                cronjob = CronJob.objects.get(pk=object_id)
-                if action == 'run':
-                    from django_simpletask5.management.commands.django_simpletask_crontab import Command as CrontabCommand
-                    cmd = CrontabCommand()
-                    cmd._trigger_cronjob(cronjob)
-                    self.message_user(request, f'Cronjob "{cronjob.display_name}" triggered.')
-                elif action == 'toggle-active':
-                    cronjob.is_active = not cronjob.is_active
-                    cronjob.save(update_fields=['is_active'])
-                    status = 'activated' if cronjob.is_active else 'deactivated'
-                    self.message_user(request, f'Cronjob "{cronjob.display_name}" {status}.')
-            except CronJob.DoesNotExist:
-                self.message_user(request, f'Cronjob not found.', level='ERROR')
-            return HttpResponseRedirect(request.path)
-        return super().changelist_view(request, extra_context=extra_context)
+    def get_form(self, request, obj=None, change=False, **kwargs):
+        form_class = super().get_form(request, obj=obj, change=change, **kwargs)
+
+        class _CronJobFormWithRequest(form_class):
+            def __init__(self, *args, **kwargs):
+                kwargs['request'] = request
+                super().__init__(*args, **kwargs)
+        return _CronJobFormWithRequest
 
     def save_model(self, request, obj, form, change):
         if change:
@@ -344,6 +417,7 @@ class CronJobAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
 class TaskExecutionStatAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangeformAdmin):
     list_display = [
         "date",
+        "executor_class",
         "trigger_event",
         "total_count",
         "success_count",
@@ -351,11 +425,12 @@ class TaskExecutionStatAdmin(DjangoCheckboxNormalizeAdmin, DjangoTabbedChangefor
         "avg_duration_seconds",
     ]
     list_filter = ["date", "trigger_event"]
+    readonly_fields = ["created_at"]
     ordering = ["-date"]
 
     fieldsets = [
         (None, {
-            "fields": ["date", "task_model", "trigger_event", "created_at"],
+            "fields": ["date", "executor_class", "trigger_event", "created_at"],
             "classes": ["tab-basic"],
         }),
         (None, {

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/django_simpletask5/core/defaults.py

@@ -4,6 +4,7 @@ DJANGO_SIMPLETASK_LOCK_TIMEOUT = getattr(settings, 'DJANGO_SIMPLETASK_LOCK_TIMEO
 
 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')
@@ -14,6 +15,7 @@ DJANGO_SIMPLETASK_CRONJOB_AUTO_SYNC = getattr(settings, 'DJANGO_SIMPLETASK_CRONJ
 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_ENABLE_SCRIPT_EXECUTORS = getattr(settings, 'DJANGO_SIMPLETASK_ENABLE_SCRIPT_EXECUTORS', False)
 DJANGO_SIMPLETASK_SCRIPT_WHITELIST = getattr(settings, 'DJANGO_SIMPLETASK_SCRIPT_WHITELIST', [])
 
 DJANGO_SIMPLETASK_FIELD_CIPHER_CLASS = getattr(settings, 'DJANGO_SIMPLETASK_FIELD_CIPHER_CLASS', None)

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/django_simpletask5/core/publisher.py

@@ -1,10 +1,12 @@
 import json
 import logging
+import time
 
 from django.db import transaction
+from django.utils import timezone
 
 from django_simpletask5.models import TaskExecution
-from django_simpletask5.core.defaults import DJANGO_SIMPLETASK_DEFAULT_QUEUE, DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS
+from django_simpletask5.core.defaults import DJANGO_SIMPLETASK_DEFAULT_QUEUE, DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS, DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS
 from django_simpletask5.executors.loader import load_executor_class
 
 logger = logging.getLogger(__name__)
@@ -20,6 +22,16 @@ def _resolve_timeout_seconds(executor_class_path: str) -> int:
     return DJANGO_SIMPLETASK_DEFAULT_TIMEOUT_SECONDS
 
 
+def _resolve_pickup_timeout_seconds(executor_class_path: str) -> int:
+    try:
+        cls = load_executor_class(executor_class_path)
+        if cls.pickup_timeout_seconds is not None:
+            return cls.pickup_timeout_seconds
+    except Exception:
+        logger.warning('Failed to load executor %s for pickup timeout resolution', executor_class_path)
+    return DJANGO_SIMPLETASK_DEFAULT_PICKUP_TIMEOUT_SECONDS
+
+
 def create_and_publish(task, trigger_event, extra_context=None):
     executor_class_path = task.get_executor_class_path(event=trigger_event)
     queue_name = task.get_queue_name(event=trigger_event)
@@ -41,6 +53,7 @@ def create_and_publish(task, trigger_event, extra_context=None):
         executor_class=executor_class_path,
         status='pending',
         timeout_seconds=_resolve_timeout_seconds(executor_class_path),
+        pickup_timeout_seconds=_resolve_pickup_timeout_seconds(executor_class_path),
         context=json.dumps(serialized_context, default=str) if serialized_context else None,
     )
     execution.save()
@@ -58,16 +71,33 @@ def _publish_message(execution, routing_key=None):
         'executor_class': execution.executor_class,
     }
 
+    from django_simpletask5.core.message_queue import get_message_queue
+
+    for attempt in range(1, 4):
+        try:
+            mq = get_message_queue()
+            mq.publish(
+                routing_key=routing_key or DJANGO_SIMPLETASK_DEFAULT_QUEUE,
+                message=message,
+            )
+            logger.debug('Published message for execution %s', execution.execution_id)
+            return
+        except Exception:
+            if attempt < 3:
+                logger.warning('Publish attempt %d/3 failed for execution %s, retrying...', attempt, execution.execution_id)
+                time.sleep(1)
+            else:
+                logger.exception('Failed to publish message for execution %s after 3 attempts', execution.execution_id)
+
     try:
-        from django_simpletask5.core.message_queue import get_message_queue
-        mq = get_message_queue()
-        mq.publish(
-            routing_key=routing_key or DJANGO_SIMPLETASK_DEFAULT_QUEUE,
-            message=message,
-        )
-        logger.debug('Published message for execution %s', execution.execution_id)
+        execution.refresh_from_db()
+        if execution.status not in ('success', 'failed', 'timeout'):
+            execution.status = 'failed'
+            execution.error_message = 'Failed to publish message to queue after 3 attempts'
+            execution.finished_at = timezone.now()
+            execution.save(update_fields=['status', 'error_message', 'finished_at', 'updated_at'])
     except Exception:
-        logger.exception('Failed to publish message for execution %s', execution.execution_id)
+        logger.exception('Failed to mark execution %s as failed after publish failure', execution.execution_id)
 
 
 def _serialize_context(context):

{django_simpletask5-0.1.4 → django_simpletask5-0.2.1}/django_simpletask5/core/worker_registry.py

@@ -12,6 +12,7 @@ logger = logging.getLogger(__name__)
 WORKER_TTL = 300
 
 _REDIS_UNAVAILABLE = False
+_redis_lock = threading.Lock()
 
 
 def _get_redis_client():
@@ -30,17 +31,18 @@ def _get_redis_client():
 
 def _safe_redis_call(fn, default=None, log_level=logging.WARNING):
     global _REDIS_UNAVAILABLE
-    try:
-        result = fn()
-        if _REDIS_UNAVAILABLE:
-            _REDIS_UNAVAILABLE = False
-            logger.info('Redis connection restored')
-        return result
-    except Exception as e:
-        if not _REDIS_UNAVAILABLE:
-            _REDIS_UNAVAILABLE = True
-            logger.log(log_level, 'Redis operation failed: %s', e)
-        return default
+    with _redis_lock:
+        try:
+            result = fn()
+            if _REDIS_UNAVAILABLE:
+                _REDIS_UNAVAILABLE = False
+                logger.info('Redis connection restored')
+            return result
+        except Exception as e:
+            if not _REDIS_UNAVAILABLE:
+                _REDIS_UNAVAILABLE = True
+                logger.log(log_level, 'Redis operation failed: %s', e)
+            return default
 
 
 def _worker_key(pid, tid):