mirror of
https://github.com/InsanusMokrassar/krontab.git
synced 2025-12-13 16:35:43 +00:00
Compare commits
1 Commits
031e42bd2d
...
0.2.1
| Author | SHA1 | Date | |
|---|---|---|---|
| 081e3a8dab |
5
.github/FUNDING.yml
vendored
5
.github/FUNDING.yml
vendored
@@ -1,5 +0,0 @@
|
||||
# These are supported funding model platforms
|
||||
|
||||
patreon: InsanusMokrassar
|
||||
|
||||
custom: ['https://paypal.me/InsanusMokrassar?locale.x=ru_RU']
|
||||
3
.github/labeler.yml
vendored
3
.github/labeler.yml
vendored
@@ -1,3 +0,0 @@
|
||||
code: "**/*.kt"
|
||||
gradle: "**/*.gradle"
|
||||
markdown: "**/*.md"
|
||||
13
.github/workflows/greetings.yml
vendored
13
.github/workflows/greetings.yml
vendored
@@ -1,13 +0,0 @@
|
||||
name: Greetings
|
||||
|
||||
on: [pull_request, issues]
|
||||
|
||||
jobs:
|
||||
greeting:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/first-interaction@v1
|
||||
with:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
issue-message: 'Welcome with your first issue'
|
||||
pr-message: 'Welcome with your first Pull Request'
|
||||
21
.github/workflows/kdocs.yml
vendored
21
.github/workflows/kdocs.yml
vendored
@@ -1,21 +0,0 @@
|
||||
name: Publish KDocs
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
jobs:
|
||||
publishing:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- uses: actions/setup-java@v1
|
||||
with:
|
||||
java-version: 17
|
||||
- name: Build
|
||||
run: ./gradlew dokkaHtml
|
||||
- name: Publish KDocs
|
||||
uses: peaceiris/actions-gh-pages@v3
|
||||
with:
|
||||
github_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
publish_dir: ./build/dokka/html
|
||||
publish_branch: kdocs
|
||||
18
.github/workflows/label.yml
vendored
18
.github/workflows/label.yml
vendored
@@ -1,18 +0,0 @@
|
||||
# This workflow will triage pull requests and apply a label based on the
|
||||
# paths that are modified in the pull request.
|
||||
#
|
||||
# To use this workflow, you will need to set up a .github/labeler.yml
|
||||
# file with configuration. For more information, see:
|
||||
# https://github.com/actions/labeler/blob/master/README.md
|
||||
|
||||
name: "Pull Request Labeler"
|
||||
on:
|
||||
- pull_request
|
||||
|
||||
jobs:
|
||||
triage:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/labeler@v2
|
||||
with:
|
||||
repo-token: "${{ secrets.GITHUB_TOKEN }}"
|
||||
27
.github/workflows/publishing_packages.yml
vendored
27
.github/workflows/publishing_packages.yml
vendored
@@ -1,27 +0,0 @@
|
||||
name: Publish package to GitHub Packages
|
||||
on: [push]
|
||||
jobs:
|
||||
publishing:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- uses: actions/setup-java@v1
|
||||
with:
|
||||
java-version: 17
|
||||
- name: Update version
|
||||
run: |
|
||||
branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
|
||||
sed -i -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" gradle.properties
|
||||
- name: prebuild
|
||||
run: ./gradlew clean build
|
||||
- name: Publish to Gitea
|
||||
continue-on-error: true
|
||||
run: ./gradlew publishAllPublicationsToGiteaRepository
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
- name: Publish package
|
||||
continue-on-error: true
|
||||
run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository
|
||||
env:
|
||||
GITHUBPACKAGES_USER: ${{ github.actor }}
|
||||
GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
@@ -9,6 +9,4 @@ settings.xml
|
||||
build/
|
||||
out/
|
||||
|
||||
kotlin-js-store/
|
||||
|
||||
local.properties
|
||||
|
||||
374
CHANGELOG.md
374
CHANGELOG.md
@@ -1,376 +1,12 @@
|
||||
# Changelog
|
||||
|
||||
## 2.2.8
|
||||
|
||||
* `Version`:
|
||||
* `Coroutines`: `1.8.0`
|
||||
|
||||
## 2.2.7
|
||||
|
||||
* `Version`:
|
||||
* `Klock`: `5.3.1`
|
||||
* `AndroidXWork`: `2.9.0`
|
||||
|
||||
## 2.2.6
|
||||
|
||||
**Since this version klock depdendency replaced with `com.soywiz.korge:korlibs-time`**
|
||||
|
||||
* `Version`:
|
||||
* `Klock`: `5.3.0`
|
||||
|
||||
## 2.2.5
|
||||
|
||||
* `Versions`
|
||||
* `Kotlin`: `1.9.22`
|
||||
* `Serialization`: `1.6.2`
|
||||
|
||||
## 2.2.4
|
||||
|
||||
* `Versions`
|
||||
* `Kotlin`: `1.9.21`
|
||||
* `Serialization`: `1.6.1`
|
||||
|
||||
## 2.2.3
|
||||
|
||||
**THIS UPDATE CONTAINS UPGRADE OF USED JDK UP TO 17**
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.9.20`
|
||||
|
||||
## 2.2.2
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.9.20-RC`
|
||||
* `Android` (min/target): `34`
|
||||
|
||||
## 2.2.1
|
||||
|
||||
* Potential fix of [#65](https://github.com/InsanusMokrassar/krontab/issues/65)
|
||||
* Versions
|
||||
* `Kotlin`: `1.9.20-Beta`
|
||||
* `Klock`: `4.0.10`
|
||||
* `Serialization`: `1.6.0`
|
||||
|
||||
## 2.2.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.9.0`
|
||||
* `Coroutines`: `1.7.3`
|
||||
* `Klock`: `4.0.9`
|
||||
|
||||
## 2.1.2
|
||||
|
||||
* Versions
|
||||
* `Coroutines`: `1.7.2`
|
||||
* All callbacks for standard extensions like `doInfinity` now fully inline
|
||||
|
||||
## 2.1.1
|
||||
|
||||
* `asFlowWithoutDelays` and `asTzFlowWithoutDelays` will have nullable `since` parameters with default to `null`
|
||||
to avoid any inconsistency of `Flow` idiom.
|
||||
<details>
|
||||
<summary>About the reason of changes</summary>
|
||||
Cold flows should not contain some state by default. So, it was not right to save some `DateTime`/`DateTimeTz`
|
||||
by default. Now it will not use some external state unless developers will set it manually
|
||||
</details>
|
||||
|
||||
## 2.1.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.8.22`
|
||||
* `Klock`: `4.0.3`
|
||||
* New value class `KrontabConfig`. It is preferable way to create `KronScheduler` instead of
|
||||
`KrontabTemplate` since this update
|
||||
* You may configure krontab with builders using simple `KronScheduler` invoke extension
|
||||
* New useful extensions like `KronScheduler.daily`
|
||||
* `KrontabTemplateWrapper` is obsolete in favor to `KrontabConfig`
|
||||
|
||||
## 2.0.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.8.21`
|
||||
* `Klock`: `4.0.1`
|
||||
* Support of `mingwx64` platform
|
||||
|
||||
## 1.0.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.8.20`
|
||||
* `AndroidXWork`: `2.8.1`
|
||||
|
||||
## 0.10.0
|
||||
|
||||
* New extensions for `KronScheduler`:
|
||||
* `asTzFlowWithoutDelays`/`asFlowWithoutDelays`
|
||||
* `asTzFlowWithDelays`/`asFlowWithDelays`
|
||||
* Old `KronScheduler.asFlow` and `KronScheduler.asTzFlow` temporarily marked as deprecated: after several versions their
|
||||
behaviour will be changed to undelayed one
|
||||
* All the flow extensions now use `cold` non-channel flows. Potentially it should increase performance and decrease memory usage
|
||||
|
||||
## 0.9.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.8.10`
|
||||
* `AndroidXWork`: `2.8.0`
|
||||
|
||||
## 0.8.5
|
||||
|
||||
* Project is now available in owner `Gitea`: https://git.inmo.dev/InsanusMokrassar/-/packages/maven/dev.inmo-krontab
|
||||
* `KronSchedulerTz#next` with incoming `DateTime` now will use adjusted local time instead of unadjusted one
|
||||
* `CronDateTimeSchedulerTz#next` with incoming `DateTime` will convert that parameter to internal offset directly
|
||||
|
||||
## 0.8.4
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.7.22`
|
||||
|
||||
## 0.8.3
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.7.21`
|
||||
* `Klock`: `3.4.0`
|
||||
|
||||
## 0.8.2
|
||||
|
||||
**THIS VERSION HAS CHANGED COMPILE ANDROID SDK FROM 32 -> 33**
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.7.20`
|
||||
* `Klock`: `3.2.0`
|
||||
|
||||
## 0.8.1
|
||||
|
||||
* Versions
|
||||
* `Klock`: `3.1.0`
|
||||
|
||||
## 0.8.0
|
||||
|
||||
**THIS VERSION HAS CHANGED MIN ANDROID SDK FROM 19 -> 21**
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.7.10`
|
||||
* `Klock`: `3.0.0`
|
||||
|
||||
## 0.7.5
|
||||
|
||||
* Versions
|
||||
* `Coroutines`: `1.6.4`
|
||||
|
||||
## 0.7.4
|
||||
|
||||
* Versions
|
||||
* `Coroutines`: `1.6.3`
|
||||
|
||||
## 0.7.3
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.6.21`
|
||||
* Several bug fixes ([#27](https://github.com/InsanusMokrassar/krontab/issues/27), [#34](https://github.com/InsanusMokrassar/krontab/issues/34))
|
||||
* New factories for `KronScheduler` and `KronSchedulerTz` (fix of [#35](https://github.com/InsanusMokrassar/krontab/issues/35))
|
||||
* Fill extensions for flow with time zones (fix of [#33](https://github.com/InsanusMokrassar/krontab/issues/33))
|
||||
|
||||
## 0.7.2
|
||||
|
||||
* Versions
|
||||
* `Coroutines`: `1.6.1`
|
||||
* `Klock`: `2.7.0`
|
||||
* Deprecate `do*Local` due to their redundancy (use `do*` instead)
|
||||
* Add support of milliseconds as optional parameter after month (fix of [#31](https://github.com/InsanusMokrassar/krontab/issues/31))
|
||||
* Add support of filters for `Flow`s with `DateTime` (fix of [#30](https://github.com/InsanusMokrassar/krontab/issues/30))
|
||||
|
||||
## 0.7.1
|
||||
|
||||
* Versions
|
||||
* `Klock`: `2.5.2`
|
||||
|
||||
## 0.7.0
|
||||
|
||||
**ALL DEPRECATIONS HAVE BEEN REMOVED**
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.6.10`
|
||||
* `Klock`: `2.4.10`
|
||||
* `Coroutines`: `1.6.0`
|
||||
* `Androidx Work`: `2.7.1`
|
||||
|
||||
## 0.6.6
|
||||
|
||||
* Versions
|
||||
* `Klock`: `2.4.8`
|
||||
* `Androidx Work`: `2.7.0`
|
||||
|
||||
## 0.6.5
|
||||
|
||||
* Flows now use `doWhile` functions
|
||||
* `doWhile` now use additional delay (for 1 ms) for cases when `block` executing too fast
|
||||
* New extensions for `KronScheduler`: `do(Once/While/Infinity)Local`/`do(Once/While/Infinity)Tz`
|
||||
|
||||
## 0.6.4
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.5.31`
|
||||
* `Coroutines`: `1.5.2`
|
||||
* `Klock`: `2.4.2`
|
||||
* `Androidx Work`: `2.6.0`
|
||||
|
||||
## 0.6.3
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.5.30`
|
||||
* `Klock`: `2.4.0`
|
||||
|
||||
## 0.6.2
|
||||
|
||||
**LEGACY COMPILER VARIANT FOR JS IS NOT AVAILABLE SINCE THIS UPDATE**
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.5.21`
|
||||
* `Coroutines`: `1.5.1`
|
||||
* `Klock`: `2.3.1`
|
||||
|
||||
## 0.6.1
|
||||
|
||||
* Versions
|
||||
* `Klock`: `2.1.0` -> `2.1.2`
|
||||
* Rewriting of default mechanism of `KronScheduler`s
|
||||
|
||||
## 0.6.0
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.4.32` -> `1.5.10`
|
||||
* `Coroutines`: `1.4.3` -> `1.5.0`
|
||||
* `Klock`: `2.0.7` -> `2.1.0`
|
||||
|
||||
## 0.5.2
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.4.31` -> `1.4.32`
|
||||
* Supporting of weekdays
|
||||
* Supporting of timezones
|
||||
* Any `KronScheduler` now can be used for calling `next` with `DateTimeTz`
|
||||
* New type `KronSchedulerTz`
|
||||
* `SchedulerFlow` has been deprecated
|
||||
* New extension `asTzFlow` and small changes in `asFlow` logic
|
||||
* `merge` extensions now return `CollectionKronScheduler` instead of just `KronScheduler`
|
||||
|
||||
## 0.5.1
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.4.21` -> `1.4.31`
|
||||
* `Coroutines`: `1.4.2` -> `1.4.3`
|
||||
* `Klock`: `2.0.3` -> `2.0.7`
|
||||
* `Androidx Work`: `2.4.0` -> `2.5.0`
|
||||
|
||||
## 0.5.0 Years
|
||||
|
||||
**BREAKING CHANGES**
|
||||
|
||||
* `CronDateTimeScheduler` has been marked as `internal` and no longer accessible outside of internal functions
|
||||
* Old methods `merge` and `plus` related to `CronDateTimeScheduler` has been marked as `deprecated` and changed their
|
||||
parameters types - it is `KronScheduler` now
|
||||
* New methods `merge` has been added
|
||||
* **`KronScheduler#next` method now is nullable. Use `nextOrRelative`/`nextOrNow` to get next time certainly**
|
||||
* **Years was added as optional part of krontab template and opportunity in `SchedulerBuilder`**
|
||||
* New builder `YearsBuilder`
|
||||
* `SchedulerFlow#collectSafely` will be normally (without exceptions) finish when `next` of scheduler will return
|
||||
null
|
||||
* `KronScheduler#doOnce` will run code immediately in case when `next` is returning null value
|
||||
* `KrontabTemplateWrapper` has been added
|
||||
* New extension `KrontabTemplate#toKronScheduler` (works as `toSchedule`)
|
||||
* **Fixed issue related to the fact that `toNearDateTime` of `CronDateTime` incorrectly handled months**
|
||||
* **Android target has been added**
|
||||
|
||||
## 0.4.2
|
||||
|
||||
* Versions
|
||||
* `Kotlin`: `1.4.20` -> `1.4.21`
|
||||
* `Klock`: `2.0.1` -> `2.0.3`
|
||||
* `CronDateTimeScheduler` now is deprecated and will be set up as `internal` in future
|
||||
|
||||
## 0.4.1
|
||||
|
||||
* Versions:
|
||||
* `Coroutines`: `1.4.1` -> `1.4.2`
|
||||
* `Klock`: `2.0.0` -> `2.0.1`
|
||||
* `CronDateTimeScheduler` now is public
|
||||
* New functions for `CronDateTimeScheduler`
|
||||
* Add `CollectionKronScheduler`. It will give opportunity to unite several schedulers in one
|
||||
|
||||
## 0.4.0
|
||||
|
||||
**BREAKING CHANGES**
|
||||
Package of project has been changed. Migration:
|
||||
|
||||
* Replace in your dependencies `com.insanusmokrassar:krontab` by `dev.inmo:krontab`
|
||||
* Replace in your project all imports `com.insanusmokrassar.krontab` by `dev.inmo.krontab`
|
||||
|
||||
* Versions:
|
||||
* `Kotlin`: `1.4.10` -> `1.4.20`
|
||||
* `Klock`: `1.12.1` -> `2.0.0`
|
||||
|
||||
## 0.3.3
|
||||
|
||||
* Versions:
|
||||
* `Coroutines`: `1.3.9` -> `1.4.1`
|
||||
|
||||
## 0.3.2
|
||||
|
||||
* Function `TimeBuilder#each` was added (works as `at`)
|
||||
* Add opportunity to use `first` shortcuts:
|
||||
* Value property `TimeBuilder#first` for including via functions like `TimeBuilder#at`
|
||||
* Shortcut for kron string format `f` or `F`
|
||||
* Add opportunity to use `last` shortcuts:
|
||||
* Value property `TimeBuilder#last` for including via functions like `TimeBuilder#at`
|
||||
* Shortcut for kron string format `l` or `L`
|
||||
|
||||
## 0.3.1
|
||||
|
||||
* Versions:
|
||||
* `Kotlin`: `1.4.0` -> `1.4.10`
|
||||
* `Klock`: `1.12.0` -> `1.12.1`
|
||||
|
||||
## 0.3.0
|
||||
|
||||
* Versions:
|
||||
* `Kotlin`: `1.3.72` -> `1.4.0`
|
||||
* `Coroutines`: `1.3.8` -> `1.3.9`
|
||||
* `Klock`: `1.11.14` -> `1.12.0`
|
||||
* Typealias `KrontabTemplate` was added
|
||||
* Extension `KrontabTemplate#toSchedule` was added
|
||||
|
||||
### 0.2.4
|
||||
|
||||
* Updates in libraries:
|
||||
* Klock `1.11.3` -> `1.11.14`
|
||||
* Coroutines `1.3.7` -> `1.3.8`
|
||||
* Ranges support were included. Now it is possible to correctly use syntax `0-5` in strings schedules
|
||||
|
||||
## 0.2.3
|
||||
|
||||
* Updates in libraries:
|
||||
* Kotlin `1.3.70` -> `1.3.72`
|
||||
* Coroutines `1.3.5` -> `1.3.7`
|
||||
* Klock `1.10.0` -> `1.11.3`
|
||||
* A lot of KDocs added and fixed
|
||||
* `EverySecondScheduler` changed its building logic - now it is lazy with builder using
|
||||
* `KronScheduler#doOnce` was optimized: now it will be explicitly called once and return result of its calculations
|
||||
* `KronScheduler#doWhile` was rewritten to use `KronScheduler#doOnce` for calculations of `block` result
|
||||
* New `buildSchedule(String)` function as a shortcut for `createSimpleScheduler(String)`
|
||||
|
||||
## 0.2.2
|
||||
|
||||
* Updates in libraries:
|
||||
* Kotlin `1.3.61` -> `1.3.70`
|
||||
* Coroutines `1.3.3` -> `1.3.5`
|
||||
* Klock `1.8.6` -> `1.10.0`
|
||||
|
||||
## 0.2.1
|
||||
|
||||
* Added support of flows: now any `KronScheduler` can be convert to `Flow<DateTime>` using `asFlow` extension
|
||||
|
||||
## 0.2.0
|
||||
# 0.2.0
|
||||
|
||||
* Updated way of publishing (for more info look at the [git](https://git.insanusmokrassar.com/InsanusMokrassar/krontab))
|
||||
* Updates in libraries:
|
||||
* Coroutines `1.3.2` -> `1.3.3`
|
||||
* Klock `1.7.3` -> `1.8.6`
|
||||
|
||||
## 0.2.1
|
||||
|
||||
* Added support of flows: now any `KronScheduler` can be convert to `Flow<DateTime>` using `asFlow` extension
|
||||
|
||||
113
README.md
113
README.md
@@ -1,20 +1,18 @@
|
||||
# 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)
|
||||
|
||||
[  ](https://bintray.com/insanusmokrassar/InsanusMokrassar/krontab/_latestVersion)
|
||||
|
||||
Library was created to give oppotunity to launch some things from time to time according to some schedule in
|
||||
runtime of applications.
|
||||
|
||||
| Table of content |
|
||||
|---|
|
||||
| [ How to use ](#how-to-use) |
|
||||
| [ How to use: Including in project ](#including-in-project) |
|
||||
| [ How to use: Config from string ](#config-from-string) |
|
||||
| [ How to use: Config via builder (DSL preview) ](#config-via-builder) |
|
||||
| [ How to use: KronScheduler as a Flow ](#KronScheduler-as-a-Flow) |
|
||||
|
||||
## How to use
|
||||
|
||||
There are several ways to configure and use this library:
|
||||
@@ -27,7 +25,7 @@ Anyway, to start some action from time to time you will need to use one of exten
|
||||
```kotlin
|
||||
val kronScheduler = /* creating of KronScheduler instance */;
|
||||
|
||||
kronScheduler.doWhile {
|
||||
kronScheuler.doWhile {
|
||||
// some action
|
||||
true // true - repeat on next time
|
||||
}
|
||||
@@ -39,12 +37,12 @@ If you want to include `krontab` in your project, just add next line to your
|
||||
dependencies part:
|
||||
|
||||
```groovy
|
||||
implementation "dev.inmo:krontab:$krontab_version"
|
||||
implementation "com.insanusmokrassar:krontab:$krontab_version"
|
||||
```
|
||||
|
||||
Next version is the latest currently for the library:
|
||||
|
||||
[](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
|
||||
[  ](https://bintray.com/insanusmokrassar/InsanusMokrassar/krontab/_latestVersion)
|
||||
|
||||
For old version of Gradle, instead of `implementation` word developers must use `compile`.
|
||||
|
||||
@@ -52,22 +50,19 @@ For old version of Gradle, instead of `implementation` word developers must use
|
||||
|
||||
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
|
||||
/-------- Seconds
|
||||
| /------ Minutes
|
||||
| | /---- Hours
|
||||
| | | /-- Days of months
|
||||
| | | | / Months
|
||||
| | | | |
|
||||
* * * * *
|
||||
```
|
||||
|
||||
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:
|
||||
will use seconds and minutes with more probability than months (for example). In fact, developers will use something
|
||||
like:
|
||||
|
||||
```kotlin
|
||||
doWhile("/5 * * * *") {
|
||||
@@ -76,7 +71,7 @@ doWhile("/5 * * * *") {
|
||||
}
|
||||
```
|
||||
|
||||
An other version:
|
||||
Or more version:
|
||||
|
||||
```kotlin
|
||||
doInfinity("/5 * * * *") {
|
||||
@@ -88,7 +83,7 @@ Both of examples will print `Called` message every five seconds.
|
||||
|
||||
### Config via builder
|
||||
|
||||
Also, this library currently supports DSL for creating the same goals:
|
||||
Also this library currently supports DSL for creating the same goals:
|
||||
|
||||
```kotlin
|
||||
val kronScheduler = buildSchedule {
|
||||
@@ -131,38 +126,6 @@ kronScheduler.doInfinity {
|
||||
|
||||
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<DateTime` using extension `asFlow`:
|
||||
@@ -177,8 +140,8 @@ val kronScheduler = buildSchedule {
|
||||
val flow = kronScheduler.asFlow()
|
||||
```
|
||||
|
||||
So, in this case any operations related to flow are available and it is expected that they will work correctly. For
|
||||
example, it is possible to use this flow with `takeWhile`:
|
||||
So, in this case any operations related to flow are available and it is expected tt th will work correctly. For example,
|
||||
it is possible to use this flow with `takeWhile`:
|
||||
|
||||
```kotlin
|
||||
flow.takeWhile {
|
||||
@@ -187,27 +150,3 @@ flow.takeWhile {
|
||||
action()
|
||||
}
|
||||
```
|
||||
|
||||
### Offsets
|
||||
|
||||
Offsets in this library works via passing parameter ending with `o` in any place after `month` config. Currently
|
||||
there is only one format supported for offsets: minutes of offsets. To use time zones you will need to call `next`
|
||||
method with `DateTimeTz` argument or `nextTimeZoned` method with any `KronScheduler` instance, but in case if this
|
||||
scheduler is not instance of `KronSchedulerTz` it will work like you passed just `DateTime`.
|
||||
|
||||
Besides, in case you wish to use time zones explicitly, you will need to get `KronSchedulerTz`. It is possible by:
|
||||
|
||||
* Using `createSimpleScheduler`/`buildSchedule`/`KrontabTemplate#toSchedule`/`KrontabTemplate#toKronScheduler` methods
|
||||
with passing `defaultOffset` parameter
|
||||
* Using `SchedulerBuilder#build`/`createSimpleScheduler`/`buildSchedule`/`KrontabTemplate#toSchedule`/`KrontabTemplate#toKronScheduler`
|
||||
methods with casting to `KronSchedulerTz` in case you are pretty sure that it is timezoned `KronScheduler`
|
||||
* Creating your own implementation of `KronSchedulerTz`
|
||||
|
||||
### Note about week days
|
||||
|
||||
Unlike original CRON, here week days:
|
||||
|
||||
* Works as `AND`: cron date time will search first day which will pass requirement according all parameters including
|
||||
week days
|
||||
* You may use any related to numbers syntax with week days: `0-3w`, `0,1,2,3w`, etc.
|
||||
* Week days (like years and offsets) are optional and can be placed anywhere after `month`
|
||||
|
||||
@@ -1 +0,0 @@
|
||||
theme: jekyll-theme-cayman
|
||||
113
build.gradle
113
build.gradle
@@ -1,147 +1,70 @@
|
||||
buildscript {
|
||||
repositories {
|
||||
mavenLocal()
|
||||
// jcenter()
|
||||
jcenter()
|
||||
mavenCentral()
|
||||
google()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
|
||||
classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
|
||||
classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
|
||||
classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
|
||||
classpath "com.android.tools.build:gradle:$android_gradle_version"
|
||||
classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
|
||||
}
|
||||
}
|
||||
|
||||
plugins {
|
||||
id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version"
|
||||
id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version"
|
||||
id "org.jetbrains.dokka" version "$dokka_version"
|
||||
}
|
||||
|
||||
// temporal crutch until legacy tests will be stabled or legacy target will be removed
|
||||
allprojects {
|
||||
if (it != rootProject.findProject("docs")) {
|
||||
tasks.whenTaskAdded { task ->
|
||||
if(task.name == "jsLegacyBrowserTest" || task.name == "jsLegacyNodeTest") {
|
||||
task.enabled = false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
apply plugin: "com.android.library"
|
||||
|
||||
project.version = "$version"
|
||||
project.group = "dev.inmo"
|
||||
project.version = "0.2.1"
|
||||
project.group = "com.insanusmokrassar"
|
||||
|
||||
apply from: "publish.gradle"
|
||||
apply from: "github_release.gradle"
|
||||
|
||||
repositories {
|
||||
mavenLocal()
|
||||
// jcenter()
|
||||
jcenter()
|
||||
mavenCentral()
|
||||
// maven { url "https://kotlin.bintray.com/kotlinx" }
|
||||
google()
|
||||
maven { url "https://kotlin.bintray.com/kotlinx" }
|
||||
}
|
||||
|
||||
apply from: './dokka.gradle'
|
||||
|
||||
kotlin {
|
||||
jvm()
|
||||
js(IR) {
|
||||
browser()
|
||||
nodejs()
|
||||
}
|
||||
android {
|
||||
publishAllLibraryVariants()
|
||||
}
|
||||
linuxX64()
|
||||
mingwX64()
|
||||
linuxArm64()
|
||||
|
||||
js()
|
||||
|
||||
sourceSets {
|
||||
commonMain {
|
||||
dependencies {
|
||||
implementation kotlin('stdlib')
|
||||
api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
|
||||
api "org.jetbrains.kotlinx:kotlinx-serialization-core:$kotlin_serialization_version"
|
||||
api "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$kotlin_coroutines_version"
|
||||
|
||||
api "com.soywiz.korge:korlibs-time:$klockVersion"
|
||||
api "com.soywiz.korlibs.klock:klock:$klockVersion"
|
||||
}
|
||||
}
|
||||
|
||||
androidMain {
|
||||
dependencies {
|
||||
api "androidx.work:work-runtime-ktx:$androidx_work_version"
|
||||
}
|
||||
}
|
||||
|
||||
commonTest {
|
||||
dependencies {
|
||||
implementation kotlin('test-common')
|
||||
implementation kotlin('test-annotations-common')
|
||||
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
|
||||
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutines_version"
|
||||
}
|
||||
}
|
||||
jvmMain {
|
||||
dependencies {
|
||||
api "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
|
||||
}
|
||||
}
|
||||
jvmTest {
|
||||
dependencies {
|
||||
implementation kotlin('test-junit')
|
||||
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
|
||||
}
|
||||
}
|
||||
jsTest {
|
||||
jsMain {
|
||||
dependencies {
|
||||
implementation kotlin('test-js')
|
||||
}
|
||||
}
|
||||
androidUnitTest {
|
||||
dependencies {
|
||||
implementation kotlin('test-junit')
|
||||
api "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$kotlin_coroutines_version"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
apply plugin: 'com.getkeepsafe.dexcount'
|
||||
|
||||
android {
|
||||
compileSdk "$android_compileSdkVersion".toInteger()
|
||||
buildToolsVersion = "$android_buildToolsVersion"
|
||||
namespace "${group}.${project.name}"
|
||||
|
||||
defaultConfig {
|
||||
minSdkVersion "$android_minSdkVersion".toInteger()
|
||||
targetSdkVersion "$android_compileSdkVersion".toInteger()
|
||||
versionCode "${android_code_version}".toInteger()
|
||||
versionName "$version"
|
||||
}
|
||||
buildTypes {
|
||||
release {
|
||||
minifyEnabled false
|
||||
}
|
||||
debug {
|
||||
debuggable true
|
||||
}
|
||||
}
|
||||
|
||||
compileOptions {
|
||||
sourceCompatibility JavaVersion.VERSION_17
|
||||
targetCompatibility JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
sourceSets {
|
||||
main.java.srcDirs += 'src/main/kotlin'
|
||||
test {
|
||||
java.srcDir file("src/jvmTest")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
java {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
function parse() {
|
||||
version=$1
|
||||
|
||||
while IFS= read -r line && [ -z "`echo $line | grep -e "^#\+ $version"`" ]
|
||||
do
|
||||
: # do nothing
|
||||
done
|
||||
|
||||
while IFS= read -r line && [ -z "`echo $line | grep -e "^#\+"`" ]
|
||||
do
|
||||
echo "$line"
|
||||
done
|
||||
}
|
||||
|
||||
version=$1
|
||||
file=$2
|
||||
|
||||
if [ -n "$file" ]; then
|
||||
parse $version < "$file"
|
||||
else
|
||||
parse $version
|
||||
fi
|
||||
54
dokka.gradle
54
dokka.gradle
@@ -1,54 +0,0 @@
|
||||
dokkaHtml {
|
||||
String dokkaOutputDirectoryPath = null
|
||||
switch (true) {
|
||||
case project.hasProperty("DOKKA_PATH"):
|
||||
dokkaOutputDirectoryPath = project.property("DOKKA_PATH").toString()
|
||||
break
|
||||
case System.getenv("DOKKA_PATH") != null:
|
||||
dokkaOutputDirectoryPath = System.getenv("DOKKA_PATH")
|
||||
break
|
||||
}
|
||||
if (dokkaOutputDirectoryPath != null) {
|
||||
File outputDirectoryFile = new File(dokkaOutputDirectoryPath)
|
||||
outputDirectoryFile.mkdirs()
|
||||
outputDirectory = outputDirectoryFile
|
||||
}
|
||||
|
||||
moduleName.set("kdocs")
|
||||
|
||||
dokkaSourceSets {
|
||||
switch (true) {
|
||||
case project.hasProperty("DOKKA_PATH"):
|
||||
outputDirectory = new File(project.property("DOKKA_PATH").toString())
|
||||
break
|
||||
case System.getenv("DOKKA_PATH") != null:
|
||||
outputDirectory = new File(System.getenv("DOKKA_PATH"))
|
||||
break
|
||||
}
|
||||
|
||||
dokkaSourceSets {
|
||||
configureEach {
|
||||
skipDeprecated.set(true)
|
||||
|
||||
sourceLink {
|
||||
localDirectory.set(file("./"))
|
||||
remoteUrl.set(new URL("https://github.com/InsanusMokrassar/krontab/blob/master/"))
|
||||
remoteLineSuffix.set("#L")
|
||||
}
|
||||
}
|
||||
|
||||
named("commonMain") {
|
||||
sourceRoots.setFrom(findSourcesWithName("commonMain"))
|
||||
}
|
||||
|
||||
//
|
||||
// named("jsMain") {
|
||||
// sourceRoot { path = "src/jsMain" }
|
||||
// }
|
||||
//
|
||||
// named("jvmMain") {
|
||||
// sourceRoot { path = "src/jvmMain" }
|
||||
// }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
private String getCurrentVersionChangelog(String version) {
|
||||
OutputStream changelogDataOS = new ByteArrayOutputStream()
|
||||
exec {
|
||||
commandLine 'chmod', "+x", './changelog_parser.sh'
|
||||
}
|
||||
exec {
|
||||
standardOutput = changelogDataOS
|
||||
commandLine './changelog_parser.sh', "$version", 'CHANGELOG.md'
|
||||
}
|
||||
|
||||
return changelogDataOS.toString().trim()
|
||||
}
|
||||
|
||||
if (new File(projectDir, "secret.gradle").exists()) {
|
||||
apply from: './secret.gradle'
|
||||
apply plugin: "com.github.breadmoirai.github-release"
|
||||
|
||||
githubRelease {
|
||||
token "${project.property('GITHUB_RELEASE_TOKEN')}"
|
||||
|
||||
owner = "InsanusMokrassar"
|
||||
repo = "${rootProject.name}"
|
||||
|
||||
tagName = "v${project.version}"
|
||||
releaseName = "${project.version}"
|
||||
targetCommitish = "${project.version}"
|
||||
|
||||
body = getCurrentVersionChangelog("${project.version}")
|
||||
}
|
||||
}
|
||||
@@ -1,40 +1,9 @@
|
||||
org.gradle.jvmargs=-Xmx512m
|
||||
kotlin.code.style=official
|
||||
org.gradle.parallel=true
|
||||
kotlin.js.generate.externals=true
|
||||
kotlin.incremental=true
|
||||
kotlin.incremental.js=true
|
||||
kotlin_version=1.3.61
|
||||
kotlin_coroutines_version=1.3.3
|
||||
|
||||
gradle_bintray_plugin_version=1.8.4
|
||||
|
||||
klockVersion=1.8.6
|
||||
|
||||
kotlin.incremental.multiplatform=true
|
||||
android.useAndroidX=true
|
||||
android.enableJetifier=false
|
||||
|
||||
|
||||
kotlin_version=1.9.22
|
||||
kotlin_coroutines_version=1.8.0
|
||||
kotlin_serialization_version=1.6.2
|
||||
|
||||
dokka_version=1.9.10
|
||||
|
||||
klockVersion=5.3.1
|
||||
|
||||
## Github reease
|
||||
|
||||
github_release_plugin_version=2.5.2
|
||||
|
||||
## Android
|
||||
|
||||
android_gradle_version=8.1.4
|
||||
android_minSdkVersion=21
|
||||
android_compileSdkVersion=34
|
||||
android_buildToolsVersion=34.0.0
|
||||
dexcount_version=4.0.0
|
||||
junit_version=4.12
|
||||
test_ext_junit_version=1.1.3
|
||||
espresso_core=3.4.0
|
||||
|
||||
androidx_work_version=2.9.0
|
||||
|
||||
## Common
|
||||
|
||||
version=2.2.8
|
||||
android_code_version=38
|
||||
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Binary file not shown.
5
gradle/wrapper/gradle-wrapper.properties
vendored
5
gradle/wrapper/gradle-wrapper.properties
vendored
@@ -1,7 +1,6 @@
|
||||
# Tue May 21 17:58:54 HKT 2019
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
|
||||
networkTimeout=10000
|
||||
validateDistributionUrl=true
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip
|
||||
|
||||
307
gradlew
vendored
307
gradlew
vendored
@@ -1,127 +1,78 @@
|
||||
#!/bin/sh
|
||||
|
||||
#
|
||||
# Copyright © 2015-2021 the original authors.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
#
|
||||
#!/usr/bin/env sh
|
||||
|
||||
##############################################################################
|
||||
#
|
||||
# Gradle start up script for POSIX generated by Gradle.
|
||||
#
|
||||
# Important for running:
|
||||
#
|
||||
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
|
||||
# noncompliant, but you have some other compliant shell such as ksh or
|
||||
# bash, then to run this script, type that shell name before the whole
|
||||
# command line, like:
|
||||
#
|
||||
# ksh Gradle
|
||||
#
|
||||
# Busybox and similar reduced shells will NOT work, because this script
|
||||
# requires all of these POSIX shell features:
|
||||
# * functions;
|
||||
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
|
||||
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
|
||||
# * compound commands having a testable exit status, especially «case»;
|
||||
# * various built-in commands including «command», «set», and «ulimit».
|
||||
#
|
||||
# Important for patching:
|
||||
#
|
||||
# (2) This script targets any POSIX shell, so it avoids extensions provided
|
||||
# by Bash, Ksh, etc; in particular arrays are avoided.
|
||||
#
|
||||
# The "traditional" practice of packing multiple parameters into a
|
||||
# space-separated string is a well documented source of bugs and security
|
||||
# problems, so this is (mostly) avoided, by progressively accumulating
|
||||
# options in "$@", and eventually passing that to Java.
|
||||
#
|
||||
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
|
||||
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
|
||||
# see the in-line comments for details.
|
||||
#
|
||||
# There are tweaks for specific operating systems such as AIX, CygWin,
|
||||
# Darwin, MinGW, and NonStop.
|
||||
#
|
||||
# (3) This script is generated from the Groovy template
|
||||
# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
|
||||
# within the Gradle project.
|
||||
#
|
||||
# You can find Gradle at https://github.com/gradle/gradle/.
|
||||
#
|
||||
##
|
||||
## Gradle start up script for UN*X
|
||||
##
|
||||
##############################################################################
|
||||
|
||||
# Attempt to set APP_HOME
|
||||
|
||||
# Resolve links: $0 may be a link
|
||||
app_path=$0
|
||||
|
||||
# Need this for daisy-chained symlinks.
|
||||
while
|
||||
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
|
||||
[ -h "$app_path" ]
|
||||
do
|
||||
ls=$( ls -ld "$app_path" )
|
||||
link=${ls#*' -> '}
|
||||
case $link in #(
|
||||
/*) app_path=$link ;; #(
|
||||
*) app_path=$APP_HOME$link ;;
|
||||
esac
|
||||
PRG="$0"
|
||||
# Need this for relative symlinks.
|
||||
while [ -h "$PRG" ] ; do
|
||||
ls=`ls -ld "$PRG"`
|
||||
link=`expr "$ls" : '.*-> \(.*\)$'`
|
||||
if expr "$link" : '/.*' > /dev/null; then
|
||||
PRG="$link"
|
||||
else
|
||||
PRG=`dirname "$PRG"`"/$link"
|
||||
fi
|
||||
done
|
||||
SAVED="`pwd`"
|
||||
cd "`dirname \"$PRG\"`/" >/dev/null
|
||||
APP_HOME="`pwd -P`"
|
||||
cd "$SAVED" >/dev/null
|
||||
|
||||
# This is normally unused
|
||||
# shellcheck disable=SC2034
|
||||
APP_BASE_NAME=${0##*/}
|
||||
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
|
||||
APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
|
||||
APP_NAME="Gradle"
|
||||
APP_BASE_NAME=`basename "$0"`
|
||||
|
||||
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
DEFAULT_JVM_OPTS=""
|
||||
|
||||
# Use the maximum available, or set MAX_FD != -1 to use that value.
|
||||
MAX_FD=maximum
|
||||
MAX_FD="maximum"
|
||||
|
||||
warn () {
|
||||
echo "$*"
|
||||
} >&2
|
||||
}
|
||||
|
||||
die () {
|
||||
echo
|
||||
echo "$*"
|
||||
echo
|
||||
exit 1
|
||||
} >&2
|
||||
}
|
||||
|
||||
# OS specific support (must be 'true' or 'false').
|
||||
cygwin=false
|
||||
msys=false
|
||||
darwin=false
|
||||
nonstop=false
|
||||
case "$( uname )" in #(
|
||||
CYGWIN* ) cygwin=true ;; #(
|
||||
Darwin* ) darwin=true ;; #(
|
||||
MSYS* | MINGW* ) msys=true ;; #(
|
||||
NONSTOP* ) nonstop=true ;;
|
||||
case "`uname`" in
|
||||
CYGWIN* )
|
||||
cygwin=true
|
||||
;;
|
||||
Darwin* )
|
||||
darwin=true
|
||||
;;
|
||||
MINGW* )
|
||||
msys=true
|
||||
;;
|
||||
NONSTOP* )
|
||||
nonstop=true
|
||||
;;
|
||||
esac
|
||||
|
||||
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
|
||||
# Determine the Java command to use to start the JVM.
|
||||
if [ -n "$JAVA_HOME" ] ; then
|
||||
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
|
||||
# IBM's JDK on AIX uses strange locations for the executables
|
||||
JAVACMD=$JAVA_HOME/jre/sh/java
|
||||
JAVACMD="$JAVA_HOME/jre/sh/java"
|
||||
else
|
||||
JAVACMD=$JAVA_HOME/bin/java
|
||||
JAVACMD="$JAVA_HOME/bin/java"
|
||||
fi
|
||||
if [ ! -x "$JAVACMD" ] ; then
|
||||
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
|
||||
@@ -130,120 +81,92 @@ Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
else
|
||||
JAVACMD=java
|
||||
if ! command -v java >/dev/null 2>&1
|
||||
then
|
||||
die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
JAVACMD="java"
|
||||
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
fi
|
||||
|
||||
# Increase the maximum file descriptors if we can.
|
||||
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
|
||||
case $MAX_FD in #(
|
||||
max*)
|
||||
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
|
||||
# shellcheck disable=SC2039,SC3045
|
||||
MAX_FD=$( ulimit -H -n ) ||
|
||||
warn "Could not query maximum file descriptor limit"
|
||||
esac
|
||||
case $MAX_FD in #(
|
||||
'' | soft) :;; #(
|
||||
*)
|
||||
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
|
||||
# shellcheck disable=SC2039,SC3045
|
||||
ulimit -n "$MAX_FD" ||
|
||||
warn "Could not set maximum file descriptor limit to $MAX_FD"
|
||||
esac
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command, stacking in reverse order:
|
||||
# * args from the command line
|
||||
# * the main class name
|
||||
# * -classpath
|
||||
# * -D...appname settings
|
||||
# * --module-path (only if needed)
|
||||
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
|
||||
|
||||
# For Cygwin or MSYS, switch paths to Windows format before running java
|
||||
if "$cygwin" || "$msys" ; then
|
||||
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
|
||||
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
|
||||
|
||||
JAVACMD=$( cygpath --unix "$JAVACMD" )
|
||||
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
for arg do
|
||||
if
|
||||
case $arg in #(
|
||||
-*) false ;; # don't mess with options #(
|
||||
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
|
||||
[ -e "$t" ] ;; #(
|
||||
*) false ;;
|
||||
esac
|
||||
then
|
||||
arg=$( cygpath --path --ignore --mixed "$arg" )
|
||||
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
|
||||
MAX_FD_LIMIT=`ulimit -H -n`
|
||||
if [ $? -eq 0 ] ; then
|
||||
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
|
||||
MAX_FD="$MAX_FD_LIMIT"
|
||||
fi
|
||||
# Roll the args list around exactly as many times as the number of
|
||||
# args, so each arg winds up back in the position where it started, but
|
||||
# possibly modified.
|
||||
#
|
||||
# NB: a `for` loop captures its iteration list before it begins, so
|
||||
# changing the positional parameters here affects neither the number of
|
||||
# iterations, nor the values presented in `arg`.
|
||||
shift # remove old arg
|
||||
set -- "$@" "$arg" # push replacement arg
|
||||
ulimit -n $MAX_FD
|
||||
if [ $? -ne 0 ] ; then
|
||||
warn "Could not set maximum file descriptor limit: $MAX_FD"
|
||||
fi
|
||||
else
|
||||
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
|
||||
fi
|
||||
fi
|
||||
|
||||
# For Darwin, add options to specify how the application appears in the dock
|
||||
if $darwin; then
|
||||
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
|
||||
fi
|
||||
|
||||
# For Cygwin, switch paths to Windows format before running java
|
||||
if $cygwin ; then
|
||||
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
|
||||
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
|
||||
JAVACMD=`cygpath --unix "$JAVACMD"`
|
||||
|
||||
# We build the pattern for arguments to be converted via cygpath
|
||||
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
|
||||
SEP=""
|
||||
for dir in $ROOTDIRSRAW ; do
|
||||
ROOTDIRS="$ROOTDIRS$SEP$dir"
|
||||
SEP="|"
|
||||
done
|
||||
OURCYGPATTERN="(^($ROOTDIRS))"
|
||||
# Add a user-defined pattern to the cygpath arguments
|
||||
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
|
||||
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
|
||||
fi
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
i=0
|
||||
for arg in "$@" ; do
|
||||
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
|
||||
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
|
||||
|
||||
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
|
||||
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
|
||||
else
|
||||
eval `echo args$i`="\"$arg\""
|
||||
fi
|
||||
i=$((i+1))
|
||||
done
|
||||
case $i in
|
||||
(0) set -- ;;
|
||||
(1) set -- "$args0" ;;
|
||||
(2) set -- "$args0" "$args1" ;;
|
||||
(3) set -- "$args0" "$args1" "$args2" ;;
|
||||
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
|
||||
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
|
||||
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
|
||||
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
|
||||
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
|
||||
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
# Escape application args
|
||||
save () {
|
||||
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
|
||||
echo " "
|
||||
}
|
||||
APP_ARGS=$(save "$@")
|
||||
|
||||
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
|
||||
# Collect all arguments for the java command, following the shell quoting and substitution rules
|
||||
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
|
||||
|
||||
# Collect all arguments for the java command:
|
||||
# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
|
||||
# and any embedded shellness will be escaped.
|
||||
# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
|
||||
# treated as '${Hostname}' itself on the command line.
|
||||
|
||||
set -- \
|
||||
"-Dorg.gradle.appname=$APP_BASE_NAME" \
|
||||
-classpath "$CLASSPATH" \
|
||||
org.gradle.wrapper.GradleWrapperMain \
|
||||
"$@"
|
||||
|
||||
# Stop when "xargs" is not available.
|
||||
if ! command -v xargs >/dev/null 2>&1
|
||||
then
|
||||
die "xargs is not available"
|
||||
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
|
||||
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
|
||||
cd "$(dirname "$0")"
|
||||
fi
|
||||
|
||||
# Use "xargs" to parse quoted args.
|
||||
#
|
||||
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
|
||||
#
|
||||
# In Bash we could simply go:
|
||||
#
|
||||
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
|
||||
# set -- "${ARGS[@]}" "$@"
|
||||
#
|
||||
# but POSIX shell has neither arrays nor command substitution, so instead we
|
||||
# post-process each arg (as a line of input to sed) to backslash-escape any
|
||||
# character that might be a shell metacharacter, then use eval to reverse
|
||||
# that process (while maintaining the separation between arguments), and wrap
|
||||
# the whole thing up as a single "set" statement.
|
||||
#
|
||||
# This will of course break if any of these variables contains a newline or
|
||||
# an unmatched quote.
|
||||
#
|
||||
|
||||
eval "set -- $(
|
||||
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
|
||||
xargs -n1 |
|
||||
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
|
||||
tr '\n' ' '
|
||||
)" '"$@"'
|
||||
|
||||
exec "$JAVACMD" "$@"
|
||||
|
||||
76
gradlew.bat
vendored
76
gradlew.bat
vendored
@@ -1,20 +1,4 @@
|
||||
@rem
|
||||
@rem Copyright 2015 the original author or authors.
|
||||
@rem
|
||||
@rem Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@rem you may not use this file except in compliance with the License.
|
||||
@rem You may obtain a copy of the License at
|
||||
@rem
|
||||
@rem https://www.apache.org/licenses/LICENSE-2.0
|
||||
@rem
|
||||
@rem Unless required by applicable law or agreed to in writing, software
|
||||
@rem distributed under the License is distributed on an "AS IS" BASIS,
|
||||
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
@rem See the License for the specific language governing permissions and
|
||||
@rem limitations under the License.
|
||||
@rem
|
||||
|
||||
@if "%DEBUG%"=="" @echo off
|
||||
@if "%DEBUG%" == "" @echo off
|
||||
@rem ##########################################################################
|
||||
@rem
|
||||
@rem Gradle startup script for Windows
|
||||
@@ -25,29 +9,25 @@
|
||||
if "%OS%"=="Windows_NT" setlocal
|
||||
|
||||
set DIRNAME=%~dp0
|
||||
if "%DIRNAME%"=="" set DIRNAME=.
|
||||
@rem This is normally unused
|
||||
if "%DIRNAME%" == "" set DIRNAME=.
|
||||
set APP_BASE_NAME=%~n0
|
||||
set APP_HOME=%DIRNAME%
|
||||
|
||||
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
|
||||
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
|
||||
|
||||
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
|
||||
set DEFAULT_JVM_OPTS=
|
||||
|
||||
@rem Find java.exe
|
||||
if defined JAVA_HOME goto findJavaFromJavaHome
|
||||
|
||||
set JAVA_EXE=java.exe
|
||||
%JAVA_EXE% -version >NUL 2>&1
|
||||
if %ERRORLEVEL% equ 0 goto execute
|
||||
if "%ERRORLEVEL%" == "0" goto init
|
||||
|
||||
echo. 1>&2
|
||||
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
|
||||
echo. 1>&2
|
||||
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
|
||||
echo location of your Java installation. 1>&2
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
@@ -55,36 +35,48 @@ goto fail
|
||||
set JAVA_HOME=%JAVA_HOME:"=%
|
||||
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
|
||||
|
||||
if exist "%JAVA_EXE%" goto execute
|
||||
if exist "%JAVA_EXE%" goto init
|
||||
|
||||
echo. 1>&2
|
||||
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
|
||||
echo. 1>&2
|
||||
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
|
||||
echo location of your Java installation. 1>&2
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:init
|
||||
@rem Get command-line arguments, handling Windows variants
|
||||
|
||||
if not "%OS%" == "Windows_NT" goto win9xME_args
|
||||
|
||||
:win9xME_args
|
||||
@rem Slurp the command line arguments.
|
||||
set CMD_LINE_ARGS=
|
||||
set _SKIP=2
|
||||
|
||||
:win9xME_args_slurp
|
||||
if "x%~1" == "x" goto execute
|
||||
|
||||
set CMD_LINE_ARGS=%*
|
||||
|
||||
:execute
|
||||
@rem Setup the command line
|
||||
|
||||
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
|
||||
|
||||
|
||||
@rem Execute Gradle
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
|
||||
|
||||
:end
|
||||
@rem End local scope for the variables with windows NT shell
|
||||
if %ERRORLEVEL% equ 0 goto mainEnd
|
||||
if "%ERRORLEVEL%"=="0" goto mainEnd
|
||||
|
||||
:fail
|
||||
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
|
||||
rem the _cmd.exe /c_ return code!
|
||||
set EXIT_CODE=%ERRORLEVEL%
|
||||
if %EXIT_CODE% equ 0 set EXIT_CODE=1
|
||||
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
|
||||
exit /b %EXIT_CODE%
|
||||
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
|
||||
exit /b 1
|
||||
|
||||
:mainEnd
|
||||
if "%OS%"=="Windows_NT" endlocal
|
||||
|
||||
57
maven.publish.gradle
Normal file
57
maven.publish.gradle
Normal file
@@ -0,0 +1,57 @@
|
||||
apply plugin: 'maven-publish'
|
||||
|
||||
task javadocsJar(type: Jar) {
|
||||
classifier = 'javadoc'
|
||||
}
|
||||
|
||||
afterEvaluate {
|
||||
project.publishing.publications.all {
|
||||
// rename artifacts
|
||||
groupId "${project.group}"
|
||||
if (it.name.contains('kotlinMultiplatform')) {
|
||||
artifactId = "${project.name}"
|
||||
} else {
|
||||
artifactId = "${project.name}-$name"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
publishing {
|
||||
publications.all {
|
||||
artifact javadocsJar
|
||||
|
||||
pom.withXml {
|
||||
asNode().children().last() + {
|
||||
resolveStrategy = Closure.DELEGATE_FIRST
|
||||
|
||||
description "It is an analog of crontab util for Kotlin Coroutines"
|
||||
name "Krontab"
|
||||
url "https://git.insanusmokrassar.com/InsanusMokrassar/krontab"
|
||||
|
||||
scm {
|
||||
developerConnection "scm:git:[fetch=]https://git.insanusmokrassar.com/InsanusMokrassar/krontab.git[push=]https://git.insanusmokrassar.com/InsanusMokrassar/krontab.git"
|
||||
url "https://git.insanusmokrassar.com/InsanusMokrassar/krontab.git"
|
||||
}
|
||||
|
||||
developers {
|
||||
|
||||
developer {
|
||||
id "InsanusMokrassar"
|
||||
name "Ovsiannikov Aleksei"
|
||||
email "ovsyannikov.alexey95@gmail.com"
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
licenses {
|
||||
|
||||
license {
|
||||
name "Apache Software License 2.0"
|
||||
url "https://git.insanusmokrassar.com/InsanusMokrassar/krontab/src/master/LICENSE"
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
1
mpp_config.json
Normal file
1
mpp_config.json
Normal file
@@ -0,0 +1 @@
|
||||
{"bintrayConfig":{"repo":"InsanusMokrassar","packageName":"${project.name}","packageVcs":"https://git.insanusmokrassar.com/InsanusMokrassar/krontab"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://git.insanusmokrassar.com/InsanusMokrassar/krontab/src/master/LICENSE"}],"mavenConfig":{"name":"Krontab","description":"It is an analog of crontab util for Kotlin Coroutines","url":"https://git.insanusmokrassar.com/InsanusMokrassar/krontab","vcsUrl":"https://git.insanusmokrassar.com/InsanusMokrassar/krontab.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]}}
|
||||
144
publish.gradle
144
publish.gradle
@@ -1,118 +1,48 @@
|
||||
apply plugin: 'maven-publish'
|
||||
apply plugin: 'com.jfrog.bintray'
|
||||
|
||||
task javadocsJar(type: Jar) {
|
||||
archiveClassifier = 'javadoc'
|
||||
}
|
||||
apply from: "maven.publish.gradle"
|
||||
|
||||
publishing {
|
||||
publications.all {
|
||||
artifact javadocsJar
|
||||
|
||||
pom {
|
||||
description = "It is an analog of crontab util for Kotlin Coroutines"
|
||||
name = "Krontab"
|
||||
url = "https://github.com/InsanusMokrassar/krontab"
|
||||
|
||||
scm {
|
||||
developerConnection = "scm:git:[fetch=]https://github.com/InsanusMokrassar/krontab.git[push=]https://github.com/InsanusMokrassar/krontab.git"
|
||||
url = "https://github.com/InsanusMokrassar/krontab.git"
|
||||
}
|
||||
|
||||
developers {
|
||||
|
||||
developer {
|
||||
id = "InsanusMokrassar"
|
||||
name = "Ovsiannikov Aleksei"
|
||||
email = "ovsyannikov.alexey95@gmail.com"
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
licenses {
|
||||
|
||||
license {
|
||||
name = "Apache Software License 2.0"
|
||||
url = "https://github.com/InsanusMokrassar/krontab/blob/master/LICENSE"
|
||||
}
|
||||
|
||||
bintray {
|
||||
user = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
|
||||
key = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
|
||||
filesSpec {
|
||||
from "${buildDir}/publications/"
|
||||
eachFile {
|
||||
if (it.getName() == "module.json") {
|
||||
File file = it.getFile()
|
||||
String directorySubname = file.parentFile.name
|
||||
if (directorySubname == "kotlinMultiplatform") {
|
||||
it.setPath("${project.name}/${project.version}/${project.name}-${project.version}.module")
|
||||
} else {
|
||||
it.setPath("${project.name}-${directorySubname}/${project.version}/${project.name}-${directorySubname}-${project.version}.module")
|
||||
}
|
||||
} else {
|
||||
it.exclude()
|
||||
}
|
||||
}
|
||||
repositories {
|
||||
if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
|
||||
maven {
|
||||
name = "GithubPackages"
|
||||
url = uri("https://maven.pkg.github.com/InsanusMokrassar/krontab")
|
||||
|
||||
credentials {
|
||||
username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
|
||||
password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
|
||||
maven {
|
||||
name = "InmoNexus"
|
||||
url = uri("https://nexus.inmo.dev/repository/maven-releases/")
|
||||
|
||||
credentials {
|
||||
username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
|
||||
password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
|
||||
maven {
|
||||
name = "sonatype"
|
||||
url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
|
||||
|
||||
credentials {
|
||||
username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
|
||||
password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
|
||||
}
|
||||
|
||||
}
|
||||
into "${project.group}".replace(".", "/")
|
||||
}
|
||||
pkg {
|
||||
repo = "InsanusMokrassar"
|
||||
name = "${project.name}"
|
||||
vcsUrl = "https://git.insanusmokrassar.com/InsanusMokrassar/krontab"
|
||||
licenses = ["Apache-2.0"]
|
||||
version {
|
||||
name = "${project.version}"
|
||||
released = new Date()
|
||||
vcsTag = "${project.version}"
|
||||
gpg {
|
||||
sign = true
|
||||
passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (project.hasProperty("signing.gnupg.keyName")) {
|
||||
apply plugin: 'signing'
|
||||
|
||||
signing {
|
||||
useGpgCmd()
|
||||
|
||||
sign publishing.publications
|
||||
}
|
||||
|
||||
task signAll {
|
||||
tasks.withType(Sign).forEach {
|
||||
dependsOn(it)
|
||||
}
|
||||
}
|
||||
|
||||
// Workaround to make android sign operations depend on signing tasks
|
||||
project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
|
||||
def signingTasks = project.getTasks().withType(Sign.class)
|
||||
mustRunAfter(signingTasks)
|
||||
}
|
||||
// Workaround to make test tasks use sign
|
||||
project.getTasks().withType(Sign.class).configureEach { signTask ->
|
||||
def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
|
||||
def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
|
||||
// These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
|
||||
|
||||
// Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
|
||||
def debugTestTask = tasks.findByName("linkDebugTest$pubName")
|
||||
if (debugTestTask != null) {
|
||||
signTask.mustRunAfter(debugTestTask)
|
||||
}
|
||||
// Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
|
||||
def testTask = tasks.findByName("compileTestKotlin$pubName")
|
||||
if (testTask != null) {
|
||||
signTask.mustRunAfter(testTask)
|
||||
}
|
||||
bintrayUpload.doFirst {
|
||||
publications = publishing.publications.collect {
|
||||
it.name
|
||||
}
|
||||
}
|
||||
|
||||
bintrayUpload.dependsOn publishToMavenLocal
|
||||
@@ -1 +0,0 @@
|
||||
{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/krontab/blob/master/LICENSE"}],"mavenConfig":{"name":"Krontab","description":"It is an analog of crontab util for Kotlin Coroutines","url":"https://github.com/InsanusMokrassar/krontab","vcsUrl":"https://github.com/InsanusMokrassar/krontab.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/krontab"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"$schema": "https://docs.renovatebot.com/renovate-schema.json",
|
||||
"extends": [
|
||||
"config:base"
|
||||
]
|
||||
}
|
||||
@@ -1,148 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import android.content.Context
|
||||
import androidx.work.*
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.millisecondsLong
|
||||
import java.util.concurrent.TimeUnit
|
||||
|
||||
/**
|
||||
* This method will enqueue [OneTimeWorkRequest] with [workName] and [existingWorkPolicy]. Use [setUpRequest] callback
|
||||
* in case you need some additional actions to do before request will be enqueued
|
||||
*/
|
||||
suspend fun <T : KronSchedulerWork> Context.enqueueKronSchedulerWork(
|
||||
workName: String,
|
||||
delayMillis: Long,
|
||||
workClass: Class<T>,
|
||||
existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.REPLACE,
|
||||
setUpRequest: suspend OneTimeWorkRequest.Builder.() -> Unit = {}
|
||||
) = WorkManager.getInstance(applicationContext).enqueueUniqueWork(
|
||||
workName,
|
||||
existingWorkPolicy,
|
||||
OneTimeWorkRequest.Builder(workClass).apply {
|
||||
setInitialDelay(delayMillis, TimeUnit.MILLISECONDS)
|
||||
setUpRequest()
|
||||
}.build()
|
||||
)
|
||||
/**
|
||||
* This method is shortcut for [enqueueKronSchedulerWork] with reified [T] parameter
|
||||
*/
|
||||
suspend inline fun <reified T : KronSchedulerWork> Context.enqueueKronSchedulerWork(
|
||||
workName: String,
|
||||
delayMillis: Long,
|
||||
existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.REPLACE,
|
||||
noinline setUpRequest: suspend OneTimeWorkRequest.Builder.() -> Unit = {}
|
||||
) = enqueueKronSchedulerWork(workName, delayMillis, T::class.java, existingWorkPolicy, setUpRequest)
|
||||
|
||||
/**
|
||||
* This method is shortcut for [enqueueKronSchedulerWork] with [initialScheduler]. It will try to calculate delay by
|
||||
* itself. In case if [KronScheduler.next] of [initialScheduler] will return null, work WILL NOT be enqueued
|
||||
*
|
||||
* @return null in case if [KronScheduler.next] of [initialScheduler] has returned null and work has not been enqueued
|
||||
*/
|
||||
suspend fun <T : KronSchedulerWork> Context.enqueueKronSchedulerWork(
|
||||
workName: String,
|
||||
initialScheduler: KronScheduler,
|
||||
workClass: Class<T>,
|
||||
existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.REPLACE,
|
||||
setUpRequest: suspend OneTimeWorkRequest.Builder.() -> Unit = {}
|
||||
): Operation? {
|
||||
val now = DateTime.now()
|
||||
val nextTriggerTime = initialScheduler.next(now)
|
||||
val delayMillis = nextTriggerTime ?.minus(now) ?.millisecondsLong ?: return null
|
||||
|
||||
return enqueueKronSchedulerWork(workName, delayMillis, workClass, existingWorkPolicy, setUpRequest)
|
||||
}
|
||||
/**
|
||||
* This method is shortcut for [enqueueKronSchedulerWork] with reified [T]
|
||||
*/
|
||||
suspend inline fun <reified T : KronSchedulerWork> Context.enqueueKronSchedulerWork(
|
||||
workName: String,
|
||||
initialScheduler: KronScheduler,
|
||||
existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.REPLACE,
|
||||
noinline setUpRequest: suspend OneTimeWorkRequest.Builder.() -> Unit = {}
|
||||
) = enqueueKronSchedulerWork(workName, initialScheduler, T::class.java, existingWorkPolicy, setUpRequest)
|
||||
|
||||
/**
|
||||
* Use this class as a super class in case you wish to implement krontab-based enqueuing of works
|
||||
*
|
||||
* @see enqueueKronSchedulerWork
|
||||
* @see KrontabTemplateSchedulerWork
|
||||
*/
|
||||
abstract class KronSchedulerWork(
|
||||
context: Context,
|
||||
workerParams: WorkerParameters
|
||||
) : CoroutineWorker(
|
||||
context,
|
||||
workerParams
|
||||
) {
|
||||
/**
|
||||
* This variable will be used to reorder new work after that one is happen
|
||||
*
|
||||
* @see prolongOnException
|
||||
* @see prolongOnFailure
|
||||
* @see prolongOnSuccess
|
||||
*/
|
||||
protected abstract val workName: String
|
||||
|
||||
/**
|
||||
* Set this to false in case when this work must not be enqueued after successful complete
|
||||
*/
|
||||
protected open val prolongOnSuccess: Boolean = true
|
||||
/**
|
||||
* Set this to false in case when this work must not be enqueued after failure complete
|
||||
*/
|
||||
protected open val prolongOnFailure
|
||||
get() = prolongOnSuccess
|
||||
/**
|
||||
* Set this to false in case when this work must not be enqueued after exception happen
|
||||
*/
|
||||
protected open val prolongOnException = false
|
||||
|
||||
/**
|
||||
* [KronScheduler] of this method will be used to [prolong] this worker
|
||||
*/
|
||||
protected abstract suspend fun kronScheduler(): KronScheduler?
|
||||
|
||||
/**
|
||||
* This method is replacement of [doWork]. It is required to wrap work with [prolong]ing and handling of complete
|
||||
* state
|
||||
*/
|
||||
protected abstract suspend fun onWork(): Result
|
||||
|
||||
/**
|
||||
* Override this method in case you have some additional settings for future [OneTimeWorkRequest]
|
||||
*/
|
||||
protected open suspend fun OneTimeWorkRequest.Builder.setUpRequest() {}
|
||||
|
||||
/**
|
||||
* This method will [enqueueKronSchedulerWork] using [workName], [kronScheduler] and default
|
||||
* [ExistingWorkPolicy.REPLACE]. You can call this method in case you want to enqueue work by yourself, but you must
|
||||
* be sure that you set up to false [prolongOnSuccess], [prolongOnFailure] and [prolongOnException]
|
||||
*/
|
||||
protected suspend fun prolong() {
|
||||
applicationContext.enqueueKronSchedulerWork(
|
||||
workName,
|
||||
kronScheduler() ?: return,
|
||||
this::class.java
|
||||
) {
|
||||
setUpRequest()
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun doWork(): Result {
|
||||
val result = try {
|
||||
onWork()
|
||||
} catch (e: Throwable) {
|
||||
if (prolongOnException) {
|
||||
prolong()
|
||||
}
|
||||
throw e
|
||||
}
|
||||
when (result) {
|
||||
is Result.Failure -> if (prolongOnFailure) prolong()
|
||||
is Result.Success -> if (prolongOnSuccess) prolong()
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import android.content.Context
|
||||
import androidx.work.*
|
||||
|
||||
const val krontabTemplateWorkField = "krontabTemplate"
|
||||
|
||||
/**
|
||||
* Will [enqueueKronSchedulerWork] with [KronScheduler] from [krontabTemplate] and call [setUpRequest] on setting up
|
||||
* [OneTimeWorkRequest.Builder] with [Data] which will be used to [OneTimeWorkRequest.Builder.setInputData] after
|
||||
* [setUpRequest] completed
|
||||
*/
|
||||
suspend inline fun <reified T : KrontabTemplateSchedulerWork> Context.enqueueKrontabTemplateSchedulerWork(
|
||||
workName: String,
|
||||
krontabTemplate: KrontabTemplate,
|
||||
existingWorkPolicy: ExistingWorkPolicy = ExistingWorkPolicy.REPLACE,
|
||||
noinline setUpRequest: suspend OneTimeWorkRequest.Builder.(
|
||||
data: Data
|
||||
) -> Unit = {}
|
||||
) = enqueueKronSchedulerWork(workName, krontabTemplate.toKronScheduler(), T::class.java, existingWorkPolicy) {
|
||||
val data = workDataOf(
|
||||
krontabTemplateWorkField to krontabTemplate
|
||||
)
|
||||
setUpRequest(data)
|
||||
setInputData(data)
|
||||
}
|
||||
|
||||
/**
|
||||
* Extend this class in case you wish to base on [KrontabTemplate]. It will automatically handle request of
|
||||
* [kronScheduler] and put it in [setUpRequest]
|
||||
*/
|
||||
abstract class KrontabTemplateSchedulerWork(
|
||||
context: Context,
|
||||
workerParams: WorkerParameters
|
||||
) : KronSchedulerWork(context, workerParams) {
|
||||
/**
|
||||
* Will try to get [KrontabTemplate] from [getInputData] by key [krontabTemplateWorkField]
|
||||
*
|
||||
* @see setUpRequest
|
||||
*/
|
||||
protected val krontabTemplate: KrontabTemplate?
|
||||
get() = inputData.getString(krontabTemplateWorkField)
|
||||
|
||||
/**
|
||||
* Override this methods instead of old [setUpRequest] in case you wish to set up some work request parameters
|
||||
*
|
||||
* @param data This parameter will be used to put data inside of [OneTimeWorkRequest.Builder] after this method
|
||||
* will be completed
|
||||
*/
|
||||
protected open suspend fun OneTimeWorkRequest.Builder.setUpRequest(data: Data) {}
|
||||
|
||||
/**
|
||||
* Will automatically put [krontabTemplate] into work data, call [setUpRequest] with future [Data] object and then
|
||||
* call [OneTimeWorkRequest.Builder.setInputData] with that [Data] object
|
||||
*/
|
||||
override suspend fun OneTimeWorkRequest.Builder.setUpRequest() {
|
||||
val data = workDataOf(
|
||||
krontabTemplateWorkField to krontabTemplate,
|
||||
)
|
||||
setUpRequest(data)
|
||||
setInputData(data)
|
||||
}
|
||||
|
||||
/**
|
||||
* Will return [KronScheduler] in case if [krontabTemplate] was not null
|
||||
*/
|
||||
override suspend fun kronScheduler(): KronScheduler? = krontabTemplate ?.toKronScheduler()
|
||||
}
|
||||
@@ -1,175 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.DateTimeTz
|
||||
import korlibs.time.millisecondsLong
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlin.coroutines.coroutineContext
|
||||
|
||||
|
||||
/**
|
||||
* Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
|
||||
*
|
||||
* WARNING!!! If you want to launch it in parallel, you must do this explicitly.
|
||||
*
|
||||
* WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediately
|
||||
*/
|
||||
suspend inline fun <T> KronScheduler.doOnce(block: (DateTime) -> T): T {
|
||||
val time = nextOrNow().also {
|
||||
delay((it - DateTime.now()).millisecondsLong)
|
||||
}
|
||||
return block(time)
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
|
||||
*
|
||||
* WARNING!!! If you want to launch it in parallel, you must do this explicitly.
|
||||
*
|
||||
* WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediately
|
||||
*/
|
||||
@Deprecated("Replaceable", ReplaceWith("doOnce", "dev.inmo.krontab.doOnce"))
|
||||
suspend inline fun <T> KronScheduler.doOnceLocal(block: (DateTime) -> T): T = doOnce(block)
|
||||
|
||||
/**
|
||||
* Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
|
||||
*
|
||||
* WARNING!!! If you want to launch it in parallel, you must do this explicitly.
|
||||
*
|
||||
* WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediatelly
|
||||
*/
|
||||
suspend inline fun <T> KronScheduler.doOnceTz(noinline block: suspend (DateTimeTz) -> T): T {
|
||||
val time = when (this) {
|
||||
is KronSchedulerTz -> nextOrNowWithOffset()
|
||||
else -> nextOrNow().local
|
||||
}
|
||||
delay((time - DateTimeTz.nowLocal()).millisecondsLong)
|
||||
return block(time)
|
||||
}
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doOnce] on it
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun <T> doOnce(
|
||||
scheduleConfig: String,
|
||||
block: (DateTime) -> T
|
||||
) = buildSchedule(scheduleConfig).doOnce(block)
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doOnce] on it
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun <T> doOnceTz(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend (DateTimeTz) -> T
|
||||
) = buildSchedule(scheduleConfig).doOnceTz(block)
|
||||
|
||||
|
||||
/**
|
||||
* Will execute [block] while it will return true as a result of its calculation
|
||||
*/
|
||||
suspend inline fun KronScheduler.doWhile(block: (DateTime) -> Boolean) {
|
||||
do {
|
||||
delay(1L)
|
||||
} while (doOnce(block))
|
||||
}
|
||||
/**
|
||||
* Will execute [block] while it will return true as a result of its calculation
|
||||
*/
|
||||
@Deprecated("Replaceable", ReplaceWith("doWhile", "dev.inmo.krontab.doWhile"))
|
||||
suspend inline fun KronScheduler.doWhileLocal(block: (DateTime) -> Boolean) = doWhile(block)
|
||||
|
||||
/**
|
||||
* Will execute [block] while it will return true as a result of its calculation
|
||||
*/
|
||||
suspend inline fun KronScheduler.doWhileTz(noinline block: suspend (DateTimeTz) -> Boolean) {
|
||||
do {
|
||||
delay(1L)
|
||||
} while (doOnceTz(block))
|
||||
}
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun doWhile(
|
||||
scheduleConfig: String,
|
||||
block: (DateTime) -> Boolean
|
||||
) = buildSchedule(scheduleConfig).doWhile(block)
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
@Deprecated("Replaceable", ReplaceWith("doWhile", "dev.inmo.krontab.doWhile"))
|
||||
suspend inline fun doWhileLocal(
|
||||
scheduleConfig: String,
|
||||
block: (DateTime) -> Boolean
|
||||
) = doWhile(scheduleConfig, block)
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun doWhileTz(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend (DateTimeTz) -> Boolean
|
||||
) = buildSchedule(scheduleConfig).doWhileTz(block)
|
||||
|
||||
|
||||
/**
|
||||
* Will execute [block] without any checking of result
|
||||
*/
|
||||
suspend inline fun KronScheduler.doInfinity(block: (DateTime) -> Unit) = doWhile {
|
||||
block(it)
|
||||
coroutineContext.isActive
|
||||
}
|
||||
/**
|
||||
* Will execute [block] without any checking of result
|
||||
*/
|
||||
@Deprecated("Replaceable", ReplaceWith("doInfinity", "dev.inmo.krontab.doInfinity"))
|
||||
suspend inline fun KronScheduler.doInfinityLocal(block: (DateTime) -> Unit) = doInfinity(block)
|
||||
|
||||
/**
|
||||
* Will execute [block] without any checking of result
|
||||
*/
|
||||
suspend inline fun KronScheduler.doInfinityTz(noinline block: suspend (DateTimeTz) -> Unit) = doWhileTz {
|
||||
block(it)
|
||||
coroutineContext.isActive
|
||||
}
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun doInfinity(
|
||||
scheduleConfig: String,
|
||||
block: (DateTime) -> Unit
|
||||
) = buildSchedule(scheduleConfig).doInfinity(block)
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
@Deprecated("Replaceable", ReplaceWith("doInfinity", "dev.inmo.krontab.doInfinity"))
|
||||
suspend inline fun doInfinityLocal(
|
||||
scheduleConfig: String,
|
||||
block: (DateTime) -> Unit
|
||||
) = doInfinity(scheduleConfig, block)
|
||||
|
||||
/**
|
||||
* Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
|
||||
*
|
||||
* @see buildSchedule
|
||||
*/
|
||||
suspend inline fun doInfinityTz(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend (DateTimeTz) -> Unit
|
||||
) = buildSchedule(scheduleConfig).doInfinityTz(block)
|
||||
@@ -1,28 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTime
|
||||
|
||||
/**
|
||||
* This interface was created for abstraction of [next] operation. Currently, there is only
|
||||
* [dev.inmo.krontab.internal.CronDateTimeScheduler] realisation of this interface inside of this library,
|
||||
* but you it is possible to create your own realisation of this interface for scheduling, for example, depending of
|
||||
* users activity or something like this
|
||||
*
|
||||
* @see dev.inmo.krontab.internal.CronDateTimeScheduler
|
||||
*/
|
||||
interface KronScheduler {
|
||||
|
||||
/**
|
||||
* @return Next [DateTime] when some action must be triggered according to settings of this instance
|
||||
*
|
||||
* @see dev.inmo.krontab.internal.CronDateTimeScheduler.next
|
||||
*/
|
||||
suspend fun next(relatively: DateTime = DateTime.now()): DateTime?
|
||||
|
||||
companion object
|
||||
}
|
||||
|
||||
suspend fun KronScheduler.nextOrRelative(relatively: DateTime = DateTime.now()): DateTime = next(relatively) ?: getAnyNext(relatively)
|
||||
suspend fun KronScheduler.nextOrNow(): DateTime = DateTime.now().let {
|
||||
next(it) ?: getAnyNext(it)
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.DateTimeTz
|
||||
|
||||
/**
|
||||
* This interface extending [KronScheduler] to use [DateTimeTz] with taking into account offset of incoming time for
|
||||
* [next] operation.
|
||||
*
|
||||
* @see dev.inmo.krontab.internal.CronDateTimeScheduler
|
||||
* @see dev.inmo.krontab.KronScheduler
|
||||
*/
|
||||
interface KronSchedulerTz : KronScheduler {
|
||||
suspend fun next(relatively: DateTimeTz): DateTimeTz?
|
||||
|
||||
override suspend fun next(relatively: DateTime): DateTime? = next(relatively.local) ?.local
|
||||
}
|
||||
|
||||
suspend fun KronSchedulerTz.nextOrRelative(relatively: DateTimeTz): DateTimeTz = next(relatively) ?: getAnyNext(
|
||||
relatively.local
|
||||
).toOffsetUnadjusted(relatively.offset)
|
||||
suspend fun KronSchedulerTz.nextOrNowWithOffset(): DateTimeTz = DateTimeTz.nowLocal().let {
|
||||
next(it) ?: getAnyNext(
|
||||
it.local
|
||||
).toOffsetUnadjusted(it.offset)
|
||||
}
|
||||
|
||||
suspend fun KronScheduler.next(relatively: DateTimeTz) = if (this is KronSchedulerTz) {
|
||||
this.next(relatively)
|
||||
} else {
|
||||
this.next(relatively.local) ?.toOffsetUnadjusted(relatively.offset)
|
||||
}
|
||||
|
||||
suspend fun KronScheduler.nextTimeZoned() = next(DateTime.now().local)
|
||||
@@ -1,46 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import dev.inmo.krontab.collection.CollectionKronScheduler
|
||||
import dev.inmo.krontab.collection.includeAll
|
||||
import dev.inmo.krontab.internal.*
|
||||
|
||||
/**
|
||||
* Create new one [CollectionKronScheduler] to include all [KronScheduler]s of [this] [Iterator]
|
||||
*
|
||||
* @see CollectionKronScheduler
|
||||
* @see CollectionKronScheduler.include
|
||||
*/
|
||||
fun Iterator<KronScheduler>.merge(): CollectionKronScheduler {
|
||||
val cronDateTimes = mutableListOf<CronDateTime>()
|
||||
val timezonedCronDateTimes = mutableListOf<CronDateTimeSchedulerTz>()
|
||||
val collectionScheduler = CollectionKronScheduler()
|
||||
forEach {
|
||||
when (it) {
|
||||
is CronDateTimeScheduler -> cronDateTimes.add(it.cronDateTime)
|
||||
is CronDateTimeSchedulerTz -> timezonedCronDateTimes.add(it)
|
||||
else -> collectionScheduler.include(it)
|
||||
}
|
||||
}
|
||||
if (cronDateTimes.isNotEmpty()) {
|
||||
collectionScheduler.include(CronDateTimeScheduler(cronDateTimes.merge()))
|
||||
}
|
||||
if (timezonedCronDateTimes.isNotEmpty()) {
|
||||
collectionScheduler.includeAll(mergeCronDateTimeSchedulers(timezonedCronDateTimes))
|
||||
}
|
||||
return collectionScheduler
|
||||
}
|
||||
|
||||
/**
|
||||
* Create new one [CollectionKronScheduler] to include all [KronScheduler]s of [this] [Iterator]
|
||||
*
|
||||
* @see CollectionKronScheduler
|
||||
* @see CollectionKronScheduler.include
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Iterable<KronScheduler>.merge(): CollectionKronScheduler = iterator().merge()
|
||||
|
||||
/**
|
||||
* @return Vararg shortcut for [merge]
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun merge(vararg kronDateTimeSchedulers: KronScheduler): CollectionKronScheduler = kronDateTimeSchedulers.iterator().merge()
|
||||
@@ -1,165 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import dev.inmo.krontab.internal.CronDateTimeScheduler
|
||||
import dev.inmo.krontab.internal.CronDateTimeSchedulerTz
|
||||
import dev.inmo.krontab.internal.createKronScheduler
|
||||
import dev.inmo.krontab.internal.createKronSchedulerWithOffset
|
||||
import dev.inmo.krontab.internal.millisecondsArrayDefault
|
||||
import dev.inmo.krontab.internal.parseDaysOfMonth
|
||||
import dev.inmo.krontab.internal.parseHours
|
||||
import dev.inmo.krontab.internal.parseMilliseconds
|
||||
import dev.inmo.krontab.internal.parseMinutes
|
||||
import dev.inmo.krontab.internal.parseMonths
|
||||
import dev.inmo.krontab.internal.parseOffset
|
||||
import dev.inmo.krontab.internal.parseSeconds
|
||||
import dev.inmo.krontab.internal.parseWeekDay
|
||||
import dev.inmo.krontab.internal.parseYears
|
||||
import dev.inmo.krontab.utils.Minutes
|
||||
import korlibs.time.TimezoneOffset
|
||||
import korlibs.time.minutes
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlin.jvm.JvmInline
|
||||
|
||||
/**
|
||||
* This value class contains [KrontabTemplate]
|
||||
*
|
||||
* * **seconds**
|
||||
* * **minutes**
|
||||
* * **hours**
|
||||
* * **dayOfMonth**
|
||||
* * **month**
|
||||
* * **year** (optional)
|
||||
* * **offset** (optional) (can be placed anywhere after month) (must be marked with `o` at the end, for example: 60o == +01:00)
|
||||
* * **dayOfWeek** (optional) (can be placed anywhere after month)
|
||||
* * **milliseconds** (optional) (can be placed anywhere after month) (must be marked with `ms` at the end, for example: 500ms; 100-200ms)
|
||||
*
|
||||
* And each one (except of offsets) have next format:
|
||||
*
|
||||
* `{number}[,{number},...]` or `*`
|
||||
*
|
||||
* and {number} here is one of
|
||||
*
|
||||
* * {int}-{int}
|
||||
* * {int}/{int}
|
||||
* * */{int}
|
||||
* * {int}
|
||||
* * F
|
||||
* * L
|
||||
*
|
||||
* Week days must be marked with `w` at the end, and starts with 0 which means Sunday. For example, 0w == Sunday. With
|
||||
* weeks you can use syntax like with any number like seconds, for example: 0-2w means Sunday-Tuesday
|
||||
*
|
||||
* Additional info about ranges can be found in follow accordance:
|
||||
*
|
||||
* * Seconds ranges can be found in [secondsRange]
|
||||
* * Minutes ranges can be found in [minutesRange]
|
||||
* * Hours ranges can be found in [hoursRange]
|
||||
* * Days of month ranges can be found in [dayOfMonthRange]
|
||||
* * Months ranges can be found in [monthRange]
|
||||
* * Years ranges can be found in [yearRange] (in fact - any [Int])
|
||||
* * WeekDay (timezone) ranges can be found in [dayOfWeekRange]
|
||||
* * Milliseconds ranges can be found in [millisecondsRange]
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* * "0/5 * * * *" for every five seconds triggering
|
||||
* * "0/5,L * * * *" for every five seconds triggering and on 59 second
|
||||
* * "0/15 30 * * *" for every 15th seconds in a half of each hour
|
||||
* * "0/15 30 * * * 500ms" for every 15th seconds in a half of each hour when milliseconds equal to 500
|
||||
* * "1 2 3 F,4,L 5" for triggering in near first second of second minute of third hour of first, fifth and last days of may
|
||||
* * "1 2 3 F,4,L 5 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may in case if it will be in Sunday-Tuesday week days with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year
|
||||
* * "1 2 3 F,4,L 5 2021 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021 60o 0-2w 500ms" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00 when milliseconds will be equal to 500
|
||||
*
|
||||
* @see dev.inmo.krontab.internal.createKronScheduler
|
||||
*/
|
||||
@Serializable
|
||||
@JvmInline
|
||||
value class KrontabConfig(
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
val template: KrontabTemplate
|
||||
) {
|
||||
/**
|
||||
* Creates __new__ [KronScheduler] based on a [template]
|
||||
*
|
||||
* @return In case when offset parameter is absent in [template] will be used [createSimpleScheduler] method and
|
||||
* returned [CronDateTimeScheduler]. In case when offset parameter there is in [template] [KrontabTemplate] will be used
|
||||
* [createKronSchedulerWithOffset] and returned [CronDateTimeSchedulerTz]
|
||||
*/
|
||||
fun scheduler(): KronScheduler {
|
||||
var offsetParsed: Int? = null
|
||||
var dayOfWeekParsed: Array<Byte>? = null
|
||||
var yearParsed: Array<Int>? = null
|
||||
var millisecondsParsed: Array<Short>? = null
|
||||
val (secondsSource, minutesSource, hoursSource, dayOfMonthSource, monthSource) = template.split(" ").also {
|
||||
listOfNotNull(
|
||||
it.getOrNull(5),
|
||||
it.getOrNull(6),
|
||||
it.getOrNull(7),
|
||||
it.getOrNull(8)
|
||||
).forEach {
|
||||
val offsetFromString = parseOffset(it)
|
||||
val dayOfWeekFromString = parseWeekDay(it)
|
||||
val millisecondsFromString = parseMilliseconds(it)
|
||||
offsetParsed = offsetParsed ?: offsetFromString
|
||||
dayOfWeekParsed = dayOfWeekParsed ?: dayOfWeekFromString
|
||||
millisecondsParsed = millisecondsParsed ?: millisecondsFromString
|
||||
when {
|
||||
dayOfWeekFromString != null || offsetFromString != null || millisecondsFromString != null -> return@forEach
|
||||
yearParsed == null -> {
|
||||
yearParsed = parseYears(it)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val secondsParsed = parseSeconds(secondsSource)
|
||||
val minutesParsed = parseMinutes(minutesSource)
|
||||
val hoursParsed = parseHours(hoursSource)
|
||||
val dayOfMonthParsed = parseDaysOfMonth(dayOfMonthSource)
|
||||
val monthParsed = parseMonths(monthSource)
|
||||
|
||||
return offsetParsed ?.let { offset ->
|
||||
createKronSchedulerWithOffset(
|
||||
secondsParsed,
|
||||
minutesParsed,
|
||||
hoursParsed,
|
||||
dayOfMonthParsed,
|
||||
monthParsed,
|
||||
yearParsed,
|
||||
dayOfWeekParsed,
|
||||
TimezoneOffset(offset.minutes),
|
||||
millisecondsParsed ?: millisecondsArrayDefault
|
||||
)
|
||||
} ?: createKronScheduler(
|
||||
secondsParsed,
|
||||
minutesParsed,
|
||||
hoursParsed,
|
||||
dayOfMonthParsed,
|
||||
monthParsed,
|
||||
yearParsed,
|
||||
dayOfWeekParsed,
|
||||
millisecondsParsed ?: millisecondsArrayDefault
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates base [KronScheduler] using [scheduler] function. In case when returned [KronScheduler] is [KronSchedulerTz],
|
||||
* it will be returned as is. Otherwise, will be created new [CronDateTimeSchedulerTz] with [defaultOffset] as
|
||||
* offset
|
||||
*/
|
||||
fun scheduler(defaultOffset: Minutes): KronSchedulerTz {
|
||||
val scheduler = scheduler()
|
||||
return if (scheduler is KronSchedulerTz) {
|
||||
scheduler
|
||||
} else {
|
||||
CronDateTimeSchedulerTz(
|
||||
(scheduler as CronDateTimeScheduler).cronDateTime,
|
||||
TimezoneOffset(defaultOffset.minutes)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
/**
|
||||
* This class contains [template] and can be simply serialized/deserialized. In fact that class will work as
|
||||
* [dev.inmo.krontab.internal.CronDateTimeScheduler] due to the fact that [toKronScheduler] will return it under the
|
||||
* hood
|
||||
*/
|
||||
@Deprecated(
|
||||
"It is useless wrapper for KrontabTemplate. Use KrontabConfig instead",
|
||||
ReplaceWith("KrontabConfig(template)", "dev.inmo.krontab.KrontabConfig")
|
||||
)
|
||||
data class KrontabTemplateWrapper(
|
||||
val template: KrontabTemplate
|
||||
) : KronScheduler by template.toKronScheduler()
|
||||
|
||||
/**
|
||||
* Will create [KrontabTemplateWrapper] from [this] [KrontabTemplate]
|
||||
*
|
||||
* @see [toKronScheduler]
|
||||
* @see [KrontabTemplateWrapper]
|
||||
*/
|
||||
@Deprecated(
|
||||
"Will be removed in near major update with KrontabTemplateWrapper",
|
||||
ReplaceWith("this.krontabConfig", "dev.inmo.krontab.krontabConfig")
|
||||
)
|
||||
fun KrontabTemplate.wrapAsKronScheduler() = KrontabTemplateWrapper(this)
|
||||
@@ -1,13 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTime
|
||||
|
||||
class LambdaKronScheduler(
|
||||
private val onNext: suspend (DateTime) -> DateTime?
|
||||
) : KronScheduler {
|
||||
override suspend fun next(relatively: DateTime): DateTime? = onNext(relatively)
|
||||
}
|
||||
|
||||
fun KronScheduler(
|
||||
onNext: suspend (DateTime) -> DateTime?
|
||||
) = LambdaKronScheduler(onNext)
|
||||
@@ -1,13 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTimeTz
|
||||
|
||||
class LambdaKronSchedulerTz(
|
||||
private val onNext: suspend (DateTimeTz) -> DateTimeTz?
|
||||
) : KronSchedulerTz {
|
||||
override suspend fun next(relatively: DateTimeTz): DateTimeTz? = onNext(relatively)
|
||||
}
|
||||
|
||||
fun KronSchedulerTz(
|
||||
onNext: suspend (DateTimeTz) -> DateTimeTz?
|
||||
) = LambdaKronSchedulerTz(onNext)
|
||||
@@ -1,108 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import dev.inmo.krontab.builder.buildSchedule
|
||||
import dev.inmo.krontab.internal.*
|
||||
|
||||
internal val anyCronDateTime by lazy {
|
||||
CronDateTime()
|
||||
}
|
||||
internal fun getAnyNext(relatively: DateTime) = anyCronDateTime.toNearDateTime(relatively)!!
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now]
|
||||
*/
|
||||
val AnyTimeScheduler: KronScheduler by lazy {
|
||||
CronDateTimeScheduler(anyCronDateTime)
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one millisecond
|
||||
*/
|
||||
val EveryMillisecondScheduler: KronScheduler by lazy {
|
||||
buildSchedule { milliseconds { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one second
|
||||
*/
|
||||
val EverySecondScheduler: KronScheduler by lazy {
|
||||
buildSchedule { seconds { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one minute
|
||||
*/
|
||||
val EveryMinuteScheduler: KronScheduler by lazy {
|
||||
buildSchedule { minutes { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one hour
|
||||
*/
|
||||
val EveryHourScheduler: KronScheduler by lazy {
|
||||
buildSchedule { hours { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one day
|
||||
*/
|
||||
val EveryDayOfMonthScheduler: KronScheduler by lazy {
|
||||
buildSchedule { dayOfMonth { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one month
|
||||
*/
|
||||
val EveryMonthScheduler: KronScheduler by lazy {
|
||||
buildSchedule { months { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one year
|
||||
*/
|
||||
val EveryYearScheduler: KronScheduler by lazy {
|
||||
buildSchedule { years { 0 every 1 } }
|
||||
}
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryMillisecondScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.everyMillisecond
|
||||
get() = EveryMillisecondScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EverySecondScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.everySecond
|
||||
get() = EverySecondScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryMinuteScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.everyMinute
|
||||
get() = EveryMinuteScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryHourScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.hourly
|
||||
get() = EveryHourScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryDayOfMonthScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.daily
|
||||
get() = EveryDayOfMonthScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryMonthScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.monthly
|
||||
get() = EveryMonthScheduler
|
||||
|
||||
/**
|
||||
* Shortcut for [EveryYearScheduler]
|
||||
*/
|
||||
inline val KronScheduler.Companion.annually
|
||||
get() = EveryYearScheduler
|
||||
@@ -1,109 +0,0 @@
|
||||
package dev.inmo.krontab
|
||||
|
||||
import dev.inmo.krontab.internal.*
|
||||
import dev.inmo.krontab.utils.Minutes
|
||||
|
||||
/**
|
||||
* @see createSimpleScheduler
|
||||
* @see buildSchedule
|
||||
*/
|
||||
typealias KrontabTemplate = String
|
||||
|
||||
inline fun KrontabTemplate.krontabConfig() = KrontabConfig(this)
|
||||
|
||||
/**
|
||||
* Parse [incoming] string and adapt according to next format: "* * * * *" where order of things:
|
||||
*
|
||||
* * **seconds**
|
||||
* * **minutes**
|
||||
* * **hours**
|
||||
* * **dayOfMonth**
|
||||
* * **month**
|
||||
* * **year** (optional)
|
||||
* * **offset** (optional) (can be placed anywhere after month) (must be marked with `o` at the end, for example: 60o == +01:00)
|
||||
* * **dayOfWeek** (optional) (can be placed anywhere after month)
|
||||
* * **milliseconds** (optional) (can be placed anywhere after month) (must be marked with `ms` at the end, for example: 500ms; 100-200ms)
|
||||
*
|
||||
* And each one (except of offsets) have next format:
|
||||
*
|
||||
* `{number}[,{number},...]` or `*`
|
||||
*
|
||||
* and {number} here is one of
|
||||
*
|
||||
* * {int}-{int}
|
||||
* * {int}/{int}
|
||||
* * */{int}
|
||||
* * {int}
|
||||
* * F
|
||||
* * L
|
||||
*
|
||||
* Week days must be marked with `w` at the end, and starts with 0 which means Sunday. For example, 0w == Sunday. With
|
||||
* weeks you can use syntax like with any number like seconds, for example: 0-2w means Sunday-Tuesday
|
||||
*
|
||||
* Additional info about ranges can be found in follow accordance:
|
||||
*
|
||||
* * Seconds ranges can be found in [secondsRange]
|
||||
* * Minutes ranges can be found in [minutesRange]
|
||||
* * Hours ranges can be found in [hoursRange]
|
||||
* * Days of month ranges can be found in [dayOfMonthRange]
|
||||
* * Months ranges can be found in [monthRange]
|
||||
* * Years ranges can be found in [yearRange] (in fact - any [Int])
|
||||
* * WeekDay (timezone) ranges can be found in [dayOfWeekRange]
|
||||
* * Milliseconds ranges can be found in [millisecondsRange]
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* * "0/5 * * * *" for every five seconds triggering
|
||||
* * "0/5,L * * * *" for every five seconds triggering and on 59 second
|
||||
* * "0/15 30 * * *" for every 15th seconds in a half of each hour
|
||||
* * "0/15 30 * * * 500ms" for every 15th seconds in a half of each hour when milliseconds equal to 500
|
||||
* * "1 2 3 F,4,L 5" for triggering in near first second of second minute of third hour of first, fifth and last days of may
|
||||
* * "1 2 3 F,4,L 5 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may in case if it will be in Sunday-Tuesday week days with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year
|
||||
* * "1 2 3 F,4,L 5 2021 60o" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021 60o 0-2w" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00
|
||||
* * "1 2 3 F,4,L 5 2021 60o 0-2w 500ms" for triggering in near first second of second minute of third hour of first, fifth and last days of may of 2021st year if it will be in Sunday-Tuesday week days with timezone UTC+01:00 when milliseconds will be equal to 500
|
||||
*
|
||||
* @return In case when offset parameter is absent in [incoming] will be used [createSimpleScheduler] method and
|
||||
* returned [CronDateTimeScheduler]. In case when offset parameter there is in [incoming] [KrontabTemplate] will be used
|
||||
* [createKronSchedulerWithOffset] and returned [CronDateTimeSchedulerTz]
|
||||
*
|
||||
* @see dev.inmo.krontab.internal.createKronScheduler
|
||||
* @see KrontabConfig.scheduler
|
||||
*/
|
||||
fun createSimpleScheduler(
|
||||
incoming: KrontabTemplate
|
||||
): KronScheduler = KrontabConfig(incoming).scheduler()
|
||||
|
||||
fun createSimpleScheduler(
|
||||
incoming: KrontabTemplate,
|
||||
defaultOffset: Minutes
|
||||
): KronSchedulerTz = KrontabConfig(incoming).scheduler(defaultOffset)
|
||||
|
||||
/**
|
||||
* Shortcut for [createSimpleScheduler]
|
||||
*/
|
||||
fun buildSchedule(incoming: KrontabTemplate): KronScheduler = createSimpleScheduler(incoming)
|
||||
/**
|
||||
* Shortcut for [createSimpleScheduler]
|
||||
*/
|
||||
fun buildSchedule(incoming: KrontabTemplate, defaultOffset: Minutes): KronSchedulerTz = createSimpleScheduler(incoming, defaultOffset)
|
||||
|
||||
/**
|
||||
* Shortcut for [buildSchedule]
|
||||
*/
|
||||
fun KrontabTemplate.toSchedule(): KronScheduler = buildSchedule(this)
|
||||
/**
|
||||
* Shortcut for [buildSchedule]
|
||||
*/
|
||||
fun KrontabTemplate.toSchedule(defaultOffset: Minutes): KronSchedulerTz = buildSchedule(this, defaultOffset)
|
||||
|
||||
/**
|
||||
* Shortcut for [buildSchedule]
|
||||
*/
|
||||
fun KrontabTemplate.toKronScheduler(): KronScheduler = buildSchedule(this)
|
||||
/**
|
||||
* Shortcut for [buildSchedule]
|
||||
*/
|
||||
fun KrontabTemplate.toKronScheduler(defaultOffset: Minutes): KronSchedulerTz = buildSchedule(this, defaultOffset)
|
||||
@@ -1,196 +0,0 @@
|
||||
package dev.inmo.krontab.builder
|
||||
|
||||
import korlibs.time.TimezoneOffset
|
||||
import korlibs.time.minutes
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
import dev.inmo.krontab.KronSchedulerTz
|
||||
import dev.inmo.krontab.internal.*
|
||||
import dev.inmo.krontab.internal.createKronScheduler
|
||||
import dev.inmo.krontab.internal.createKronSchedulerWithOffset
|
||||
import dev.inmo.krontab.utils.Minutes
|
||||
|
||||
/**
|
||||
* Will help to create an instance of [KronScheduler]
|
||||
*
|
||||
* @see dev.inmo.krontab.createSimpleScheduler
|
||||
*/
|
||||
inline fun buildSchedule(settingsBlock: SchedulerBuilder.() -> Unit): KronScheduler {
|
||||
val builder = SchedulerBuilder()
|
||||
|
||||
builder.settingsBlock()
|
||||
|
||||
return builder.build()
|
||||
}
|
||||
|
||||
/**
|
||||
* Will help to create an instance of [KronScheduler]
|
||||
*
|
||||
* @see dev.inmo.krontab.createSimpleScheduler
|
||||
*/
|
||||
inline fun buildSchedule(
|
||||
offset: Minutes,
|
||||
settingsBlock: SchedulerBuilder.() -> Unit
|
||||
): KronSchedulerTz {
|
||||
val builder = SchedulerBuilder(offset = offset)
|
||||
|
||||
builder.settingsBlock()
|
||||
|
||||
return builder.build() as KronSchedulerTz
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates new [KronScheduler] with [settingsBlock]
|
||||
*
|
||||
* Since it is inline function, you may break execution of [settingsBlock]
|
||||
* at any time
|
||||
*/
|
||||
inline operator fun KronScheduler.Companion.invoke(
|
||||
offset: Minutes,
|
||||
settingsBlock: SchedulerBuilder.() -> Unit
|
||||
): KronSchedulerTz = buildSchedule(offset, settingsBlock)
|
||||
|
||||
/**
|
||||
* Creates new [KronScheduler] with [settingsBlock]
|
||||
*
|
||||
* Since it is inline function, you may break execution of [settingsBlock]
|
||||
* at any time
|
||||
*/
|
||||
inline operator fun KronScheduler.Companion.invoke(
|
||||
settingsBlock: SchedulerBuilder.() -> Unit
|
||||
): KronScheduler = buildSchedule(settingsBlock)
|
||||
|
||||
class SchedulerBuilder(
|
||||
private var seconds: Array<Byte>? = null,
|
||||
private var minutes: Array<Byte>? = null,
|
||||
private var hours: Array<Byte>? = null,
|
||||
private var dayOfMonth: Array<Byte>? = null,
|
||||
private var month: Array<Byte>? = null,
|
||||
private var year: Array<Int>? = null,
|
||||
private var dayOfWeek: Array<Byte>? = null,
|
||||
private val offset: Minutes? = null,
|
||||
private var milliseconds: Array<Short>? = null
|
||||
) {
|
||||
private fun <I, T : TimeBuilder<I>> callAndReturn(
|
||||
initial: Array<I>?,
|
||||
builder: T,
|
||||
block: T.() -> Unit
|
||||
): List<I>? {
|
||||
builder.block()
|
||||
|
||||
val builderValue = builder.build()
|
||||
|
||||
return initial ?.let {
|
||||
builderValue ?.let { _ ->
|
||||
(it + builderValue).distinct()
|
||||
} ?: builderValue
|
||||
} ?: builderValue
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an milliseconds block
|
||||
*/
|
||||
fun milliseconds(block: MillisecondsBuilder.() -> Unit) {
|
||||
milliseconds = callAndReturn(
|
||||
milliseconds,
|
||||
MillisecondsBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an seconds block
|
||||
*/
|
||||
fun seconds(block: SecondsBuilder.() -> Unit) {
|
||||
seconds = callAndReturn(
|
||||
seconds,
|
||||
SecondsBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an minutes block
|
||||
*/
|
||||
fun minutes(block: MinutesBuilder.() -> Unit) {
|
||||
minutes = callAndReturn(
|
||||
minutes,
|
||||
MinutesBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an hours block
|
||||
*/
|
||||
fun hours(block: HoursBuilder.() -> Unit) {
|
||||
hours = callAndReturn(
|
||||
hours,
|
||||
HoursBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an days of month block
|
||||
*/
|
||||
fun dayOfMonth(block: DaysOfMonthBuilder.() -> Unit) {
|
||||
dayOfMonth = callAndReturn(
|
||||
dayOfMonth,
|
||||
DaysOfMonthBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an hours block
|
||||
*/
|
||||
fun dayOfWeek(block: WeekDaysBuilder.() -> Unit) {
|
||||
dayOfWeek = callAndReturn(
|
||||
dayOfWeek,
|
||||
WeekDaysBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an months block
|
||||
*/
|
||||
fun months(block: MonthsBuilder.() -> Unit) {
|
||||
month = callAndReturn(
|
||||
month,
|
||||
MonthsBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts an year block
|
||||
*/
|
||||
fun years(block: YearsBuilder.() -> Unit) {
|
||||
year = callAndReturn(
|
||||
year,
|
||||
YearsBuilder(),
|
||||
block
|
||||
) ?.toTypedArray()
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Completely built and independent [KronScheduler]
|
||||
*
|
||||
* @see dev.inmo.krontab.createSimpleScheduler
|
||||
* @see dev.inmo.krontab.internal.createKronScheduler
|
||||
*/
|
||||
fun build(): KronScheduler = offset ?.let {
|
||||
createKronSchedulerWithOffset(
|
||||
seconds,
|
||||
minutes,
|
||||
hours,
|
||||
dayOfMonth,
|
||||
month,
|
||||
year,
|
||||
dayOfWeek,
|
||||
TimezoneOffset(it.minutes),
|
||||
milliseconds ?: millisecondsArrayDefault
|
||||
)
|
||||
} ?: createKronScheduler(seconds, minutes, hours, dayOfMonth, month, year, dayOfWeek, milliseconds ?: millisecondsArrayDefault)
|
||||
}
|
||||
@@ -1,132 +0,0 @@
|
||||
package dev.inmo.krontab.builder
|
||||
|
||||
import dev.inmo.krontab.internal.*
|
||||
|
||||
/**
|
||||
* This class was created for incapsulation of builder work with specified [restrictionsRange]. For example,
|
||||
* [include] function of [TimeBuilder] will always [coerceIn] incoming data using its [restrictionsRange]
|
||||
*/
|
||||
sealed class TimeBuilder<T : Number> (
|
||||
private val restrictionsRange: IntRange,
|
||||
private val converter: Converter<T>
|
||||
) {
|
||||
private var result: Set<Int>? = null
|
||||
|
||||
/**
|
||||
* The first possible value of builder
|
||||
*/
|
||||
val first
|
||||
get() = restrictionsRange.first
|
||||
/**
|
||||
* The last possible value of builder. Using of this variable equal to using "L" in strings
|
||||
*/
|
||||
val last
|
||||
get() = restrictionsRange.last
|
||||
|
||||
/**
|
||||
* After calling of this function this builder will allow any value of current time
|
||||
*/
|
||||
@Suppress("unused")
|
||||
fun allowAll() {
|
||||
result = null
|
||||
}
|
||||
|
||||
/**
|
||||
* Will include all variations from this array inside of this timeline
|
||||
*/
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
infix fun include(array: Array<Int>) {
|
||||
val clamped = array.map { it.coerceIn(restrictionsRange) } + (result ?: emptySet())
|
||||
result = clamped.toSet()
|
||||
}
|
||||
|
||||
/**
|
||||
* Add one [value] to current timeline
|
||||
*/
|
||||
@Suppress("unused")
|
||||
infix fun at(value: Int) {
|
||||
result = (result ?: emptySet()) + value.coerceIn(restrictionsRange)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Shortcut for [at]. In fact will
|
||||
*/
|
||||
@Suppress("unused", "NOTHING_TO_INLINE")
|
||||
inline infix fun each(value: Int) = at(value)
|
||||
|
||||
/**
|
||||
* Just wrapper for more obvious writing something like "[from] 2 [every] 5". For example, for [SecondsBuilder] it
|
||||
* will mean "[from] second second [every] 5 seconds", or "2, 7, 13, ..."
|
||||
*/
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline infix fun from(value: Int) = value
|
||||
|
||||
/**
|
||||
* Will create an sequence of times starting [from] [this] [every] [delay] times. For example, for [SecondsBuilder] it
|
||||
* will mean "[from] second second [every] 5 seconds", or "2, 7, 13, ..."
|
||||
*
|
||||
* @see [from]
|
||||
*/
|
||||
infix fun Int.every(delay: Int): Array<Int> {
|
||||
val progression = coerceIn(restrictionsRange) .. restrictionsRange.last step delay
|
||||
val result = progression.toSet().toTypedArray()
|
||||
|
||||
this@TimeBuilder include result
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Shortcut for "[from] 0 [every] [delay]"
|
||||
*/
|
||||
infix fun every(delay: Int): Array<Int> = this from 0 every delay
|
||||
|
||||
/**
|
||||
* Will fill up this timeline from [this] up to [endIncluding]
|
||||
*/
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
infix fun Int.upTo(endIncluding: Int): Array<Int> {
|
||||
val progression = coerceIn(restrictionsRange) .. endIncluding.coerceIn(restrictionsRange)
|
||||
val result = progression.toSet().toTypedArray()
|
||||
|
||||
this@TimeBuilder include result
|
||||
|
||||
return result
|
||||
}
|
||||
/**
|
||||
* Shortcut for "[from] 0 [upTo] [endIncluding]"
|
||||
*/
|
||||
@Suppress("unused")
|
||||
infix fun upTo(endIncluding: Int): Array<Int> = this from 0 upTo endIncluding
|
||||
/**
|
||||
* Will fill up this timeline from [this] up to [endIncluding]
|
||||
*/
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
infix operator fun Int.rangeTo(endIncluding: Int) = upTo(endIncluding)
|
||||
/**
|
||||
* Shortcut for "[from] 0 [rangeTo] [endIncluding]"
|
||||
*/
|
||||
@Suppress("MemberVisibilityCanBePrivate")
|
||||
infix operator fun rangeTo(endIncluding: Int) = (this from 0) rangeTo endIncluding
|
||||
|
||||
/**
|
||||
* Will include the last possible value
|
||||
*/
|
||||
fun includeLast() = at(restrictionsRange.last)
|
||||
/**
|
||||
* Will include the first possible value
|
||||
*/
|
||||
fun includeFirst() = at(restrictionsRange.first)
|
||||
|
||||
internal fun build() = result ?.map(converter)
|
||||
}
|
||||
|
||||
class MillisecondsBuilder : TimeBuilder<Short>(millisecondsRange, intToShortConverter)
|
||||
class SecondsBuilder : TimeBuilder<Byte>(secondsRange, intToByteConverter)
|
||||
class MinutesBuilder : TimeBuilder<Byte>(minutesRange, intToByteConverter)
|
||||
class HoursBuilder : TimeBuilder<Byte>(hoursRange, intToByteConverter)
|
||||
class DaysOfMonthBuilder : TimeBuilder<Byte>(dayOfMonthRange, intToByteConverter)
|
||||
class MonthsBuilder : TimeBuilder<Byte>(monthRange, intToByteConverter)
|
||||
class YearsBuilder : TimeBuilder<Int>(yearRange, intToIntConverter)
|
||||
class WeekDaysBuilder : TimeBuilder<Byte>(dayOfWeekRange, intToByteConverter)
|
||||
@@ -1,25 +0,0 @@
|
||||
package dev.inmo.krontab.collection
|
||||
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun CollectionKronScheduler.includeAll(kronSchedulers: List<KronScheduler>) {
|
||||
kronSchedulers.forEach {
|
||||
include(it)
|
||||
}
|
||||
}
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun CollectionKronScheduler.includeAll(vararg kronSchedulers: KronScheduler) {
|
||||
includeAll(kronSchedulers.toList())
|
||||
}
|
||||
|
||||
operator fun KronScheduler.plus(kronScheduler: KronScheduler): CollectionKronScheduler {
|
||||
return CollectionKronScheduler().apply {
|
||||
includeAll(this, kronScheduler)
|
||||
}
|
||||
}
|
||||
|
||||
operator fun CollectionKronScheduler.plusAssign(kronScheduler: KronScheduler) {
|
||||
include(kronScheduler)
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
package dev.inmo.krontab.collection
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.DateTimeTz
|
||||
import dev.inmo.krontab.*
|
||||
import dev.inmo.krontab.internal.*
|
||||
|
||||
/**
|
||||
* This scheduler will be useful in case you want to unite several different [KronScheduler]s
|
||||
*/
|
||||
data class CollectionKronScheduler internal constructor(
|
||||
internal val schedulers: MutableList<KronScheduler>
|
||||
) : KronSchedulerTz {
|
||||
internal constructor() : this(mutableListOf())
|
||||
|
||||
/**
|
||||
* Add [kronScheduler] into its [schedulers] list
|
||||
*
|
||||
* * When [kronScheduler] is [CronDateTimeScheduler] it will merge all [CronDateTimeScheduler]s from [schedulers] list
|
||||
* and this [kronScheduler] using [mergeCronDateTimeSchedulers] function
|
||||
* * When [kronScheduler] is [CollectionKronScheduler] it this instance will include all [kronScheduler]
|
||||
* [schedulers]
|
||||
* * Otherwise [kronScheduler] will be added to [schedulers] list
|
||||
*/
|
||||
fun include(kronScheduler: KronScheduler) {
|
||||
when (kronScheduler) {
|
||||
is CronDateTimeScheduler -> {
|
||||
val resultCronDateTimes = mutableListOf(kronScheduler)
|
||||
schedulers.removeAll {
|
||||
if (it is CronDateTimeScheduler) {
|
||||
resultCronDateTimes.add(it)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
schedulers.add(
|
||||
mergeCronDateTimeSchedulers(resultCronDateTimes)
|
||||
)
|
||||
}
|
||||
is CronDateTimeSchedulerTz -> {
|
||||
val newCronDateTimes = mutableListOf(kronScheduler.cronDateTime)
|
||||
schedulers.removeAll {
|
||||
if (it is CronDateTimeSchedulerTz && it.offset == kronScheduler.offset) {
|
||||
newCronDateTimes.add(it.cronDateTime)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
schedulers.add(CronDateTimeSchedulerTz(newCronDateTimes.merge(), kronScheduler.offset))
|
||||
}
|
||||
is CollectionKronScheduler -> kronScheduler.schedulers.forEach {
|
||||
include(it)
|
||||
}
|
||||
else -> schedulers.add(kronScheduler)
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun next(relatively: DateTime): DateTime {
|
||||
return schedulers.mapNotNull { it.next(relatively) }.minOrNull() ?: getAnyNext(relatively)
|
||||
}
|
||||
|
||||
override suspend fun next(relatively: DateTimeTz): DateTimeTz {
|
||||
return schedulers.mapNotNull { it.next(relatively) }.minOrNull() ?: getAnyNext(relatively.local).toOffsetUnadjusted(relatively.offset)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package com.insanusmokrassar.krontab
|
||||
|
||||
import com.soywiz.klock.DateTime
|
||||
import kotlinx.coroutines.delay
|
||||
|
||||
suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean) {
|
||||
do {
|
||||
delay(next().unixMillisLong - DateTime.now().unixMillisLong)
|
||||
} while (block())
|
||||
}
|
||||
suspend inline fun doWhile(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend () -> Boolean
|
||||
) = createSimpleScheduler(scheduleConfig).doWhile(block)
|
||||
|
||||
suspend inline fun KronScheduler.doInfinity(noinline block: suspend () -> Unit) = doWhile {
|
||||
block()
|
||||
true
|
||||
}
|
||||
suspend inline fun doInfinity(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend () -> Unit
|
||||
) = createSimpleScheduler(scheduleConfig).doInfinity(block)
|
||||
|
||||
suspend inline fun KronScheduler.doOnce(noinline block: suspend () -> Unit) = doWhile {
|
||||
block()
|
||||
false
|
||||
}
|
||||
suspend inline fun doOnce(
|
||||
scheduleConfig: String,
|
||||
noinline block: suspend () -> Unit
|
||||
) = createSimpleScheduler(scheduleConfig).doOnce(block)
|
||||
@@ -0,0 +1,7 @@
|
||||
package com.insanusmokrassar.krontab
|
||||
|
||||
import com.soywiz.klock.DateTime
|
||||
|
||||
interface KronScheduler {
|
||||
suspend fun next(relatively: DateTime = DateTime.now()): DateTime
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package com.insanusmokrassar.krontab
|
||||
|
||||
import com.insanusmokrassar.krontab.builder.buildSchedule
|
||||
import com.insanusmokrassar.krontab.internal.CronDateTime
|
||||
|
||||
internal val anyCronDateTime by lazy {
|
||||
CronDateTime()
|
||||
}
|
||||
val AnyTimeScheduler: KronScheduler by lazy {
|
||||
CronDateTimeScheduler(listOf(anyCronDateTime))
|
||||
}
|
||||
val EverySecondScheduler: KronScheduler
|
||||
get() = AnyTimeScheduler
|
||||
|
||||
val EveryMinuteScheduler: KronScheduler by lazy {
|
||||
buildSchedule { minutes { 0 every 1 } }
|
||||
}
|
||||
|
||||
val EveryHourScheduler: KronScheduler by lazy {
|
||||
buildSchedule { hours { 0 every 1 } }
|
||||
}
|
||||
|
||||
val EveryDayOfMonthScheduler: KronScheduler by lazy {
|
||||
buildSchedule { dayOfMonth { 0 every 1 } }
|
||||
}
|
||||
|
||||
val EveryMonthScheduler: KronScheduler by lazy {
|
||||
buildSchedule { months { 0 every 1 } }
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package com.insanusmokrassar.krontab
|
||||
|
||||
import com.insanusmokrassar.krontab.internal.*
|
||||
import com.insanusmokrassar.krontab.internal.CronDateTime
|
||||
import com.insanusmokrassar.krontab.internal.parseDaysOfMonth
|
||||
import com.insanusmokrassar.krontab.internal.parseHours
|
||||
import com.insanusmokrassar.krontab.internal.parseMinutes
|
||||
import com.insanusmokrassar.krontab.internal.parseMonths
|
||||
import com.insanusmokrassar.krontab.internal.parseSeconds
|
||||
|
||||
/**
|
||||
* Parse [incoming] string and adapt according to next format: "* * * * *" where order of things:
|
||||
*
|
||||
* seconds
|
||||
* minutes
|
||||
* hours
|
||||
* dayOfMonth
|
||||
* month
|
||||
*
|
||||
* And each one have next format:
|
||||
*
|
||||
* {number},{number},...
|
||||
*
|
||||
* and {number} here is one of {int}-{int} OR {int}/{int} OR *\/{int} OR {int}.
|
||||
*
|
||||
* Seconds ranges can be found in [com.insanusmokrassar.krontab.internal.secondsRange].
|
||||
* Minutes ranges can be found in [com.insanusmokrassar.krontab.internal.minutesRange].
|
||||
* Hours ranges can be found in [com.insanusmokrassar.krontab.internal.hoursRange].
|
||||
* Days of month ranges can be found in [com.insanusmokrassar.krontab.internal.dayOfMonthRange].
|
||||
* Months ranges can be found in [com.insanusmokrassar.krontab.internal.monthRange].
|
||||
*
|
||||
* @sample "0/5 * * * *" for every five seconds triggering
|
||||
* @sample "0/15 30 * * *" for every 15th seconds in a half of each hour
|
||||
* @sample "1 2 3 4 5" for triggering in near first second of second minute of third hour of fourth day of may
|
||||
*/
|
||||
fun createSimpleScheduler(incoming: String): KronScheduler {
|
||||
val (secondsSource, minutesSource, hoursSource, dayOfMonthSource, monthSource) = incoming.split(" ")
|
||||
|
||||
val secondsParsed = parseSeconds(secondsSource)
|
||||
val minutesParsed = parseMinutes(minutesSource)
|
||||
val hoursParsed = parseHours(hoursSource)
|
||||
val dayOfMonthParsed = parseDaysOfMonth(dayOfMonthSource)
|
||||
val monthParsed = parseMonths(monthSource)
|
||||
|
||||
val resultCronDateTimes = mutableListOf(CronDateTime())
|
||||
|
||||
secondsParsed ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(seconds = currentTime)
|
||||
}
|
||||
|
||||
minutesParsed ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(minutes = currentTime)
|
||||
}
|
||||
|
||||
hoursParsed ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(hours = currentTime)
|
||||
}
|
||||
|
||||
dayOfMonthParsed ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(dayOfMonth = currentTime)
|
||||
}
|
||||
|
||||
monthParsed ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(month = currentTime)
|
||||
}
|
||||
|
||||
return CronDateTimeScheduler(resultCronDateTimes.toList())
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package com.insanusmokrassar.krontab.builder
|
||||
|
||||
import com.insanusmokrassar.krontab.CronDateTimeScheduler
|
||||
import com.insanusmokrassar.krontab.KronScheduler
|
||||
import com.insanusmokrassar.krontab.internal.CronDateTime
|
||||
import com.insanusmokrassar.krontab.internal.fillWith
|
||||
|
||||
fun buildSchedule(settingsBlock: SchedulerBuilder.() -> Unit): KronScheduler {
|
||||
val builder = SchedulerBuilder()
|
||||
|
||||
builder.settingsBlock()
|
||||
|
||||
return builder.build()
|
||||
}
|
||||
|
||||
class SchedulerBuilder(
|
||||
private var seconds: Array<Byte>? = null,
|
||||
private var minutes: Array<Byte>? = null,
|
||||
private var hours: Array<Byte>? = null,
|
||||
private var dayOfMonth: Array<Byte>? = null,
|
||||
private var month: Array<Byte>? = null
|
||||
) {
|
||||
private fun <T : TimeBuilder> callAndReturn(
|
||||
initial: Array<Byte>?,
|
||||
builder: T,
|
||||
block: T.() -> Unit
|
||||
): Array<Byte>? {
|
||||
builder.block()
|
||||
|
||||
val builderValue = builder.build()
|
||||
|
||||
return initial ?.let {
|
||||
builderValue ?.let { _ ->
|
||||
(it + builderValue).distinct().toTypedArray()
|
||||
} ?: builderValue
|
||||
} ?: builderValue
|
||||
}
|
||||
|
||||
fun seconds(block: SecondsBuilder.() -> Unit) {
|
||||
seconds = callAndReturn(
|
||||
seconds,
|
||||
SecondsBuilder(),
|
||||
block
|
||||
)
|
||||
}
|
||||
|
||||
fun minutes(block: MinutesBuilder.() -> Unit) {
|
||||
minutes = callAndReturn(
|
||||
minutes,
|
||||
MinutesBuilder(),
|
||||
block
|
||||
)
|
||||
}
|
||||
|
||||
fun hours(block: HoursBuilder.() -> Unit) {
|
||||
hours = callAndReturn(
|
||||
hours,
|
||||
HoursBuilder(),
|
||||
block
|
||||
)
|
||||
}
|
||||
|
||||
fun dayOfMonth(block: DaysOfMonthBuilder.() -> Unit) {
|
||||
dayOfMonth = callAndReturn(
|
||||
dayOfMonth,
|
||||
DaysOfMonthBuilder(),
|
||||
block
|
||||
)
|
||||
}
|
||||
|
||||
fun months(block: MonthsBuilder.() -> Unit) {
|
||||
month = callAndReturn(
|
||||
month,
|
||||
MonthsBuilder(),
|
||||
block
|
||||
)
|
||||
}
|
||||
|
||||
fun build(): KronScheduler {
|
||||
val resultCronDateTimes = mutableListOf(CronDateTime())
|
||||
|
||||
seconds ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(seconds = currentTime)
|
||||
}
|
||||
|
||||
minutes ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(minutes = currentTime)
|
||||
}
|
||||
|
||||
hours ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(hours = currentTime)
|
||||
}
|
||||
|
||||
dayOfMonth ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(dayOfMonth = currentTime)
|
||||
}
|
||||
|
||||
month ?.fillWith(resultCronDateTimes) { previousCronDateTime: CronDateTime, currentTime: Byte ->
|
||||
previousCronDateTime.copy(month = currentTime)
|
||||
}
|
||||
|
||||
return CronDateTimeScheduler(resultCronDateTimes.toList())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package com.insanusmokrassar.krontab.builder
|
||||
|
||||
import com.insanusmokrassar.krontab.internal.*
|
||||
import com.insanusmokrassar.krontab.utils.clamp
|
||||
|
||||
sealed class TimeBuilder (
|
||||
private val restrictionsRange: IntRange
|
||||
) {
|
||||
private var result: Set<Int>? = null
|
||||
|
||||
fun allowAll() {
|
||||
result = null
|
||||
}
|
||||
|
||||
infix fun include(array: Array<Int>) {
|
||||
val clamped = array.map { it.clamp(restrictionsRange) } + (result ?: emptySet())
|
||||
result = clamped.toSet()
|
||||
}
|
||||
|
||||
infix fun at(value: Int) {
|
||||
result = (result ?: emptySet()) + value.clamp(restrictionsRange)
|
||||
}
|
||||
|
||||
inline fun from(value: Int) = value
|
||||
|
||||
infix fun Int.every(delay: Int): Array<Int> {
|
||||
val progression = clamp(restrictionsRange) .. restrictionsRange.last step delay
|
||||
val result = progression.toSet().toTypedArray()
|
||||
|
||||
this@TimeBuilder include result
|
||||
|
||||
return result
|
||||
}
|
||||
infix fun every(delay: Int): Array<Int> = 0 every delay
|
||||
|
||||
infix fun Int.upTo(endIncluding: Int): Array<Int> {
|
||||
val progression = clamp(restrictionsRange) .. endIncluding.clamp(restrictionsRange)
|
||||
val result = progression.toSet().toTypedArray()
|
||||
|
||||
this@TimeBuilder include result
|
||||
|
||||
return result
|
||||
}
|
||||
infix fun upTo(endIncluding: Int): Array<Int> = 0 upTo endIncluding
|
||||
|
||||
internal fun build() = result ?.map { it.toByte() } ?.toTypedArray()
|
||||
}
|
||||
|
||||
class SecondsBuilder : TimeBuilder(secondsRange)
|
||||
class MinutesBuilder : TimeBuilder(minutesRange)
|
||||
class HoursBuilder : TimeBuilder(com.insanusmokrassar.krontab.internal.hoursRange)
|
||||
class DaysOfMonthBuilder : TimeBuilder(com.insanusmokrassar.krontab.internal.dayOfMonthRange)
|
||||
class MonthsBuilder : TimeBuilder(monthRange)
|
||||
@@ -0,0 +1,77 @@
|
||||
package com.insanusmokrassar.krontab.internal
|
||||
|
||||
import com.insanusmokrassar.krontab.utils.clamp
|
||||
import com.soywiz.klock.DateTime
|
||||
import com.soywiz.klock.DateTimeSpan
|
||||
|
||||
/**
|
||||
* [month] 0-11
|
||||
* [dayOfMonth] 0-31
|
||||
* [hours] 0-23
|
||||
* [minutes] 0-59
|
||||
* [seconds] 0-59
|
||||
*/
|
||||
internal data class CronDateTime(
|
||||
val month: Byte? = null,
|
||||
val dayOfMonth: Byte? = null,
|
||||
val hours: Byte? = null,
|
||||
val minutes: Byte? = null,
|
||||
val seconds: Byte? = null
|
||||
) {
|
||||
init {
|
||||
check(month ?.let { it in com.insanusmokrassar.krontab.internal.monthRange } ?: true)
|
||||
check(dayOfMonth ?.let { it in com.insanusmokrassar.krontab.internal.dayOfMonthRange } ?: true)
|
||||
check(hours?.let { it in com.insanusmokrassar.krontab.internal.hoursRange } ?: true)
|
||||
check(minutes?.let { it in com.insanusmokrassar.krontab.internal.minutesRange } ?: true)
|
||||
check(seconds?.let { it in com.insanusmokrassar.krontab.internal.secondsRange } ?: true)
|
||||
}
|
||||
|
||||
internal val klockDayOfMonth = dayOfMonth ?.plus(1)
|
||||
|
||||
companion object {
|
||||
fun create(
|
||||
month: Int? = null,
|
||||
dayOfMonth: Int? = null,
|
||||
hours: Int? = null,
|
||||
minutes: Int? = null,
|
||||
seconds: Int? = null
|
||||
) = CronDateTime(
|
||||
month ?.clamp(com.insanusmokrassar.krontab.internal.monthRange) ?.toByte(),
|
||||
dayOfMonth ?.clamp(com.insanusmokrassar.krontab.internal.dayOfMonthRange) ?.toByte(),
|
||||
hours ?.clamp(com.insanusmokrassar.krontab.internal.hoursRange) ?.toByte(),
|
||||
minutes ?.clamp(com.insanusmokrassar.krontab.internal.minutesRange) ?.toByte(),
|
||||
seconds ?.clamp(com.insanusmokrassar.krontab.internal.secondsRange) ?.toByte()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
internal fun CronDateTime.toNearDateTime(relativelyTo: DateTime = DateTime.now()): DateTime {
|
||||
var current = relativelyTo
|
||||
|
||||
seconds?.let {
|
||||
val left = it - current.seconds
|
||||
current += DateTimeSpan(minutes = if (left <= 0) 1 else 0, seconds = left)
|
||||
}
|
||||
|
||||
minutes?.let {
|
||||
val left = it - current.minutes
|
||||
current += DateTimeSpan(hours = if (left < 0) 1 else 0, minutes = left)
|
||||
}
|
||||
|
||||
hours?.let {
|
||||
val left = it - current.hours
|
||||
current += DateTimeSpan(days = if (left < 0) 1 else 0, hours = left)
|
||||
}
|
||||
|
||||
klockDayOfMonth ?.let {
|
||||
val left = it - current.dayOfMonth
|
||||
current += DateTimeSpan(months = if (left < 0) 1 else 0, days = left)
|
||||
}
|
||||
|
||||
month ?.let {
|
||||
val left = it - current.month0
|
||||
current += DateTimeSpan(months = if (left < 0) 1 else 0, days = left)
|
||||
}
|
||||
|
||||
return current
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package com.insanusmokrassar.krontab
|
||||
|
||||
import com.insanusmokrassar.krontab.internal.*
|
||||
import com.soywiz.klock.DateTime
|
||||
|
||||
internal data class CronDateTimeScheduler internal constructor(
|
||||
internal val cronDateTimes: List<CronDateTime>
|
||||
) : KronScheduler {
|
||||
override suspend fun next(relatively: DateTime): DateTime {
|
||||
return cronDateTimes.map { it.toNearDateTime(relatively) }.min() ?: anyCronDateTime.toNearDateTime(relatively)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
package com.insanusmokrassar.krontab.internal
|
||||
|
||||
import com.insanusmokrassar.krontab.utils.clamp
|
||||
|
||||
private fun createSimpleScheduler(from: String, dataRange: IntRange): Array<Byte>? {
|
||||
val things = from.split(",")
|
||||
|
||||
val results = things.flatMap {
|
||||
when {
|
||||
it.contains("/") -> {
|
||||
val (start, step) = it.split("/")
|
||||
val startNum = (if (start.isEmpty() || start == "*") {
|
||||
0
|
||||
} else {
|
||||
start.toInt()
|
||||
}).clamp(dataRange)
|
||||
val stepNum = step.toInt().clamp(dataRange)
|
||||
(startNum .. dataRange.last step stepNum).map { it }
|
||||
}
|
||||
it == "*" -> return null
|
||||
else -> listOf(it.toInt().clamp(dataRange))
|
||||
}
|
||||
}
|
||||
|
||||
return results.map { it.toByte() }.toTypedArray()
|
||||
}
|
||||
|
||||
internal fun parseMonths(from: String) = createSimpleScheduler(from, monthRange)
|
||||
internal fun parseDaysOfMonth(from: String) = createSimpleScheduler(from, dayOfMonthRange)
|
||||
internal fun parseHours(from: String) = createSimpleScheduler(from, hoursRange)
|
||||
internal fun parseMinutes(from: String) = createSimpleScheduler(from, minutesRange)
|
||||
internal fun parseSeconds(from: String) = createSimpleScheduler(from, secondsRange)
|
||||
|
||||
internal fun Array<Byte>.fillWith(
|
||||
whereToPut: MutableList<CronDateTime>,
|
||||
createFactory: (CronDateTime, Byte) -> CronDateTime
|
||||
) {
|
||||
val previousValues = whereToPut.toList()
|
||||
|
||||
whereToPut.clear()
|
||||
|
||||
previousValues.forEach { previousValue ->
|
||||
forEach {
|
||||
whereToPut.add(createFactory(previousValue, it))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,10 +1,7 @@
|
||||
package dev.inmo.krontab.internal
|
||||
package com.insanusmokrassar.krontab.internal
|
||||
|
||||
internal val dayOfWeekRange = 0 .. 6
|
||||
internal val yearRange = Int.MIN_VALUE .. Int.MAX_VALUE
|
||||
internal val monthRange = 0 .. 11
|
||||
internal val dayOfMonthRange = 0 .. 30
|
||||
internal val hoursRange = 0 .. 23
|
||||
internal val minutesRange = 0 .. 59
|
||||
internal val secondsRange = minutesRange
|
||||
internal val millisecondsRange = 0 .. 999
|
||||
@@ -0,0 +1,4 @@
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
internal fun Int.clamp(min: Int, max: Int): Int = if (this < min) min else if (this > max) max else this
|
||||
internal fun Int.clamp(range: IntRange): Int = clamp(range.first, range.last)
|
||||
@@ -0,0 +1,25 @@
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import com.insanusmokrassar.krontab.KronScheduler
|
||||
import com.soywiz.klock.DateTime
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.flow.*
|
||||
|
||||
@FlowPreview
|
||||
fun KronScheduler.asFlow(): Flow<DateTime> = SchedulerFlow(this)
|
||||
|
||||
@FlowPreview
|
||||
class SchedulerFlow(
|
||||
private val scheduler: KronScheduler
|
||||
) : AbstractFlow<DateTime>() {
|
||||
@FlowPreview
|
||||
override suspend fun collectSafely(collector: FlowCollector<DateTime>) {
|
||||
while (true) {
|
||||
val now = DateTime.now()
|
||||
val nextTime = scheduler.next(now)
|
||||
val sleepDelay = (nextTime - now).millisecondsLong
|
||||
delay(sleepDelay)
|
||||
collector.emit(nextTime)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,136 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.TimezoneOffset
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
|
||||
/**
|
||||
* @param daysOfWeek 0-6
|
||||
* @param years any int
|
||||
* @param months 0-11
|
||||
* @param daysOfMonth 0-30
|
||||
* @param hours 0-23
|
||||
* @param minutes 0-59
|
||||
* @param seconds 0-59
|
||||
*/
|
||||
internal data class CronDateTime(
|
||||
val daysOfWeek: Array<Byte>? = null,
|
||||
val years: Array<Int>? = null,
|
||||
val months: Array<Byte>? = null,
|
||||
val daysOfMonth: Array<Byte>? = null,
|
||||
val hours: Array<Byte>? = null,
|
||||
val minutes: Array<Byte>? = null,
|
||||
val seconds: Array<Byte>? = null,
|
||||
val milliseconds: Array<Short>? = millisecondsArrayDefault
|
||||
) {
|
||||
init {
|
||||
check(daysOfWeek ?.all { it in dayOfWeekRange } ?: true)
|
||||
check(years?.all { it in yearRange } ?: true)
|
||||
check(months?.all { it in monthRange } ?: true)
|
||||
check(daysOfMonth ?.all { it in dayOfMonthRange } ?: true)
|
||||
check(hours?.all { it in hoursRange } ?: true)
|
||||
check(minutes?.all { it in minutesRange } ?: true)
|
||||
check(seconds?.all { it in secondsRange } ?: true)
|
||||
check(milliseconds?.all { it in millisecondsRange } ?: true)
|
||||
}
|
||||
|
||||
internal val calculators = listOf(
|
||||
years ?.let { NearDateTimeCalculatorYears(it) },
|
||||
daysOfWeek ?.let { NearDateTimeCalculatorWeekDays(it) },
|
||||
milliseconds ?.let { NearDateTimeCalculatorMillis(it) },
|
||||
seconds ?.let { NearDateTimeCalculatorSeconds(it) },
|
||||
minutes ?.let { NearDateTimeCalculatorMinutes(it) },
|
||||
hours ?.let { NearDateTimeCalculatorHours(it) },
|
||||
daysOfMonth ?.let { NearDateTimeCalculatorDays(it) },
|
||||
months ?.let { NearDateTimeCalculatorMonths(it) },
|
||||
)
|
||||
|
||||
internal fun toNearDateTime(relativelyTo: DateTime = DateTime.now()): DateTime? {
|
||||
var current = relativelyTo
|
||||
whileLoop@while (true) {
|
||||
for (calculator in calculators) {
|
||||
val (calculated, requireRecalculation) = (calculator ?: continue).calculateNearTime(current) ?: return null
|
||||
current = calculated
|
||||
if (requireRecalculation) {
|
||||
continue@whileLoop
|
||||
}
|
||||
}
|
||||
return current
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal fun createCronDateTime(
|
||||
seconds: Array<Byte>? = null,
|
||||
minutes: Array<Byte>? = null,
|
||||
hours: Array<Byte>? = null,
|
||||
dayOfMonth: Array<Byte>? = null,
|
||||
month: Array<Byte>? = null,
|
||||
years: Array<Int>? = null,
|
||||
weekDays: Array<Byte>? = null,
|
||||
milliseconds: Array<Short>? = millisecondsArrayDefault
|
||||
): CronDateTime {
|
||||
return CronDateTime(weekDays, years, month, dayOfMonth, hours, minutes, seconds, milliseconds)
|
||||
}
|
||||
|
||||
/**
|
||||
* @return [KronScheduler] (in fact [CronDateTimeScheduler]) based on incoming data
|
||||
*/
|
||||
internal fun createKronScheduler(
|
||||
seconds: Array<Byte>? = null,
|
||||
minutes: Array<Byte>? = null,
|
||||
hours: Array<Byte>? = null,
|
||||
dayOfMonth: Array<Byte>? = null,
|
||||
month: Array<Byte>? = null,
|
||||
years: Array<Int>? = null,
|
||||
weekDays: Array<Byte>? = null,
|
||||
milliseconds: Array<Short>? = millisecondsArrayDefault
|
||||
): KronScheduler = CronDateTimeScheduler(
|
||||
createCronDateTime(
|
||||
seconds,
|
||||
minutes,
|
||||
hours,
|
||||
dayOfMonth,
|
||||
month,
|
||||
years,
|
||||
weekDays,
|
||||
milliseconds
|
||||
)
|
||||
)
|
||||
/**
|
||||
* @return [KronScheduler] (in fact [CronDateTimeScheduler]) based on incoming data
|
||||
*/
|
||||
internal fun createKronSchedulerWithOffset(
|
||||
seconds: Array<Byte>? = null,
|
||||
minutes: Array<Byte>? = null,
|
||||
hours: Array<Byte>? = null,
|
||||
dayOfMonth: Array<Byte>? = null,
|
||||
month: Array<Byte>? = null,
|
||||
years: Array<Int>? = null,
|
||||
weekDays: Array<Byte>? = null,
|
||||
offset: TimezoneOffset,
|
||||
milliseconds: Array<Short>? = millisecondsArrayDefault
|
||||
): KronScheduler = CronDateTimeSchedulerTz(
|
||||
createCronDateTime(
|
||||
seconds,
|
||||
minutes,
|
||||
hours,
|
||||
dayOfMonth,
|
||||
month,
|
||||
years,
|
||||
weekDays,
|
||||
milliseconds
|
||||
),
|
||||
offset
|
||||
)
|
||||
|
||||
internal fun List<CronDateTime>.merge() = CronDateTime(
|
||||
flatMap { it.daysOfWeek ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.years ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.months ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.daysOfMonth ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.hours ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.minutes ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.seconds ?.toList() ?: emptyList() }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
flatMap { it.milliseconds ?.toList() ?: listOf(0) }.distinct().toTypedArray().takeIf { it.isNotEmpty() },
|
||||
)
|
||||
@@ -1,38 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
|
||||
/**
|
||||
* Cron-oriented realisation of [KronScheduler]
|
||||
*
|
||||
* @see dev.inmo.krontab.AnyTimeScheduler
|
||||
* @see dev.inmo.krontab.EveryMillisecondScheduler
|
||||
* @see dev.inmo.krontab.EverySecondScheduler
|
||||
* @see dev.inmo.krontab.EveryMinuteScheduler
|
||||
* @see dev.inmo.krontab.EveryHourScheduler
|
||||
* @see dev.inmo.krontab.EveryDayOfMonthScheduler
|
||||
* @see dev.inmo.krontab.EveryMonthScheduler
|
||||
* @see dev.inmo.krontab.EveryYearScheduler
|
||||
*
|
||||
* @see dev.inmo.krontab.builder.buildSchedule
|
||||
* @see dev.inmo.krontab.builder.SchedulerBuilder
|
||||
*/
|
||||
internal data class CronDateTimeScheduler internal constructor(
|
||||
internal val cronDateTime: CronDateTime
|
||||
) : KronScheduler {
|
||||
/**
|
||||
* @return Near date using [cronDateTimes] list and getting the [Iterable.minByOrNull] one
|
||||
*
|
||||
* @see toNearDateTime
|
||||
*/
|
||||
override suspend fun next(relatively: DateTime): DateTime? {
|
||||
return cronDateTime.toNearDateTime(relatively)
|
||||
}
|
||||
}
|
||||
|
||||
internal fun mergeCronDateTimeSchedulers(
|
||||
schedulers: List<CronDateTimeScheduler>
|
||||
): CronDateTimeScheduler = CronDateTimeScheduler(
|
||||
schedulers.map { it.cronDateTime }.merge()
|
||||
)
|
||||
@@ -1,37 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.DateTimeTz
|
||||
import korlibs.time.TimezoneOffset
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
import dev.inmo.krontab.KronSchedulerTz
|
||||
|
||||
/**
|
||||
* Cron-oriented realisation of [KronScheduler] with taking into account [offset] for list of [cronDateTimes]
|
||||
*
|
||||
* @see CronDateTime
|
||||
*/
|
||||
internal data class CronDateTimeSchedulerTz internal constructor(
|
||||
internal val cronDateTime: CronDateTime,
|
||||
internal val offset: TimezoneOffset
|
||||
) : KronSchedulerTz {
|
||||
override suspend fun next(relatively: DateTimeTz): DateTimeTz? {
|
||||
val dateTimeWithActualOffset = relatively.toOffset(offset).local
|
||||
return cronDateTime.toNearDateTime(dateTimeWithActualOffset) ?.toOffsetUnadjusted(offset) ?.toOffset(relatively.offset)
|
||||
}
|
||||
|
||||
override suspend fun next(relatively: DateTime): DateTime? {
|
||||
return next(relatively.toOffset(offset)) ?.utc
|
||||
}
|
||||
}
|
||||
|
||||
internal fun mergeCronDateTimeSchedulers(
|
||||
schedulers: List<CronDateTimeSchedulerTz>
|
||||
) = schedulers.groupBy {
|
||||
it.offset
|
||||
}.map { (offset, schedulers) ->
|
||||
CronDateTimeSchedulerTz(
|
||||
schedulers.map { it.cronDateTime }.merge(),
|
||||
offset
|
||||
)
|
||||
}
|
||||
@@ -1,4 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
internal const val millisecondsDefault: Short = 0
|
||||
internal val millisecondsArrayDefault: Array<Short> = arrayOf(millisecondsDefault)
|
||||
@@ -1,190 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
import korlibs.time.*
|
||||
import dev.inmo.krontab.utils.copy
|
||||
import kotlin.math.min
|
||||
|
||||
fun interface NearDateTimeCalculator {
|
||||
/**
|
||||
* @return pair of near [DateTime] for this checker and [Boolean] flag that all previous calculations must be
|
||||
* recalculated
|
||||
*/
|
||||
fun calculateNearTime(
|
||||
relativelyTo: DateTime
|
||||
): Pair<DateTime, Boolean>?
|
||||
}
|
||||
|
||||
internal class CommonNearDateTimeCalculator<T>(
|
||||
private val times: Array<T>,
|
||||
private val partGetter: (DateTime) -> T,
|
||||
private val partSetter: (DateTime, T) -> DateTime?
|
||||
) : NearDateTimeCalculator where T : Comparable<T>, T : Number {
|
||||
/**
|
||||
* @return pair of near [DateTime] for this checker and [Boolean] flag that all previous calculations must be
|
||||
* recalculated
|
||||
*/
|
||||
override fun calculateNearTime(
|
||||
relativelyTo: DateTime
|
||||
): Pair<DateTime, Boolean>? {
|
||||
val currentData = partGetter(relativelyTo)
|
||||
val greaterOrEquals = times.firstOrNull { it >= currentData }
|
||||
val newDateTime = when (greaterOrEquals) {
|
||||
null -> partSetter(relativelyTo, times.first()) ?: return null
|
||||
currentData -> relativelyTo
|
||||
else -> partSetter(relativelyTo, greaterOrEquals) ?: return null
|
||||
}
|
||||
return if (newDateTime == relativelyTo) {
|
||||
relativelyTo to false
|
||||
} else {
|
||||
newDateTime to true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal fun NearDateTimeCalculatorMillis(
|
||||
times: Array<Short>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.milliseconds.toShort() },
|
||||
{ dateTime, newOne ->
|
||||
(if (newOne < dateTime.milliseconds) {
|
||||
dateTime.plus(1.seconds)
|
||||
} else {
|
||||
dateTime
|
||||
}).copy(milliseconds = newOne.toInt())
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorSeconds(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.seconds.toByte() },
|
||||
{ dateTime, newOne ->
|
||||
(if (newOne < dateTime.seconds) {
|
||||
dateTime.plus(1.minutes)
|
||||
} else {
|
||||
dateTime
|
||||
}).copy(second = newOne.toInt(), milliseconds = 0)
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorMinutes(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.minutes.toByte() },
|
||||
{ dateTime, newOne ->
|
||||
(if (newOne < dateTime.minutes) {
|
||||
dateTime.plus(1.hours)
|
||||
} else {
|
||||
dateTime
|
||||
}).copy(minute = newOne.toInt(), second = 0, milliseconds = 0)
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorHours(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.hours.toByte() },
|
||||
{ dateTime, newOne ->
|
||||
(if (newOne < dateTime.hours) {
|
||||
dateTime.plus(1.days)
|
||||
} else {
|
||||
dateTime
|
||||
}).copy(hour = newOne.toInt(), minute = 0, second = 0, milliseconds = 0)
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorDays(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ (it.dayOfMonth - 1).toByte() }, // index1, so, decrease
|
||||
{ dateTime, newOne ->
|
||||
val dateTime = (if (newOne < dateTime.dayOfMonth) {
|
||||
dateTime.plus(1.months)
|
||||
} else {
|
||||
dateTime
|
||||
})
|
||||
val newDateTime = dateTime.copy(
|
||||
dayOfMonth = min(dateTime.month.days(dateTime.year), newOne.toInt() + 1), // index1
|
||||
hour = 0,
|
||||
minute = 0,
|
||||
second = 0,
|
||||
milliseconds = 0
|
||||
)
|
||||
// If day of month has not been changed, use old dateTime due to no changes required
|
||||
if (newDateTime.dayOfMonth == dateTime.dayOfMonth) {
|
||||
dateTime
|
||||
} else {
|
||||
newDateTime
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorMonths(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.month0.toByte() },
|
||||
{ dateTime, newOne ->
|
||||
(if (newOne < dateTime.month0) {
|
||||
dateTime.plus(1.years)
|
||||
} else {
|
||||
dateTime
|
||||
}).copy(
|
||||
month = newOne.toInt() + 1, // index1
|
||||
dayOfMonth = 1, // index1
|
||||
hour = 0,
|
||||
minute = 0,
|
||||
second = 0,
|
||||
milliseconds = 0
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorWeekDays(
|
||||
times: Array<Byte>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.dayOfWeek.index0.toByte() },
|
||||
{ dateTime, newOne ->
|
||||
val currentDayOfWeek = dateTime.dayOfWeek.index0
|
||||
if (newOne.toInt() == currentDayOfWeek) return@CommonNearDateTimeCalculator dateTime
|
||||
(if (newOne < currentDayOfWeek) {
|
||||
dateTime.plus(7.days - (currentDayOfWeek - newOne).days)
|
||||
} else {
|
||||
dateTime.plus(newOne.toInt().days - currentDayOfWeek.days)
|
||||
}).copy(
|
||||
hour = 0,
|
||||
minute = 0,
|
||||
second = 0,
|
||||
milliseconds = 0
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
internal fun NearDateTimeCalculatorYears(
|
||||
times: Array<Int>
|
||||
) = CommonNearDateTimeCalculator(
|
||||
times,
|
||||
{ it.yearInt },
|
||||
{ dateTime, newOne ->
|
||||
val currentYear = dateTime.yearInt
|
||||
if (newOne == currentYear) return@CommonNearDateTimeCalculator dateTime
|
||||
(if (newOne < currentYear) {
|
||||
null
|
||||
} else {
|
||||
dateTime.plus(newOne.years - currentYear.years)
|
||||
}) ?.copy(
|
||||
month = 1, // index1
|
||||
dayOfMonth = 1, // index1
|
||||
hour = 0,
|
||||
minute = 0,
|
||||
second = 0,
|
||||
milliseconds = 0
|
||||
)
|
||||
}
|
||||
)
|
||||
@@ -1,77 +0,0 @@
|
||||
package dev.inmo.krontab.internal
|
||||
|
||||
typealias Converter<T> = (Int) -> T
|
||||
|
||||
internal val intToByteConverter: Converter<Byte> = { it: Int -> it.toByte() }
|
||||
internal val intToShortConverter: Converter<Short> = { it: Int -> it.toShort() }
|
||||
internal val intToIntConverter: Converter<Int> = { it: Int -> it }
|
||||
private fun <T> createSimpleScheduler(from: String, dataRange: IntRange, dataConverter: Converter<T>): List<T>? {
|
||||
val things = from.split(",")
|
||||
|
||||
val results = things.flatMap {
|
||||
val currentToken = it.lowercase().replace(
|
||||
"f", dataRange.first.toString()
|
||||
).replace(
|
||||
"l", dataRange.last.toString()
|
||||
)
|
||||
when {
|
||||
currentToken.contains("-") -> {
|
||||
val splitted = currentToken.split("-")
|
||||
(splitted.first().toInt().coerceIn(dataRange) .. splitted[1].toInt().coerceIn(dataRange)).toList()
|
||||
}
|
||||
currentToken.contains("/") -> {
|
||||
val (start, step) = currentToken.split("/")
|
||||
val startNum = (if (start.isEmpty() || start == "*") {
|
||||
0
|
||||
} else {
|
||||
start.toInt()
|
||||
}).coerceIn(dataRange)
|
||||
val stepNum = step.toInt().coerceIn(dataRange)
|
||||
(startNum .. dataRange.last step stepNum).map { it }
|
||||
}
|
||||
currentToken == "*" -> return null
|
||||
else -> listOf(currentToken.toInt().coerceIn(dataRange))
|
||||
}
|
||||
}
|
||||
|
||||
return results.map(dataConverter)
|
||||
}
|
||||
|
||||
internal fun parseWeekDay(from: String?) = from ?.let { if (it.endsWith("w")) createSimpleScheduler(it.removeSuffix("w"), dayOfWeekRange, intToByteConverter) ?.toTypedArray() else null }
|
||||
internal fun parseOffset(from: String?) = from ?.let { if (it.endsWith("o")) it.removeSuffix("o").toIntOrNull() else null }
|
||||
internal fun parseYears(from: String?) = from ?.let { createSimpleScheduler(from, yearRange, intToIntConverter) ?.toTypedArray() }
|
||||
internal fun parseMonths(from: String) = createSimpleScheduler(from, monthRange, intToByteConverter) ?.toTypedArray()
|
||||
internal fun parseDaysOfMonth(from: String) = createSimpleScheduler(from, dayOfMonthRange, intToByteConverter) ?.toTypedArray()
|
||||
internal fun parseHours(from: String) = createSimpleScheduler(from, hoursRange, intToByteConverter) ?.toTypedArray()
|
||||
internal fun parseMinutes(from: String) = createSimpleScheduler(from, minutesRange, intToByteConverter) ?.toTypedArray()
|
||||
internal fun parseSeconds(from: String) = createSimpleScheduler(from, secondsRange, intToByteConverter) ?.toTypedArray()
|
||||
internal fun parseMilliseconds(from: String?) = from ?.let { if (it.endsWith("ms")) createSimpleScheduler(from.removeSuffix("ms"), millisecondsRange, intToShortConverter) ?.toTypedArray() else null }
|
||||
|
||||
internal fun <T> Array<T>.fillWith(
|
||||
whereToPut: MutableList<CronDateTime>,
|
||||
createFactory: (CronDateTime, T) -> CronDateTime
|
||||
) {
|
||||
val previousValues = whereToPut.toList()
|
||||
|
||||
whereToPut.clear()
|
||||
|
||||
previousValues.forEach { previousValue ->
|
||||
forEach {
|
||||
whereToPut.add(createFactory(previousValue, it))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal fun <T> T.fillWith(
|
||||
whereToPut: MutableList<CronDateTime>,
|
||||
createFactory: (CronDateTime, T) -> CronDateTime
|
||||
) {
|
||||
val previousValues = whereToPut.toList()
|
||||
|
||||
whereToPut.clear()
|
||||
|
||||
previousValues.forEach { previousValue ->
|
||||
whereToPut.add(createFactory(previousValue, this))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.Month
|
||||
import kotlin.math.min
|
||||
|
||||
fun DateTime.copy(
|
||||
year: Int = yearInt,
|
||||
month: Int = month1,
|
||||
dayOfMonth: Int = this.dayOfMonth,
|
||||
hour: Int = hours,
|
||||
minute: Int = minutes,
|
||||
second: Int = seconds,
|
||||
milliseconds: Int = this.milliseconds
|
||||
) = DateTime(
|
||||
year,
|
||||
month,
|
||||
min(Month(month).days(yearInt), dayOfMonth),
|
||||
hour,
|
||||
minute,
|
||||
second,
|
||||
milliseconds
|
||||
)
|
||||
@@ -1,94 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.DateTimeTz
|
||||
import korlibs.time.milliseconds
|
||||
import dev.inmo.krontab.KronScheduler
|
||||
import dev.inmo.krontab.next
|
||||
import korlibs.time.millisecondsLong
|
||||
import kotlinx.coroutines.currentCoroutineContext
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.flow
|
||||
import kotlinx.coroutines.flow.onEach
|
||||
import kotlinx.coroutines.isActive
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* Will emit all the [KronScheduler.next] as soon as possible. In case [KronScheduler.next] return null, flow will
|
||||
* be completed
|
||||
*
|
||||
* @param since Will be used as the first parameter for [KronScheduler.next] fun. If passed null, `flow`
|
||||
* will always start since the moment of collecting start
|
||||
*/
|
||||
fun KronScheduler.asTzFlowWithoutDelays(since: DateTimeTz? = null): Flow<DateTimeTz> = flow {
|
||||
var previous = since ?: DateTime.nowLocal()
|
||||
while (currentCoroutineContext().isActive) {
|
||||
val next = next(previous) ?: break
|
||||
emit(next)
|
||||
previous = next + 1.milliseconds
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* This [Flow] will use [asTzFlowWithoutDelays], but stop on each time until this time will happen
|
||||
*/
|
||||
fun KronScheduler.asTzFlowWithDelays(): Flow<DateTimeTz> = asTzFlowWithoutDelays().onEach { futureHappenTime ->
|
||||
val now = DateTime.nowLocal()
|
||||
|
||||
delay((futureHappenTime - now).millisecondsLong)
|
||||
}
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* This [Flow] will use [asTzFlowWithoutDelays], but stop on each time until this time will happen
|
||||
*/
|
||||
@Deprecated(
|
||||
"Behaviour will be changed. In some of near versions this flow will not delay executions",
|
||||
ReplaceWith("this.asTzFlowWithDelays()", "dev.inmo.krontab.utils.asTzFlowWithDelays")
|
||||
)
|
||||
fun KronScheduler.asTzFlow(): Flow<DateTimeTz> = asTzFlowWithDelays()
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* Will emit all the [KronScheduler.next] as soon as possible. In case [KronScheduler.next] return null, flow will
|
||||
* be completed
|
||||
*
|
||||
* @param since Will be used as the first parameter for [KronScheduler.next] fun. If passed null, `flow`
|
||||
* will always start since the moment of collecting start
|
||||
*/
|
||||
fun KronScheduler.asFlowWithoutDelays(since: DateTime? = null): Flow<DateTime> = flow {
|
||||
var previous = since ?: DateTime.now()
|
||||
while (currentCoroutineContext().isActive) {
|
||||
val next = next(previous) ?: break
|
||||
emit(next)
|
||||
previous = next + 1.milliseconds
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* This [Flow] will use [asFlowWithoutDelays], but stop on each time until this time will happen
|
||||
*/
|
||||
fun KronScheduler.asFlowWithDelays(): Flow<DateTime> = asFlowWithoutDelays().onEach { futureHappenTime ->
|
||||
val now = DateTime.now()
|
||||
|
||||
delay((futureHappenTime - now).millisecondsLong)
|
||||
}
|
||||
|
||||
/**
|
||||
* **This flow is [cold](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/)**
|
||||
*
|
||||
* This [Flow] will use [asFlowWithDelays], but stop on each time until this time will happen
|
||||
*/
|
||||
@Deprecated(
|
||||
"Behaviour will be changed. In some of near versions this flow will not delay executions",
|
||||
ReplaceWith("this.asFlowWithDelays()", "dev.inmo.krontab.utils.asFlowWithDelays")
|
||||
)
|
||||
fun KronScheduler.asFlow(): Flow<DateTime> = asFlowWithDelays()
|
||||
@@ -1,3 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
typealias Minutes = Int
|
||||
@@ -1,34 +0,0 @@
|
||||
package dev.inmo.krontab.utils.flows
|
||||
|
||||
import korlibs.time.*
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.filter
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterSeconds(vararg seconds: Int) = filter { it.seconds in seconds }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterMinutes(vararg minutes: Int) = filter { it.minutes in minutes }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterHours(vararg hours: Int) = filter { it.hours in hours }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterDaysOfMonths(vararg daysOfMonths: Int) = filter { it.dayOfMonth in daysOfMonths }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterMonths(vararg months: Month) = filter { it.month in months }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterMonths0(vararg months: Int) = filter { it.month0 in months }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterMonths1(vararg months: Int) = filter { it.month1 in months }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterYears(year: Year) = filter { it.year == year }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterYears(vararg years: Int) = filter { it.yearInt in years }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterWeekDays(vararg weekDays: DayOfWeek) = filter { it.dayOfWeek in weekDays }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.filterWeekDays(vararg weekDays: Int) = filter { it.dayOfWeekInt in weekDays }
|
||||
@@ -1,34 +0,0 @@
|
||||
package dev.inmo.krontab.utils.flows
|
||||
|
||||
import korlibs.time.*
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.filter
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterSeconds(vararg seconds: Int) = filter { it.seconds in seconds }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterMinutes(vararg minutes: Int) = filter { it.minutes in minutes }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterHours(vararg hours: Int) = filter { it.hours in hours }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterDaysOfMonths(vararg daysOfMonths: Int) = filter { it.dayOfMonth in daysOfMonths }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterMonths(vararg months: Month) = filter { it.month in months }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterMonths0(vararg months: Int) = filter { it.month0 in months }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterMonths1(vararg months: Int) = filter { it.month1 in months }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterYears(year: Year) = filter { it.year == year }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterYears(vararg years: Int) = filter { it.yearInt in years }
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterWeekDays(vararg weekDays: DayOfWeek) = filter { it.dayOfWeek in weekDays }
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.filterWeekDays(vararg weekDays: Int) = filter { it.dayOfWeekInt in weekDays }
|
||||
@@ -1,25 +0,0 @@
|
||||
package dev.inmo.krontab.utils.flows
|
||||
|
||||
import korlibs.time.*
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfMinutes() = filterSeconds(0)
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfHours() = filterMinutes(0).onlyStartsOfMinutes()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfDays() = filterHours(0).onlyStartsOfHours()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfMondays() = filterWeekDays(DayOfWeek.Monday).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfSundays() = filterWeekDays(DayOfWeek.Sunday).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfMonths() = filterDaysOfMonths(1).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTime>.onlyStartsOfYears() = filterMonths(Month.January).onlyStartsOfMonths()
|
||||
@@ -1,25 +0,0 @@
|
||||
package dev.inmo.krontab.utils.flows
|
||||
|
||||
import korlibs.time.*
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfMinutes() = filterSeconds(0)
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfHours() = filterMinutes(0).onlyStartsOfMinutes()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfDays() = filterHours(0).onlyStartsOfHours()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfMondays() = filterWeekDays(DayOfWeek.Monday).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfSundays() = filterWeekDays(DayOfWeek.Sunday).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfMonths() = filterDaysOfMonths(1).onlyStartsOfDays()
|
||||
|
||||
@Suppress("NOTHING_TO_INLINE")
|
||||
inline fun Flow<DateTimeTz>.onlyStartsOfYears() = filterMonths(Month.January).onlyStartsOfMonths()
|
||||
@@ -1,23 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.DateTime
|
||||
import korlibs.time.days
|
||||
import dev.inmo.krontab.buildSchedule
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.*
|
||||
|
||||
class CheckMonthsAndDaysCorrectWork {
|
||||
@Test
|
||||
fun checkMonthsAndDaysCorrectWork() {
|
||||
val now = DateTime.now().startOfYear.startOfDay
|
||||
for (i in 0 until now.year.days) {
|
||||
val scheduleDateTime = (now + i.days)
|
||||
runTest {
|
||||
assertEquals(
|
||||
scheduleDateTime,
|
||||
buildSchedule("0 0 0 ${scheduleDateTime.dayOfMonth - 1} ${scheduleDateTime.month0}").next(now)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.*
|
||||
import dev.inmo.krontab.KronSchedulerTz
|
||||
import dev.inmo.krontab.buildSchedule
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.flow.takeWhile
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.*
|
||||
|
||||
@ExperimentalCoroutinesApi
|
||||
@FlowPreview
|
||||
class StringParseTest {
|
||||
@Test
|
||||
fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnString() {
|
||||
val kronScheduler = buildSchedule("*/1 * * * *")
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
|
||||
runTest {
|
||||
val mustBeCollected = 10
|
||||
var collected = 0
|
||||
flow.takeWhile {
|
||||
collected < mustBeCollected
|
||||
}.collect {
|
||||
collected++
|
||||
}
|
||||
assertEquals(mustBeCollected, collected)
|
||||
}
|
||||
}
|
||||
@Test
|
||||
fun testThatFlowIsCorrectlyWorkEverySecondWhenMillisIsHalfOfSecondBuiltOnString() {
|
||||
val kronScheduler = buildSchedule("*/1 * * * * 500ms")
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
|
||||
runTest {
|
||||
val mustBeCollected = 10
|
||||
var collected = 0
|
||||
flow.takeWhile {
|
||||
collected < mustBeCollected
|
||||
}.collect {
|
||||
collected++
|
||||
}
|
||||
assertEquals(mustBeCollected, collected)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testThatFlowIsCorrectlyWorkEverySecondWithMuchOfEmittersBuiltOnString() {
|
||||
val kronScheduler = buildSchedule("*/1 * * * *")
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
|
||||
runTest {
|
||||
val testsCount = 10
|
||||
val failJob = createFailJob((testsCount * 2) * 1000L)
|
||||
val mustBeCollected = 10
|
||||
val answers = (0 until testsCount).map { _ ->
|
||||
async {
|
||||
var collected = 0
|
||||
flow.takeWhile {
|
||||
collected < mustBeCollected
|
||||
}.collect {
|
||||
collected++
|
||||
}
|
||||
collected
|
||||
}
|
||||
}.awaitAll()
|
||||
|
||||
failJob.cancel()
|
||||
|
||||
answers.forEach {
|
||||
assertEquals(mustBeCollected, it)
|
||||
}
|
||||
}
|
||||
}
|
||||
@Test
|
||||
fun testThatFlowIsCorrectlyWorkEverySeveralSecondsRangeBuiltOnString() {
|
||||
val rangesEnds = listOf(0 to 5, 30 to 35)
|
||||
val kronScheduler = buildSchedule("${rangesEnds.joinToString(",") { "${it.first}-${it.second}" }} * * * *")
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
|
||||
runTest {
|
||||
val ranges = rangesEnds.map { it.first .. it.second }.flatten().distinct().toMutableList()
|
||||
val expectedCollects = ranges.size
|
||||
var collected = 0
|
||||
|
||||
flow.takeWhile { ranges.isNotEmpty() }.collect {
|
||||
ranges.remove(it.seconds)
|
||||
collected++
|
||||
assertTrue(
|
||||
collected <= expectedCollects,
|
||||
"Expected value should be less than $expectedCollects, but was $collected. Ranges state: $ranges"
|
||||
)
|
||||
}
|
||||
assertEquals(expectedCollects, collected)
|
||||
}
|
||||
}
|
||||
@Test
|
||||
fun testNextIsCorrectlyWorkEverySeveralMillisecondsRangeBuiltOnString() {
|
||||
val rangesEnds = listOf(0, 200, 500, 750)
|
||||
val kronScheduler = buildSchedule("* * * * * ${rangesEnds.joinToString(",") { "$it" }}ms")
|
||||
|
||||
runTest {
|
||||
val ranges = rangesEnds.toMutableList()
|
||||
val expectedCollects = ranges.size
|
||||
var collected = 0
|
||||
|
||||
var currentTime = DateTime.now()
|
||||
while (ranges.isNotEmpty()) {
|
||||
val nextTrigger = kronScheduler.next(currentTime) ?: error("Strangely unable to get next time")
|
||||
|
||||
ranges.remove(nextTrigger.milliseconds)
|
||||
collected++
|
||||
|
||||
currentTime = nextTrigger + 1.milliseconds
|
||||
}
|
||||
assertEquals(expectedCollects, collected)
|
||||
}
|
||||
}
|
||||
@Test
|
||||
fun testThatTimezoneCorrectlyDeserialized() {
|
||||
val now = DateTime.now().copy(milliseconds = 0).local
|
||||
|
||||
runTest {
|
||||
for (i in 0 .. 1339) {
|
||||
val expectedInCurrentOffset = now.toOffset(TimezoneOffset(i.minutes)) + 1.hours
|
||||
val kronScheduler = buildSchedule(
|
||||
"${expectedInCurrentOffset.seconds} ${expectedInCurrentOffset.minutes} ${expectedInCurrentOffset.hours} * * ${i}o"
|
||||
) as KronSchedulerTz
|
||||
val next = kronScheduler.next(now)
|
||||
assertEquals(expectedInCurrentOffset.toOffset(now.offset), next)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.*
|
||||
import dev.inmo.krontab.builder.buildSchedule
|
||||
import dev.inmo.krontab.next
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class TimeZoneTest {
|
||||
@Test
|
||||
fun testDifferentTimeZonesReturnsDifferentTimes() {
|
||||
val scheduler = buildSchedule { seconds { every(1) } }
|
||||
val additionalMilliseconds = 100.milliseconds
|
||||
val baseDate = DateTime.now().startOfWeek.copy(milliseconds = additionalMilliseconds.millisecondsInt)
|
||||
runTest {
|
||||
for (i in 0 until 7) {
|
||||
val now = baseDate + i.days
|
||||
for (j in 0 .. 24) {
|
||||
val nowTz = now.toOffset(j.hours)
|
||||
val next = scheduler.next(nowTz)!!
|
||||
assertEquals(
|
||||
(nowTz + 1.seconds - additionalMilliseconds).utc.unixMillisLong, next.utc.unixMillisLong
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package dev.inmo.krontab.utils
|
||||
|
||||
import korlibs.time.*
|
||||
import dev.inmo.krontab.builder.buildSchedule
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.math.ceil
|
||||
import kotlin.test.*
|
||||
|
||||
class WeekDaysTest {
|
||||
@Test
|
||||
fun testThatWeekDaysSchedulingWorks() {
|
||||
val startDateTime = DateTime.now().startOfDay
|
||||
val weekDay = startDateTime.dayOfWeek.index0
|
||||
val testDays = 400
|
||||
val scheduler = buildSchedule {
|
||||
dayOfWeek {
|
||||
at(weekDay)
|
||||
}
|
||||
years {
|
||||
at(startDateTime.yearInt)
|
||||
}
|
||||
}
|
||||
runTest {
|
||||
for (day in 0 until testDays) {
|
||||
val currentDateTime = startDateTime + day.days
|
||||
val next = scheduler.next(currentDateTime)
|
||||
val expected = when {
|
||||
day % 7 == 0 -> currentDateTime
|
||||
else -> startDateTime + ceil(day.toFloat() / 7).weeks
|
||||
}
|
||||
if (expected.yearInt != startDateTime.yearInt) {
|
||||
assertNull(next)
|
||||
} else {
|
||||
assertEquals(expected, next)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,6 @@
|
||||
package dev.inmo.krontab.utils
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.*
|
||||
|
||||
fun CoroutineScope.createFailJob(forTimeMillis: Long) = launch {
|
||||
delay(forTimeMillis)
|
||||
@@ -0,0 +1,8 @@
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
|
||||
/**
|
||||
* Workaround to use suspending functions in unit tests
|
||||
*/
|
||||
expect fun runTest(block: suspend (scope : CoroutineScope) -> Unit)
|
||||
@@ -1,9 +1,10 @@
|
||||
package dev.inmo.krontab.utils
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import dev.inmo.krontab.builder.buildSchedule
|
||||
import com.insanusmokrassar.krontab.builder.buildSchedule
|
||||
import com.soywiz.klock.DateTime
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.flow.collect
|
||||
import kotlinx.coroutines.flow.takeWhile
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
@@ -18,7 +19,7 @@ class SchedulerFlowTests {
|
||||
}
|
||||
}
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
val flow = kronScheduler.asFlow()
|
||||
|
||||
runTest {
|
||||
val mustBeCollected = 10
|
||||
@@ -40,14 +41,14 @@ class SchedulerFlowTests {
|
||||
}
|
||||
}
|
||||
|
||||
val flow = kronScheduler.asFlowWithoutDelays()
|
||||
val flow = kronScheduler.asFlow()
|
||||
|
||||
runTest {
|
||||
val testsCount = 10
|
||||
val failJob = createFailJob((testsCount * 2) * 1000L)
|
||||
val failJob = it.createFailJob((testsCount * 2) * 1000L)
|
||||
val mustBeCollected = 10
|
||||
val answers = (0 until testsCount).map { _ ->
|
||||
async {
|
||||
it.async {
|
||||
var collected = 0
|
||||
flow.takeWhile {
|
||||
collected < mustBeCollected
|
||||
@@ -0,0 +1,5 @@
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import kotlinx.coroutines.*
|
||||
|
||||
actual fun runTest(block: suspend (scope : CoroutineScope) -> Unit): dynamic = GlobalScope.promise { block(this) }
|
||||
@@ -0,0 +1,9 @@
|
||||
package com.insanusmokrassar.krontab.utils
|
||||
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.runBlocking
|
||||
|
||||
/**
|
||||
* Workaround to use suspending functions in unit tests
|
||||
*/
|
||||
actual fun runTest(block: suspend (scope: CoroutineScope) -> Unit) = runBlocking(block = block)
|
||||
Reference in New Issue
Block a user