Rocketry项目基础教程：任务调度与执行管理
项目地址: https://gitcode.com/gh_mirrors/ro/rocketry 概述
Rocketry是一个现代化的Python任务调度框架，采用声明式（Statement-based）调度方式，为Python应用程序提供强大的定时任务管理能力。无论你是需要简单的定时脚本还是复杂的企业级任务调度系统，Rocketry都能提供简洁而强大的解决方案。
核心特性速览
| 特性 | 描述 | 适用场景 |
|---|---|---|
| 声明式调度 | 使用直观的字符串语法或API进行任务调度 | 快速开发，代码可读性强 |
| 多执行模式 | 支持主线程、异步、线程、进程四种执行方式 | 并发控制，性能优化 |
| 参数化任务 | 任务间参数传递和返回值共享 | 任务流水线，数据传递 |
| 条件组合 | 支持复杂的逻辑条件组合（与、或、非） | 复杂调度逻辑 |
| 运行时修改 | 支持运行时动态修改会话配置 | 灵活配置，热更新 |
快速入门
安装Rocketry
pip install rocketry
最小示例
from rocketry import Rocketry
# 创建Rocketry应用实例
app = Rocketry()
# 定义每日执行的任务
@app.task('daily')
def do_daily_task():
print("每日任务执行中...")
# 这里可以添加你的业务逻辑
# 定义每分钟执行的任务
@app.task('every 1 minute')
def do_minutely_task():
print("每分钟任务执行中...")
if __name__ == "__main__":
# 启动调度器
app.run()
任务调度详解
时间调度语法
Rocketry提供了多种时间调度方式：
from rocketry import Rocketry
app = Rocketry()
# 固定间隔调度
@app.task('every 10 seconds') # 每10秒
def every_10_seconds():
pass
@app.task('every 2 hours 30 minutes') # 每2小时30分钟
def custom_interval():
pass
# 周期性调度
@app.task('daily') # 每天
def daily_task():
pass
@app.task('weekly') # 每周
def weekly_task():
pass
@app.task('monthly') # 每月
def monthly_task():
pass
# 时间范围调度
@app.task('daily after 08:00') # 每天8点后
def after_eight():
pass
@app.task('daily between 09:00 and 17:00') # 每天9点到17点
def during_work_hours():
pass
@app.task('time of day between 22:00 and 06:00') # 夜间时段持续执行
def during_night():
pass
条件组合调度
from rocketry.conds import daily, time_of_day, after_success
from pathlib import Path
# 条件组合示例
@app.task(daily.after("08:00") & time_of_day.before("18:00"))
def during_working_hours():
"""工作日8点到18点执行"""
pass
@app.task((daily.on("Mon") | daily.on("Wed") | daily.on("Fri")) &
time_of_day.after("14:00"))
def on_weekdays_after_two():
"""周一、三、五的14点后执行"""
pass
# 自定义条件
@app.cond()
def file_exists(file_path):
"""自定义条件：文件存在"""
return Path(file_path).exists()
@app.task(daily & file_exists("data/input.csv"))
def process_if_file_exists():
"""每天执行，但仅当输入文件存在时"""
pass
任务执行管理
执行模式对比
Rocketry支持四种执行模式，满足不同场景需求：
| 执行模式 | 描述 | 适用场景 | 优缺点 |
|---|---|---|---|
main | 主线程执行 | 简单任务，无并发需求 | 简单，但会阻塞调度器 |
async | 异步执行 | I/O密集型任务 | 高效，支持async/await |
thread | 多线程执行 | I/O密集型，简单并行 | 轻量级并发，共享内存 |
process | 多进程执行 | CPU密集型任务 | 真正并行，内存隔离 |
执行模式示例
from rocketry import Rocketry
app = Rocketry()
# 主线程执行（默认）
@app.task('every 1 minute', execution="main")
def main_thread_task():
"""在主线程中执行，会阻塞调度器"""
import time
time.sleep(5) # 模拟耗时操作
# 异步执行
@app.task('every 30 seconds', execution="async")
async def async_task():
"""在异步环境中执行，适合I/O操作"""
import asyncio
await asyncio.sleep(1)
# 多线程执行
@app.task('every 2 minutes', execution="thread")
def thread_task():
"""在单独线程中执行"""
import time
time.sleep(10) # 不会阻塞主调度器
# 多进程执行
@app.task('daily', execution="process")
def process_task():
"""在单独进程中执行，完全隔离"""
# CPU密集型计算
result = sum(i*i for i in range(10**6))
return result
# 设置默认执行模式
app_with_async_default = Rocketry(execution="async")
@app_with_async_default.task('hourly')
def default_async_task():
"""使用异步作为默认执行模式"""
pass
任务流水线与参数传递
from rocketry import Rocketry
from rocketry.conds import daily, after_success
from rocketry.args import Return, FuncArg
app = Rocketry()
# 任务流水线示例
@app.task(daily.at("09:00"))
def data_extraction():
"""数据提取任务"""
print("开始提取数据...")
# 模拟数据提取
extracted_data = {"records": 1000, "size": "2MB"}
return extracted_data
@app.task(after_success(data_extraction))
def data_processing(extracted_data=Return(data_extraction)):
"""数据处理任务，依赖提取任务的结果"""
print(f"处理数据: {extracted_data}")
# 模拟数据处理
processed_data = {"processed_records": extracted_data["records"], "status": "completed"}
return processed_data
@app.task(after_success(data_processing))
def data_loading(processed_data=Return(data_processing)):
"""数据加载任务，依赖处理任务的结果"""
print(f"加载处理后的数据: {processed_data}")
# 模拟数据加载
return "数据加载完成"
# 函数参数传递
def get_config():
"""获取配置信息的函数"""
return {"database": "production", "timeout": 30}
@app.task('every 1 hour')
def hourly_task(config=FuncArg(get_config)):
"""每小时执行，使用函数参数"""
print(f"使用配置: {config}")
# 使用配置执行任务
高级特性
自定义条件创建
from rocketry import Rocketry
from rocketry.conds import daily
import requests
app = Rocketry()
# 创建API状态条件
@app.cond()
def api_is_healthy():
"""检查API健康状态"""
try:
response = requests.get("https://api.example.com/health", timeout=5)
return response.status_code == 200
except:
return False
# 创建数据库连接条件
@app.cond()
def database_connected():
"""检查数据库连接状态"""
try:
# 这里使用伪代码，实际需要具体的数据库连接检查
import psycopg2
conn = psycopg2.connect("dbname=test user=postgres")
conn.close()
return True
except:
return False
# 使用自定义条件
@app.task(daily & api_is_healthy() & database_connected())
def critical_daily_task():
"""仅在API和数据库都健康时执行每日任务"""
print("执行关键每日任务")
# 带参数的自定义条件
@app.cond()
def file_older_than(file_path, hours):
"""检查文件是否超过指定小时未修改"""
from pathlib import Path
from datetime import datetime, timedelta
file = Path(file_path)
if not file.exists():
return False
mod_time = datetime.fromtimestamp(file.stat().st_mtime)
return datetime.now() - mod_time > timedelta(hours=hours)
@app.task(daily & file_older_than("data/backup.zip", 24))
def create_backup_if_needed():
"""如果备份文件超过24小时未更新，则创建新备份"""
print("创建新的备份文件")
错误处理与重试机制
from rocketry import Rocketry
from rocketry.conds import daily
from rocketry.args import Return
app = Rocketry()
@app.task(daily, execution="process", timeout=300) # 5分钟超时
def long_running_task():
"""长时间运行的任务，设置超时"""
import time
# 模拟长时间运行
time.sleep(250) # 4分10秒
return "任务完成"
# 带重试机制的任务
@app.task('every 2 hours', max_runs=3) # 最多重试3次
def task_with_retry():
"""带重试机制的任务"""
import random
if random.random() < 0.3: # 30%概率失败
raise Exception("随机失败")
return "成功执行"
# 错误处理任务
@app.task(after_success(task_with_retry) | after_failure(task_with_retry))
def handle_task_result(result=Return(task_with_retry),
status=ReturnStatus(task_with_retry)):
"""处理任务执行结果"""
if status == "success":
print(f"任务成功: {result}")
else:
print(f"任务失败: {result}")
# 可以在这里添加告警逻辑
最佳实践
项目结构建议
my_scheduler/
├── src/
│ ├── __init__.py
│ ├── main.py # 主入口文件
│ ├── tasks/ # 任务模块
│ │ ├── __init__.py
│ │ ├── data_tasks.py # 数据相关任务
│ │ ├── api_tasks.py # API相关任务
│ │ └── system_tasks.py # 系统任务
│ ├── conditions/ # 自定义条件
│ │ ├── __init__.py
│ │ ├── file_conditions.py
│ │ └── api_conditions.py
│ └── config.py # 配置管理
├── requirements.txt
└── README.md
配置管理示例
# config.py
import os
from rocketry import Rocketry
from redbird.repos import CSVFileRepo
class Config:
# 日志配置
LOG_FILE = os.getenv('LOG_FILE', 'scheduler.log')
# 执行模式配置
DEFAULT_EXECUTION = os.getenv('DEFAULT_EXECUTION', 'async')
# 任务超时配置（秒）
TASK_TIMEOUT = int(os.getenv('TASK_TIMEOUT', '600'))
@classmethod
def create_app(cls):
"""创建配置好的Rocketry应用"""
return Rocketry(
execution=cls.DEFAULT_EXECUTION,
logger_repo=CSVFileRepo(filename=cls.LOG_FILE)
)
# main.py
from src.config import Config
from src.tasks import data_tasks, api_tasks, system_tasks
app = Config.create_app()
if __name__ == "__main__":
app.run()
总结
Rocketry作为一个现代化的Python任务调度框架，提供了强大而灵活的任务管理能力。通过本教程，你应该已经掌握了：
- 基础调度：使用声明式语法创建各种时间调度任务
- 执行管理：理解并应用四种执行模式满足不同场景需求
- 高级特性：使用条件组合、参数传递、自定义条件等高级功能
- 错误处理：实现健壮的错误处理和重试机制
- 最佳实践：遵循项目结构和配置管理的最佳实践
Rocketry的声明式设计使得代码更加清晰易读，而丰富的功能集又能满足复杂的企业级需求。无论是简单的定时脚本还是复杂的分布式任务系统，Rocketry都能提供优秀的解决方案。
记住，良好的任务调度系统应该具备：清晰的调度逻辑、适当的错误处理、合理的资源管理以及完善的监控告警。Rocketry为这些需求提供了坚实的基础，让你的Python应用更加健壮和可靠。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
