delay-timer

delay-timer is a task manager based on a time wheel algorithm, which makes it easy to manage timed tasks, or to periodically execute arbitrary tasks such as closures..

The underlying runtime is currently based on smol, so upper level applications that want to extend asynchronous functionality need to use libraries that are compatible with smol.

Since the library currently includes features such as #[bench], it needs to be developed in a nightly version.

Examples

```

fn main() { let mut delaytimer = DelayTimer::new(); let taskbuilder = TaskBuilder::default();

delay_timer.add_task(build_task1(task_builder)).unwrap();

delay_timer.add_task(build_task2(task_builder)).unwrap();
delay_timer.add_task(build_task3(task_builder)).unwrap();
delay_timer.add_task(build_task5(task_builder)).unwrap();

sleep(Duration::new(2, 1_000_000));
delay_timer.remove_task(1).unwrap();

// cancel_task cancel_task is currently available,
// but the user does not currently have access to reasonable input data (record_id).

// Development of a version of delay_timer that supports rustc-stable,
// with full canca support is expected to be completed in version 0.2.0.

sleep(Duration::new(90, 0));
delay_timer.stop_delay_timer().unwrap();

}

fn buildtask1(mut taskbuilder: TaskBuilder) -> Task { let body = createasyncfnbody!({ println!("createasyncfnbody!--7");

    Timer::after(Duration::from_secs(3)).await;

    println!("create_async_fn_body:i'success");
    Ok(())
});
task_builder
    .set_task_id(1)
    .set_frequency(Frequency::Repeated("0/7 * * * * * *"))
    .spawn(body)

}

fn buildtask2(mut taskbuilder: TaskBuilder) -> Task { let body = createasyncfnbody!({ let mut res = surf::get("https://httpbin.org/get").await.unwrap(); dbg!(res.bodystring().await.unwrap());

    Ok(())
});
task_builder
    .set_frequency(Frequency::CountDown(2, "0/8 * * * * * *"))
    .set_task_id(2)
    .set_maximum_running_time(5)
    .spawn(body)

}

fn buildtask3(mut taskbuilder: TaskBuilder) -> Task { let body = unblockprocesstaskfn("php /home/open/project/rust/repo/myself/delaytimer/examples/tryspawn.php >> ./tryspawn.txt".into()); taskbuilder .setfrequency(Frequency::Once("@minutely")) .settaskid(3) .setmaximumrunning_time(5) .spawn(body) }

fn buildtask5(mut taskbuilder: TaskBuilder) -> Task { let body = generateclosuretemplate("delaytimer is easy to use. .".into()); taskbuilder .setfrequency(Frequency::Repeated( "0,10,15,25,50 0/1 * * Jan-Dec * 2020-2100", )) .settaskid(5) .setmaximumrunningtime(5) .spawn(body) }

pub fn generateclosuretemplate( name: String, ) -> impl Fn() -> Box + 'static + Send + Sync { move || { createdelaytaskhandler(asyncspawn(asynctemplate( gettimestamp() as i32, name.clone(), ))) } }

pub async fn asynctemplate(id: i32, name: String) -> Result<()> { let url = format!("https://httpbin.org/get?id={}&name={}", id, name); let mut res = surf::get(url).await.unwrap(); dbg!(res.bodystring().await.unwrap());

Ok(())

}

```

There's a lot more in the [examples] directory.

License

Licensed under either of

• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

To Do List

• [x] Disable unwrap related methods that will panic.
• [x] Thread and running task quit when delayTimer drop.
• [x] error handle need supplement.
• [x] neaten todo in code, replenish tests and benchmark.
• [x] batch-opration.
• [x] report-for-server.
• [x] TASK-TAG.
• [x] Future upgrade of delay_timer to multi-wheel mode, different excutor handling different wheels e.g. subtract laps for one wheel, run task for one wheel.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

The author comments:

Make an upgrade plan for smooth updates in the future, Such as stop serve back-up unfinished task then up new version serve load task.bak, Runing.