jmrozanec__cron-utils_CVE-2021-41269_9-1-5 — Bibliothèque Java pour l'analyse, la validation, la migration et la description d'expressions cron avec prise en charge de plusieurs formats (Unix, Quartz, Spring) et sortie lisible par l'homme et spécifique à la locale. | Kitploit

cron-utils

Nous définissons les crons. Et nous les supportons.

cron-utils est une bibliothèque Java pour définir, analyser, valider, migrer des crons ainsi que pour en obtenir des descriptions lisibles par les humains. Le projet suit la Convention de Versionnement Sémantique, fournit des métadonnées OSGi et utilise la licence Apache 2.0.

Téléchargement

cron-utils est disponible sur le dépôt Maven central.

<dependency>
    <groupId>com.cronutils</groupId>
    <artifactId>cron-utils</artifactId>
    <version>9.2.1</version>
</dependency>

Pour les développeurs Android, cron-utils 7.0.0 suppose Android 26+. Pour les versions antérieures d'Android, envisagez d'utiliser cron-utils 6.0.6. Si vous utilisez ScheduleExpression de Java EE, cela doit être fourni comme une dépendance d'exécution.

Développement actuel

Nous travaillons actuellement à mettre à jour la base de code vers JDK 16, pour garantir une pleine compatibilité avec JDK 17 lors de sa sortie.

Créez des expressions cron arbitraires : vous pouvez définir votre propre format cron ! Les champs pris en charge sont : seconde, minute, heure, jour du mois, mois, jour de la semaine, année.
Vous pouvez marquer le dernier champ comme optionnel !
Prend en charge tous les caractères spéciaux cron : * / , -
- Les caractères non standard L, W, LW, '?' et # sont également pris en charge !
Prend en charge les extensions / surnoms cron : @yearly, @annually, @monthly, @weekly, @daily, @midnight, @hourly, @reboot
Imprimez dans un format lisible par les humains spécifique à la locale (le chinois, l'anglais, l'allemand, le grec, l'indonésien, le japonais, le coréen, le polonais, le roumain, l'espagnol, le swahili et le turc sont entièrement pris en charge. Le néerlandais, le français, l'italien, le portugais et le russe ont un support de base).
Les processus d'analyse et de description sont découplés : analysez une fois et opérez avec le résultat !
Construisez des expressions cron avec CronBuilder :
- plus besoin de se souvenir des champs et contraintes pour chaque fournisseur cron.
- les crons deviennent découplés du fournisseur cron : vous pouvez à tout moment exporter vers un autre format.
Vérifiez si des expressions cron sont équivalentes.
Réduisez plusieurs expressions cron en une seule !
Validez si des expressions cron sous forme de chaîne correspondent à une définition cron.
Convertissez des crons entre différentes définitions cron : si vous avez besoin de migrer des expressions, CronMapper peut vous aider !
Des définitions prédéfinies pour les bibliothèques cron suivantes sont fournies :
- Unix
- Cron4j
- Quartz
- Spring. Nous supportons deux définitions : avant v5.3 et à partir de v5.3.
Obtenez la dernière/prochaine heure d'exécution ainsi que le temps depuis la dernière exécution/le temps jusqu'à la prochaine exécution.
Calculez le nombre d'exécutions entre deux jours, et comparez des crons en fonction de leurs fréquences d'exécution.
Obtenez le nombre de jours ouvrés entre deux dates, en tenant compte de différentes politiques de week-end ainsi que des jours fériés.
Besoin de mapper des constantes entre différentes bibliothèques de cron/temps ? Utilisez ConstantsMapper.

// Define your own cron: arbitrary fields are allowed and last field can be optional
CronDefinition cronDefinition =
    CronDefinitionBuilder.defineCron()
        .withSeconds().and()
        .withMinutes().and()
        .withHours().and()
        .withDayOfMonth()
            .supportsHash().supportsL().supportsW().and()
        .withMonth().and()
        .withDayOfWeek()
            .withIntMapping(7, 0) //we support non-standard non-zero-based numbers!
            .supportsHash().supportsL().supportsW().and()
        .withYear().optional().and()
        .instance();

// or get a predefined instance
cronDefinition = CronDefinitionBuilder.instanceDefinitionFor(QUARTZ);

// Create a cron expression. CronMigrator will ensure you remain cron provider agnostic
import static com.cronutils.model.field.expression.FieldExpressionFactory.*;

Cron cron = CronBuilder.cron(CronDefinitionBuilder.instanceDefinitionFor(CronType.QUARTZ))
    .withYear(always())
    .withDoM(between(SpecialChar.L, 3))
    .withMonth(always())
    .withDoW(questionMark())
    .withHour(always())
    .withMinute(always())
    .withSecond(on(0))
    .instance();
// Obtain the string expression
String cronAsString = cron.asString(); // 0 * * L-3 * ? *

// Create a descriptor for a specific Locale
CronDescriptor descriptor = CronDescriptor.instance(Locale.UK);

// Parse some expression and ask descriptor for description
String description = descriptor.describe(parser.parse("*/45 * * * * ?"));
// Description will be: "every 45 seconds"

description = descriptor.describe(quartzCron);
// Description will be: "every hour at minute 23 every day between Monday and Friday"
// which is the same description we get for the cron below:
descriptor.describe(parser.parse("0 23 * ? * MON-FRI *"));

// Migration between cron libraries has never been so easy!
// Turn cron expressions into another format by using CronMapper:
CronMapper cronMapper = CronMapper.fromQuartzToCron4j();

Cron cron4jCron = cronMapper.map(quartzCron);
// and to get a String representation of it, we can use
cron4jCron.asString();//will return: 23 * * * 1-5

// Get date for last execution
ZonedDateTime now = ZonedDateTime.now();
ExecutionTime executionTime = ExecutionTime.forCron(parser.parse("* * * * * ? *"));
ZonedDateTime lastExecution = executionTime.lastExecution(now);

// Get date for next execution
ZonedDateTime nextExecution = executionTime.nextExecution(now);

// Time from last execution
Duration timeFromLastExecution = executionTime.timeFromLastExecution(now);

// Time to next execution
Duration timeToNextExecution = executionTime.timeToNextExecution(now);

// Map day of week value from Quartz to JodaTime
int jodatimeDayOfWeek =
        ConstantsMapper.weekDayMapping(
                ConstantsMapper.QUARTZ_WEEK_DAY,
                ConstantsMapper.JODATIME_WEEK_DAY
        );

// You no longer need to remember "YYYY-MM-dd KK a" patterns.
DateTimeFormatter formatter = 
	    HDateTimeFormatBuilder
		    .getInstance()
		    .forJodaTime()
		    .getFormatter(Locale.US)
		    .forPattern("June 9, 2011");
String formattedDateTime = formatter.print(lastExecution);
// formattedDateTime will be lastExecution in "dayOfWeek, Month day, Year" format

jmrozanec__cron-utils_CVE-2021-41269_9-1-5

Populaires

cron-utils