Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/insanusmokrassar/krontab
Library for using Crontab-like syntax in scheduling of some Kotlin Coroutines tasks to do from time to time
https://github.com/insanusmokrassar/krontab
crontab-format kotlin kotlin-android kotlin-coroutine-flow kotlin-coroutines kotlin-js kotlin-jvm kotlin-library kotlin-multiplatform scheduling
Last synced: about 3 hours ago
JSON representation
Library for using Crontab-like syntax in scheduling of some Kotlin Coroutines tasks to do from time to time
- Host: GitHub
- URL: https://github.com/insanusmokrassar/krontab
- Owner: InsanusMokrassar
- License: apache-2.0
- Created: 2019-11-19T12:41:14.000Z (about 5 years ago)
- Default Branch: master
- Last Pushed: 2025-01-27T16:43:56.000Z (7 days ago)
- Last Synced: 2025-01-27T22:34:03.170Z (7 days ago)
- Topics: crontab-format, kotlin, kotlin-android, kotlin-coroutine-flow, kotlin-coroutines, kotlin-js, kotlin-jvm, kotlin-library, kotlin-multiplatform, scheduling
- Language: Kotlin
- Homepage: https://docs.inmo.dev/krontab/index.html
- Size: 1.77 MB
- Stars: 106
- Watchers: 3
- Forks: 6
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
README
# krontab
[](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
[](https://inmodev_chat.t.me)
[](https://insanusmokrassar.github.io/krontab/)
[](https://docs.inmo.dev/krontab/index.html)
Library was created to give oppotunity to launch some things from time to time according to some schedule in
runtime of applications.
## How to use
There are several ways to configure and use this library:
* From some string
* From builder
Anyway, to start some action from time to time you will need to use one of extensions/functions:
```kotlin
val kronScheduler = /* creating of KronScheduler instance */;
kronScheduler.doWhile {
// some action
true // true - repeat on next time
}
```
### Including in project
If you want to include `krontab` in your project, just add next line to your
dependencies part:
```groovy
implementation "dev.inmo:krontab:$krontab_version"
```
Next version is the latest currently for the library:
[](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
For old version of Gradle, instead of `implementation` word developers must use `compile`.
### Config from string
Developers can use more simple way to configure repeat times is string. String configuring
like a `crontab`, but with a little bit different meanings:
```
/--------------- Seconds
| /------------- Minutes
| | /----------- Hours
| | | /--------- Days of months
| | | | /------- Months
| | | | | /----- (optional) Year
| | | | | | /--- (optional) Timezone offset
| | | | | | | / (optional) Week days
* * * * * * 0o *w
```
It is different with original `crontab` syntax for the reason, that expected that in practice developers
will use seconds and minutes with more probability than months (for example) or even years. In fact, developers will use
something like:
```kotlin
doWhile("/5 * * * *") {
println("Called")
true // true - repeat on next time
}
```
An other version:
```kotlin
doInfinity("/5 * * * *") {
println("Called")
}
```
Both of examples will print `Called` message every five seconds.
### Config via builder
Also, this library currently supports DSL for creating the same goals:
```kotlin
val kronScheduler = buildSchedule {
seconds {
from (0) every 5
}
}
kronScheduler.doWhile {
println("Called")
true // true - repeat on next time
}
```
Or
```kotlin
val kronScheduler = buildSchedule {
seconds {
0 every 5
}
}
kronScheduler.doWhile {
println("Called")
true // true - repeat on next time
}
```
Or
```kotlin
val kronScheduler = buildSchedule {
seconds {
0 every 5
}
}
kronScheduler.doInfinity {
println("Called")
}
```
All of these examples will do the same things: print `Called` message every five seconds.
### do\* functions
With regular `doOnce`/`doWhile`/`doInfinity` there are two types of their variations: **local** and **timezoned**. Local
variations (`doOnceLocal`/`doWhileLocal`/`doInfinityLocal`) will pass `DateTime` as an argument into the block:
```kotlin
doInfinityLocal("/5 * * * *") {
println(it) // will print current date time
}
```
Timezoned variations (`doOnceTz`/`doWhileTz`/`doInfinityTz`) will do the same thing but pass as an argument `DateTimeTz`:
```kotlin
doInfinityTz("/5 * * * * 0o") {
println(it) // will print current date time in UTC
}
```
It is useful in cases when you need to get the time of calling and avoid extra calls to system time.
#### Helpful table for
| | No args | Local `DateTime` | Local `DateTimeTz` with offset of `KronScheduler` |
|---| ------- | ---------------- | ------------------------------------------------- |
| **Call only near time** | doOnce | doOnceLocal | doOnceTz |
| **Call while condition is true** | doWhile | doWhileLocal | doWhileTz |
| **Work infinity*** | doInfinity | doInfinityLocal | doInfinityTz |
*Here there is an important notice, that `Work infinity` is not exactly `infinity`. Actually, that means that `do while
coroutine is alive` and in fact executing will be stopped when coroutine became cancelled.
### KronScheduler as a Flow
Any `KronScheduler`can e converted to a `Flow