nativedb/
nativedb.rs

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 RETRY_POLICY: RetryPolicy = RetryPolicy::linear(10, Some(5));
62    const DELAY_SECONDS: u32 = 0;
63    fn run(self) -> TaskFuture {
64        Box::pin(async move {
65            // println!("{}", self.name);
66            // println!("{}", self.age);
67
68            //println!("my task1 is running");
69            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            //tokio::time::sleep(Duration::from_secs(100000)).await;
95            println!("my_task_c is running");
96            Ok(())
97        })
98    }
99}