1use std::{sync::Arc, time::Duration};
2use persistent_scheduler::{
3 core::{
4 context::{TaskConfiguration, TaskContext},
5 store::TaskStore,
6 task::{Task, TaskFuture},
7 task_kind::TaskKind,
8 },
9 nativedb::meta::NativeDbTaskStore,
10};
11use serde::{Deserialize, Serialize};
12
13#[tokio::main]
14async fn main() {
15 tracing_subscriber::fmt()
16 .with_max_level(tracing::Level::INFO)
17 .init();
18
19 let task_store = NativeDbTaskStore::default();
20 task_store.restore_tasks().await.unwrap();
21 let context = TaskContext::new(task_store)
22 .register::<MyTask1>()
23 .register::<MyTask2>()
24 .set_concurrency("default", 10)
25 .start().await;
26 let context = Arc::new(context);
27 let mut tasks = Vec::new();
28
29 for _ in 0..10000 {
30 tasks.push(TaskConfiguration {
31 inner: MyTask1::new("name1".to_string(), 32),
32 kind: TaskKind::Once,
33 delay_seconds: None,
34 });
35 }
36
37 tokio::spawn(async move {
38 context.add_tasks(tasks).await.unwrap();
39 });
40
41 tokio::time::sleep(Duration::from_secs(10000)).await;
42}
43
44#[derive(Clone, Debug, Deserialize, Serialize)]
45struct MyTask1 {
46 pub name: String,
47 pub age: i32,
48}
49
50impl MyTask1 {
51 pub fn new(name: String, age: i32) -> Self {
52 Self { name, age }
53 }
54}
55
56impl Task for MyTask1 {
57 const TASK_KEY: &'static str = "my_task_a";
58
59 const TASK_QUEUE: &'static str = "default";
60
61 const DELAY_SECONDS: u32 = 0;
63 fn run(self) -> TaskFuture {
64 Box::pin(async move {
65 Ok(())
70 })
71 }
72}
73
74#[derive(Clone, Debug, Deserialize, Serialize)]
75struct MyTask2 {
76 pub name: String,
77 pub age: i32,
78}
79
80impl MyTask2 {
81 pub fn new(name: String, age: i32) -> Self {
82 Self { name, age }
83 }
84}
85
86impl Task for MyTask2 {
87 const TASK_KEY: &'static str = "my_task_c";
88 const TASK_QUEUE: &'static str = "default";
89
90 fn run(self) -> TaskFuture {
91 Box::pin(async move {
92 println!("{}", self.name);
93 println!("{}", self.age);
94 println!("my_task_c is running");
96 Ok(())
97 })
98 }
99}