Merge pull request #35 from BinChengZhao/feature/refactor

Version 0.11.0

Author: BinChengZhao

.gitignore

@@ -4,6 +4,8 @@
 /examples/target/
 /examples/*.lock
 .DS_Store
+/.vscode
+/.vscode/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
@@ -19,4 +21,4 @@ Cargo.lock
 *.log
 /*.txt
 *.dat
-.idea
+.idea

CHANGELOG.md

@@ -1,3 +1,18 @@
+# Version 0.11.0 
+
+## Changed
+- Optimized the entire delay-timer usage by removing macros for creating asynchronous tasks and now allowing users to use a closure that returns a Future.
+
+- The default internal runtime currently used by 'Tokio', 'smol' can also be manually enabled by the user.
+
+- Updated lots of utility cases, lots of documentation, and dependency updates.
+
+- Fixed a bug where tasks were executed ahead of time.([#33](https://github.com/BinChengZhao/delay-timer/issues/33))
+
+### Details
+
+Major refactoring of 'task execution'.
+
 # Version 0.10.1 
 
 ## Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "delay_timer"
-version = "0.10.1"
+version = "0.11.0"
 authors = ["binchengZhao <binchengZhao@outlook.com>"]
 edition = "2018"
 repository = "https://github.com/BinChengZhao/delay-timer"
@@ -21,10 +21,8 @@ name = "delay_timer"
 
 [features]
 default = []
-full = ["tokio-full"]
 
-tokio-full = ["tokio-support","status-report"]
-tokio-support = ["tokio"]
+full = ["status-report"]
 status-report = []
 
 
@@ -34,28 +32,33 @@ anyhow = "^1.0.31"
 rs-snowflake = "0.5.0"
 dashmap = "^4.0.2"
 lru = "^0.6.5"
+once_cell = "1.9.0"
 futures = "^0.3.13"
 smol = "^1.2.5"
-concat-idents = "1.1.2"
+concat-idents = "1.1.3"
 async-trait = "^0.1.48"
 event-listener = "^2.5.1"
 log = "^0.4.14"
+tracing = "0.1.29"
 thiserror = "^1.0.24"
 
 
-# Optional
-tokio = { version = "^1.3.0", features = ["full"] , optional = true }
+tokio = { version = "^1.3.0", features = ["full"] }
 
 [dev-dependencies]
 rand = "0.8.4"
 surf = "^2.1.0"
-tracing = "0.1.29"
+tracing-error = { version = "0.1.2" }
 tracing-subscriber = "0.2.0"
 tokio = { version = "^1.3.0", features = ["full"] }
 hyper= {version  = "^0.14.2" , features = ["full"] }
 pretty_env_logger = "^0.4"
 mockall = "^0.8.2"
 env_logger = "^0.8.3"
+color-eyre = { version =  "0.5.11", features = ["capture-spantrace", "issue-url"]}
+pretty_assertions = "0.6.1"
+thiserror = "1.0.19"
+ansi-parser = "0.6.5" # used for testing color schemes
 
 [dev-dependencies.async-std]
 version = "^1.9.0"
@@ -80,7 +83,6 @@ features = ["full", "test-util"]
 [[example]]
 name = "cycle_tokio_task"
 path = "examples/cycle_tokio_task.rs"
-required-features = ["tokio-support"]
 
 [[example]]
 name = "demo"
@@ -96,3 +98,6 @@ required-features = ["full"]
 #name = "demo"
 #path = "benches/demo.rs"
 #required-features = ["full"]
+
+[profile.dev.package.backtrace]
+opt-level = 3

README.md

@@ -14,7 +14,7 @@ delay-timer is a task manager based on a time wheel algorithm, which makes it ea
 
 The underlying runtime is based on the optional smol and tokio, and you can build your application with either one.
 
-The minimum-supported version of `rustc` is **1.49**.
+The minimum-supported version of `rustc` is **1.56**.
 
 Except for the simple execution in a few seconds, you can also specify a specific date, 
 such as Sunday at 4am to execute a backup task.
@@ -61,19 +61,19 @@ fn main() -> Result<()> {
 fn build_task_async_print() -> Result<Task, TaskError> {
     let mut task_builder = TaskBuilder::default();
 
-    let body = create_async_fn_body!({
+    let body = || async {
         println!("create_async_fn_body!");
 
         Timer::after(Duration::from_secs(3)).await;
 
         println!("create_async_fn_body:i'success");
-    });
+    };
 
     task_builder
         .set_task_id(1)
-        .set_frequency_repeated_by_seconds(1)
+        .set_frequency_repeated_by_cron_str("@secondly")
         .set_maximum_parallel_runnable_num(2)
-        .spawn(body)
+        .spawn_async_routine(body)
 }
 
  ```
@@ -116,22 +116,21 @@ async fn main() -> Result<()> {
 fn build_task_async_print() -> Result<Task, TaskError> {
     let mut task_builder = TaskBuilder::default();
 
-    let body = create_async_fn_body!({
+    let body = || async {
         println!("create_async_fn_body!");
 
         Timer::after(Duration::from_secs(3)).await;
 
         println!("create_async_fn_body:i'success");
-    });
+    };
 
     task_builder
         .set_task_id(1)
-        .set_frequency_repeated_by_seconds(6)
+        .set_frequency_repeated_by_cron_str("@secondly")
         .set_maximum_parallel_runnable_num(2)
-        .spawn(body)
+        .spawn_async_routine(body)
 }
 
-
  ```
 
 
@@ -149,21 +148,19 @@ fn build_task_async_print() -> Result<Task, TaskError> {
 
 
  let delay_timer = DelayTimer::new();
-
  let share_num = Arc::new(AtomicUsize::new(0));
  let share_num_bunshin = share_num.clone();
-
- let body = create_async_fn_body!((share_num_bunshin){
-     share_num_bunshin_ref.fetch_add(1, Release);
- });
-
+ 
+ let body = move || {
+     share_num_bunshin.fetch_add(1, Release);
+ };
+ 
  let task = TaskBuilder::default()
-     .set_frequency_count_down_by_seconds(1, 9)
+     .set_frequency_count_down_by_cron_str(expression, 3)
      .set_task_id(1)
-     .set_maximum_parallel_runnable_num(3)
-     .spawn(body)?;
+     .spawn_routine(body)?;
 
- delay_timer.add_task(task);
+ delay_timer.add_task(task)?;
 
  ```
 
@@ -176,29 +173,28 @@ fn build_task_async_print() -> Result<Task, TaskError> {
  use hyper::{Client, Uri};
 
 fn build_task_customized_async_task() -> Result<Task, TaskError> {
+    let id = 1;
+    let name = String::from("someting");
     let mut task_builder = TaskBuilder::default();
 
-    let body = generate_closure_template("delay_timer is easy to use. .".into());
+    let body = move || {
+        let name_ref = name.clone();
+        async move {
+            async_template(id, name_ref).await.expect("Request failed.");
+
+            sleep(Duration::from_secs(3)).await;
+
+            println!("create_async_fn_body:i'success");
+        }
+    };
+
     task_builder
         .set_frequency_repeated_by_cron_str("0,10,15,25,50 0/1 * * Jan-Dec * 2020-2100")
         .set_task_id(5)
         .set_maximum_running_time(5)
-        .spawn(body)
+        .spawn_async_routine(body)
 }
 
-pub fn generate_closure_template(
-    name: String,
-) -> impl Fn(TaskContext) -> Box<dyn DelayTaskHandler> + 'static + Send + Sync {
-    move |context| {
-        let future_inner = async_template(get_timestamp() as i32, name.clone());
-
-        let future = async move {
-            future_inner.await;
-            context.finish_task().await;
-        };
-        create_delay_task_handler(async_spawn(future))
-    }
-}
 
 pub async fn async_template(id: i32, name: String) -> Result<()> {
     let url = format!("https://httpbin.org/get?id={}&name={}", id, name);

benches/body.rs

@@ -23,7 +23,7 @@ fn bench_task_spwan(b: &mut Bencher) {
 
     // String parsing to corn-expression -> iterator is the most time-consuming operation about 1500ns ~ 3500 ns.
     // The iterator is used to find out when the next execution should take place, in about 500 ns.
-    b.iter(|| task_builder.spawn(body.clone()));
+    b.iter(|| task_builder.spawn_async_routine(body.clone()));
 }
 
 #[bench]
@@ -40,12 +40,12 @@ fn bench_maintain_task(b: &mut Bencher) {
         .set_maximum_running_time(5)
         .set_task_id(1);
 
-    // `task_builder.spawn(body)` is about 1500 ns .
+    // `task_builder.spawn_async_routine(body)` is about 1500 ns .
     // So maintain_task takes (result of bench - task_spawn)ns.  about 1000ns.
     b.iter(|| {
         block_on({
             async {
-                if let Ok(task) = task_builder.spawn(body) {
+                if let Ok(task) = task_builder.spawn_async_routine(body) {
                     timer.maintain_task(task, 1, 1).await.ok();
                 }
             }
@@ -57,7 +57,7 @@ fn bench_maintain_task(b: &mut Bencher) {
 fn bench_try_wait(b: &mut Bencher) {
     use std::process::Command;
 
-    if let Ok(mut child) = Command::new("ps").spawn() {
+    if let Ok(mut child) = Command::new("ps").spawn_async_routine() {
         b.iter(|| child.try_wait());
     }
 }

examples/cycle_tokio_task.rs

@@ -30,45 +30,35 @@ fn main() -> Result<()> {
 fn build_task_customized_async_task() -> Result<Task> {
     let mut task_builder = TaskBuilder::default();
 
-    let body = generate_closure_template("'delay_timer-is-easy-to-use.'".into());
+    let body = generate_closure_template;
 
     Ok(task_builder
         .set_frequency_repeated_by_cron_str("10,15,25,50 0/1 * * Jan-Dec * 2020-2100")
         .set_task_id(5)
         .set_maximum_running_time(15)
-        .spawn(body)?)
+        .spawn_async_routine(body)?)
 }
 
 fn build_wake_task() -> Result<Task> {
     let mut task_builder = TaskBuilder::default();
 
     let thread: Thread = current();
-    let body = move |_| {
+    let body = move || {
         println!("bye bye");
         thread.unpark();
-        create_default_delay_task_handler()
     };
 
     Ok(task_builder
         .set_frequency_by_candy(CandyFrequency::Repeated(AuspiciousDay::Wake))
         .set_task_id(7)
         .set_maximum_running_time(50)
-        .spawn(body)?)
+        .spawn_routine(body)?)
 }
 
-pub fn generate_closure_template(
-    name: String,
-) -> impl Fn(TaskContext) -> Box<dyn DelayTaskHandler> + 'static + Send + Sync {
-    move |context| {
-        let future_inner = async_template(get_timestamp() as i32, name.clone());
-
-        let future = async move {
-            future_inner.await.ok();
-            context.finish_task(None).await;
-        };
-
-        create_delay_task_handler(async_spawn_by_tokio(future))
-    }
+pub async fn generate_closure_template() {
+    let name: String = "'delay_timer-is-easy-to-use.'".into();
+    let future_inner = async_template(get_timestamp() as i32, name.clone());
+    future_inner.await.ok();
 }
 
 pub async fn async_template(id: i32, name: String) -> Result<()> {