Scheduler.
9 | *
10 | *
11 | * @return Scheduler
12 | */
13 | public function getScheduler();
14 | }
15 |
--------------------------------------------------------------------------------
/pkg/app/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: false
2 |
3 | git:
4 | depth: 1
5 |
6 | language: php
7 |
8 | php:
9 | - '7.2'
10 |
11 | cache:
12 | directories:
13 | - $HOME/.composer/cache
14 |
15 | install:
16 | - composer self-update
17 | - composer install --ignore-platform-reqs --prefer-source
18 |
19 | script:
20 | - vendor/bin/phpunit
21 |
--------------------------------------------------------------------------------
/pkg/bridge/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: false
2 |
3 | git:
4 | depth: 1
5 |
6 | language: php
7 |
8 | php:
9 | - '7.2'
10 |
11 | cache:
12 | directories:
13 | - $HOME/.composer/cache
14 |
15 | install:
16 | - composer self-update
17 | - composer install --ignore-platform-reqs --prefer-source
18 |
19 | script:
20 | - vendor/bin/phpunit
21 |
--------------------------------------------------------------------------------
/pkg/bundle/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: false
2 |
3 | git:
4 | depth: 1
5 |
6 | language: php
7 |
8 | php:
9 | - '7.2'
10 |
11 | cache:
12 | directories:
13 | - $HOME/.composer/cache
14 |
15 | install:
16 | - composer self-update
17 | - composer install --prefer-source --ignore-platform-reqs
18 |
19 | script:
20 | - vendor/bin/phpunit
21 |
--------------------------------------------------------------------------------
/pkg/quartz/Scheduler/JobRunShell.php:
--------------------------------------------------------------------------------
1 | run(new ArgvInput());
12 |
--------------------------------------------------------------------------------
/docker/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM formapro/nginx-php-fpm:7.3-latest-all-exts
2 |
3 | COPY ./cli.ini /etc/php/7.3/cli/conf.d/1-dev_cli.ini
4 | COPY ./entrypoiny.sh /usr/local/bin/entrypoint.sh
5 | RUN chmod u+x /usr/local/bin/entrypoint.sh
6 | RUN apt-get update && apt-get -y --no-install-recommends --no-install-suggests install netcat
7 |
8 | RUN mkdir -p /app
9 | WORKDIR /app
10 |
11 | CMD /usr/local/bin/entrypoint.sh
12 |
--------------------------------------------------------------------------------
/pkg/bundle/Tests/Functional/SchedulerTest.php:
--------------------------------------------------------------------------------
1 | get('test_quartz.scheduler');
12 |
13 | $this->assertInstanceOf(StdScheduler::class, $scheduler);
14 | }
15 | }
--------------------------------------------------------------------------------
/pkg/app/etc/packages/enqueue.yaml:
--------------------------------------------------------------------------------
1 | enqueue:
2 | default:
3 | transport:
4 | dsn: 'amqp:'
5 | connection_factory_class: 'Enqueue\AmqpBunny\AmqpConnectionFactory'
6 | host: '%env(RABBITMQ_HOST)%'
7 | port: '%env(RABBITMQ_PORT)%'
8 | user: '%env(RABBITMQ_USER)%'
9 | pass: '%env(RABBITMQ_PASS)%'
10 | vhost: '%env(RABBITMQ_VHOST)%'
11 | client:
12 | app_name: 'quartz'
13 |
--------------------------------------------------------------------------------
/pkg/bundle/QuartzBundle.php:
--------------------------------------------------------------------------------
1 | addCompilerPass(new QuartzJobCompilerPass());
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/pkg/bundle/Tests/Functional/RemoteSchedulerTest.php:
--------------------------------------------------------------------------------
1 | get('test_quartz.remote.scheduler');
12 |
13 | $this->assertInstanceOf(RemoteScheduler::class, $scheduler);
14 | }
15 | }
--------------------------------------------------------------------------------
/pkg/bundle/Tests/Functional/SchedulerCommandTest.php:
--------------------------------------------------------------------------------
1 | get('test_quartz.cli.scheduler');
12 |
13 | $this->assertInstanceOf(SchedulerCommand::class, $scheduler);
14 | }
15 | }
--------------------------------------------------------------------------------
/pkg/bundle/Tests/Functional/ManagementCommandTest.php:
--------------------------------------------------------------------------------
1 | get('test_quartz.cli.management');
12 |
13 | $this->assertInstanceOf(ManagementCommand::class, $scheduler);
14 | }
15 | }
--------------------------------------------------------------------------------
/pkg/quartz/Events/KeyEvent.php:
--------------------------------------------------------------------------------
1 | key = $key;
19 | }
20 |
21 | /**
22 | * @return Key
23 | */
24 | public function getKey(): Key
25 | {
26 | return $this->key;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/pkg/app/etc/packages/framework.yaml:
--------------------------------------------------------------------------------
1 | framework:
2 | secret: '%env(APP_SECRET)%'
3 | #default_locale: en
4 | #csrf_protection: null
5 | #http_method_override: true
6 | #trusted_hosts: null
7 | # https://symfony.com/doc/current/reference/configuration/framework.html#handler-id
8 | #session:
9 | # handler_id: session.handler.native_file
10 | # save_path: '%kernel.project_dir%/var/sessions/%kernel.environment%'
11 | #esi: ~
12 | #fragments: ~
13 | php_errors:
14 | log: true
15 |
--------------------------------------------------------------------------------
/pkg/quartz/Core/CompletedExecutionInstruction.php:
--------------------------------------------------------------------------------
1 | hydrate($values, build_object($class, $values));
20 | }
21 | }
--------------------------------------------------------------------------------
/pkg/quartz/Events/GroupsEvent.php:
--------------------------------------------------------------------------------
1 | groups = $groups;
17 | }
18 |
19 | /**
20 | * @return string[]|null
21 | */
22 | public function getGroups(): array
23 | {
24 | return $this->groups;
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/pkg/quartz/Events/TriggerEvent.php:
--------------------------------------------------------------------------------
1 | trigger = $trigger;
19 | }
20 |
21 | /**
22 | * @return Trigger
23 | */
24 | public function getTrigger()
25 | {
26 | return $this->trigger;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/pkg/quartz/Events/JobDetailEvent.php:
--------------------------------------------------------------------------------
1 | jobDetail = $jobDetail;
19 | }
20 |
21 | /**
22 | * @return JobDetail
23 | */
24 | public function getJobDetail()
25 | {
26 | return $this->jobDetail;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/pkg/quartz/Events/TickEvent.php:
--------------------------------------------------------------------------------
1 | interrupted = false;
14 | }
15 |
16 | /**
17 | * @return boolean
18 | */
19 | public function isInterrupted()
20 | {
21 | return $this->interrupted;
22 | }
23 |
24 | /**
25 | * @param boolean $interrupt
26 | */
27 | public function setInterrupted($interrupt)
28 | {
29 | $this->interrupted = (bool) $interrupt;
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/pkg/quartz/Scheduler/StdJobRunShellFactory.php:
--------------------------------------------------------------------------------
1 | jobRunShell = $jobRunShell;
19 | }
20 |
21 | /**
22 | * {@inheritdoc}
23 | */
24 | public function createJobRunShell(Trigger $trigger)
25 | {
26 | return $this->jobRunShell;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/bin/test:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | FORCE_EXIT=false
4 |
5 | function waitForService()
6 | {
7 | ATTEMPTS=0
8 | until nc -z $1 $2; do
9 | printf "wait for service %s:%s\n" $1 $2
10 | ((ATTEMPTS++))
11 | if [ $ATTEMPTS -ge $3 ]; then
12 | printf "service is not running %s:%s\n" $1 $2
13 | exit 1
14 | fi
15 | if [ "$FORCE_EXIT" = true ]; then
16 | exit;
17 | fi
18 |
19 | sleep 1
20 | done
21 |
22 | printf "service is online %s:%s\n" $1 $2
23 | }
24 |
25 | trap "FORCE_EXIT=true" SIGTERM SIGINT
26 |
27 | waitForService mongo 27017 50
28 |
29 | bin/phpunit "$@"
30 |
--------------------------------------------------------------------------------
/pkg/app/.env.dist:
--------------------------------------------------------------------------------
1 | # This file is a "template" of which env vars needs to be defined in your configuration or in an .env file
2 | # Set variables here that may be different on each deployment target of the app, e.g. development, staging, production.
3 | # https://symfony.com/doc/current/best_practices/configuration.html#infrastructure-related-configuration
4 |
5 | ###> symfony/framework-bundle ###
6 | APP_ENV=dev
7 | APP_DEBUG=1
8 | APP_SECRET=c2e19906f05378569f0f5357d3245bdd
9 | RABBITMQ_HOST=localhost
10 | RABBITMQ_PORT=5672
11 | RABBITMQ_USER=guest
12 | RABBITMQ_PASS=guest
13 | RABBITMQ_VHOST=/
14 | MONGODB_HOST=localhost
15 | MONGODB_PORT=27017
16 | MONGODB_DB=quartz
17 | ###< symfony/framework-bundle ###
18 |
--------------------------------------------------------------------------------
/pkg/quartz/Scheduler/JobRunShellFactory.php:
--------------------------------------------------------------------------------
1 |
8 | * Responsible for creating the instances of {@link JobRunShell}
9 | * to be used within the
16 | * Called by the {@link org.quartz.core.QuartzSchedulerThread}
17 | * to obtain instances of {@link JobRunShell}.
18 | *
{@link Scheduler} when a {@link Trigger}
9 | * fires that is associated with the Job.
10 | *
11 | *
12 | *
13 | * The implementation may wish to set a
14 | * {@link JobExecutionContext#setResult(Object) result} object on the
15 | * {@link JobExecutionContext} before this method exits. The result itself
16 | * is meaningless to Quartz, but may be informative to
17 | * {@link JobListener}s or
18 | * {@link TriggerListener}s that are watching the job's
19 | * execution.
20 | *
{@link Trigger}
7 | * or {@link Calendar}) in a {@link Scheduler}
8 | * failed, because one with the same name & group already exists.
9 | */
10 | class ObjectAlreadyExistsException extends JobPersistenceException
11 | {
12 | /**
13 | * @param object $object
14 | *
15 | * @return ObjectAlreadyExistsException
16 | */
17 | public static function create($object)
18 | {
19 | if ($object instanceof JobDetail) {
20 | $message = sprintf(
21 | 'Unable to store Job : "%s", because one already exists with this identification.', $object->getKey()
22 | );
23 | } elseif ($object instanceof Trigger) {
24 | $message = sprintf(
25 | 'Unable to store Trigger with name: "%s" and group: "%s", because one already exists with this identification.'
26 | , $object->getKey()->getName(), $object->getKey()->getGroup()
27 | );
28 | } else {
29 | $message = (string) $object;
30 | }
31 |
32 | return new static($message);
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "php-quartz/quartz-dev",
3 | "type": "project",
4 | "minimum-stability": "dev",
5 | "description": "PHP Job Time Scheduler Project",
6 | "keywords": ["job", "time", "task", "time scheduler", "quartz", "chrono"],
7 | "license": "MIT",
8 | "config": {
9 | "bin-dir": "bin",
10 | "platform": {
11 | "php": "7.2",
12 | "ext-mongodb": "1.4"
13 | },
14 | "preferred-install": {
15 | "*": "dist"
16 | },
17 | "sort-packages": true
18 | },
19 | "require": {
20 | "php": "^7.2",
21 | "php-quartz/quartz": "*@dev",
22 | "php-quartz/bridge": "*@dev",
23 | "php-quartz/bundle": "*@dev",
24 | "php-quartz/app": "*@dev",
25 | "symfony/dotenv": "^3.3|^4",
26 | "phpunit/phpunit": "^5.5",
27 | "symfony/browser-kit": "^3.4|^4"
28 | },
29 | "repositories": [
30 | {
31 | "type": "path",
32 | "url": "pkg/quartz"
33 | },
34 | {
35 | "type": "path",
36 | "url": "pkg/bridge"
37 | },
38 | {
39 | "type": "path",
40 | "url": "pkg/bundle"
41 | },
42 | {
43 | "type": "path",
44 | "url": "pkg/app"
45 | }
46 | ]
47 | }
48 |
--------------------------------------------------------------------------------
/pkg/bundle/Tests/Functional/App/AppKernel.php:
--------------------------------------------------------------------------------
1 | load(__DIR__.'/config/config.yml');
46 | }
47 |
48 | protected function getContainerClass()
49 | {
50 | return parent::getContainerClass().'BundleDefault';
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/pkg/quartz/Core/JobFactory.php:
--------------------------------------------------------------------------------
1 |
6 | * A JobFactory is responsible for producing instances of Job
7 | * classes.
8 | *
9 | *
10 | *
11 | * This interface may be of use to those wishing to have their application
12 | * produce Job instances via some special mechanism, such as to
13 | * give the opportunity for dependency injection.
14 | *
Job instance on which to call execute.
22 | *
23 | *
24 | * It should be extremely rare for this method to throw an exception -
25 | * basically only the case where there is no way at all to instantiate
26 | * and prepare the Job for execution. When the exception is thrown, the
27 | * Scheduler will move all triggers associated with the Job into the
28 | * Trigger.STATE_ERROR state, which will require human
29 | * intervention (e.g. an application restart after fixing whatever
30 | * configuration problem led to the issue wih instantiating the Job.
31 | *
17 | * Get the base calendar. Will be null, if not set. 18 | *
19 | * 20 | * @return Calendar 21 | */ 22 | public function getBaseCalendar(); 23 | 24 | /** 25 | *26 | * Determine whether the given time (in milliseconds) is 'included' by the 27 | * Calendar. 28 | *
29 | * 30 | * @param int $timeStamp 31 | * 32 | * @return bool 33 | */ 34 | public function isTimeIncluded($timeStamp); 35 | 36 | /** 37 | *38 | * Determine the next time (in milliseconds) that is 'included' by the 39 | * Calendar after the given time. 40 | *
41 | * 42 | * @param int $timeStamp 43 | * 44 | * @return int timestamp 45 | */ 46 | public function getNextIncludedTime($timeStamp); 47 | 48 | /** 49 | *
50 | * Return the description given to the Calendar instance by
51 | * its creator (if any).
52 | *
60 | * Set a description for the Calendar instance - may be
61 | * useful for remembering/displaying the purpose of the calendar, though
62 | * the description has no meaning to Quartz.
63 | *
9 | * Quartz does not store an actual instance of a Job class, but
10 | * instead allows you to define an instance of one, through the use of a JobDetail.
11 | *
14 | * Jobs have a name and group associated with them, which
15 | * should uniquely identify them within a single {@link Scheduler}.
16 | *
19 | * Triggers are the 'mechanism' by which Jobs
20 | * are scheduled. Many Triggers can point to the same Job,
21 | * but a single Trigger can only point to one Job.
22 | *
38 | * Return the description given to the Job instance by its
39 | * creator (if any).
40 | *
48 | * Get the instance of Job that will be executed.
49 | *
57 | * Get the JobDataMap that is associated with the Job.
58 | *
66 | * Whether or not the Job should remain stored after it is
67 | * orphaned (no {@link Trigger}s point to it).
68 | *
71 | * If not explicitly set, the default value is false.
72 | *
true if the Job should remain persisted after being orphaned.
75 | */
76 | public function isDurable();
77 |
78 | /**
79 | *
80 | * Instructs the Scheduler whether or not the Job
81 | * should be re-executed if a 'recovery' or 'fail-over' situation is
82 | * encountered.
83 | *
86 | * If not explicitly set, the default value is false.
87 | *
13 | * The implementation DOES take the year into consideration, so if you want to 14 | * exclude July 4th for the next 10 years, you need to add 10 entries to the 15 | * exclude list. 16 | *
17 | */ 18 | class HolidayCalendar extends BaseCalendar 19 | { 20 | const INSTANCE = 'holiday'; 21 | 22 | /** 23 | * {@inheritdoc} 24 | */ 25 | public function __construct(Calendar $baseCalendar = null, \DateTimeZone $timeZone = null) 26 | { 27 | parent::__construct(self::INSTANCE, $baseCalendar, $timeZone); 28 | } 29 | 30 | /** 31 | * {@inheritdoc} 32 | */ 33 | public function isTimeIncluded($timeStamp) 34 | { 35 | if (parent::isTimeIncluded($timeStamp) == false) { 36 | return false; 37 | } 38 | 39 | $lookFor = $this->getStartOfDayDateTime($timeStamp); 40 | 41 | $dates = $this->getValue('excludedDates'); 42 | 43 | return false == isset($dates[$lookFor->format('U')]); 44 | } 45 | 46 | /** 47 | * {@inheritdoc} 48 | */ 49 | public function getNextIncludedTime($timeStamp) 50 | { 51 | // Call base calendar implementation first 52 | $baseTime = parent::getNextIncludedTime($timeStamp); 53 | if ($baseTime > 0 && $baseTime > $timeStamp) { 54 | $timeStamp = $baseTime; 55 | } 56 | 57 | // Get timestamp for 00:00:00 58 | $day = $this->getStartOfDayDateTime($timeStamp); 59 | 60 | while (false == $this->isTimeIncluded((int) $day->format('U'))) { 61 | $day->add(new \DateInterval('P1D')); 62 | } 63 | 64 | return (int) $day->format('U'); 65 | } 66 | 67 | /** 68 | *69 | * Add the given Date to the list of excluded days. Only the month, day and 70 | * year of the returned dates are significant. 71 | *
72 | * 73 | * @param \DateTime $excludedDate 74 | */ 75 | public function addExcludedDate(\DateTime $excludedDate) 76 | { 77 | $date = $this->getStartOfDayDateTime($excludedDate->format('U')); 78 | 79 | $dates = $this->getValue('excludedDates'); 80 | $dates[$date->format('U')] = true; 81 | 82 | $this->setValue('excludedDates', $dates); 83 | } 84 | 85 | /** 86 | * @param \DateTime $dateToRemove 87 | */ 88 | public function removeExcludedDate(\DateTime $dateToRemove) 89 | { 90 | $date = $this->getStartOfDayDateTime($dateToRemove->format('U')); 91 | 92 | $dates = $this->getValue('excludedDates'); 93 | unset($dates[$date->format('U')]); 94 | 95 | $this->setValue('excludedDates', $dates); 96 | } 97 | 98 | /** 99 | *100 | * Returns a list of Dates representing the excluded 101 | * days. Only the month, day and year of the returned dates are 102 | * significant. 103 | *
104 | */ 105 | public function getExcludedDates() 106 | { 107 | $dates = []; 108 | foreach ($this->getValue('excludedDates') as $date => $v) { 109 | $d = \DateTime::createFromFormat('U', $date); 110 | 111 | if ($tz = $this->getTimeZone()) { 112 | $d->setTimezone($tz); 113 | } 114 | 115 | $dates[] = $d; 116 | } 117 | 118 | return $dates; 119 | } 120 | } 121 | -------------------------------------------------------------------------------- /pkg/bridge/LoggerSubscriber.php: -------------------------------------------------------------------------------- 1 | logger = $logger; 23 | } 24 | 25 | public function schedulerStarting() 26 | { 27 | $this->debug('Scheduler starting'); 28 | } 29 | 30 | public function schedulerStarted() 31 | { 32 | $this->debug('Scheduler started'); 33 | } 34 | 35 | public function schedulerShuttingdown() 36 | { 37 | $this->debug('Scheduler shutting down'); 38 | } 39 | 40 | public function schedulerShutdown() 41 | { 42 | $this->debug('Scheduler shutdown'); 43 | } 44 | 45 | public function jobToBeExecuted(JobExecutionContextEvent $event) 46 | { 47 | $this->debug(sprintf('Job to be executed: "%s"', (string) $event->getContext()->getJobDetail()->getKey())); 48 | } 49 | 50 | public function jobWasExecuted(JobExecutionContextEvent $event) 51 | { 52 | $this->debug(sprintf('Job was executed: "%s"', (string) $event->getContext()->getJobDetail()->getKey())); 53 | 54 | if ($e = $event->getContext()->getException()) { 55 | $this->debug(sprintf('Job has thrown exception: "%s", "%s"', get_class($e), $e->getMessage())); 56 | } 57 | } 58 | 59 | public function jobExecutionVetoed(JobExecutionContextEvent $event) 60 | { 61 | $this->debug(sprintf('Job was vetoed: "%s"', (string) $event->getContext()->getJobDetail()->getKey())); 62 | } 63 | 64 | public function triggerComplete(JobExecutionContextEvent $event) 65 | { 66 | $trigger = $event->getContext()->getTrigger(); 67 | 68 | $previousFireTime = $trigger->getPreviousFireTime() ? $trigger->getPreviousFireTime()->format(DATE_ISO8601) : 'null'; 69 | $scheduledFireTime = $trigger->getScheduledFireTime() ? $trigger->getScheduledFireTime()->format(DATE_ISO8601) : 'null'; 70 | $nextFireTime = $trigger->getNextFireTime() ? $trigger->getNextFireTime()->format(DATE_ISO8601) : 'null'; 71 | 72 | $this->debug(sprintf('Trigger execution completed: PreviousFireTime: "%s" ScheduledFireTime: "%s" NextFireTime: "%s"', 73 | $previousFireTime, $scheduledFireTime, $nextFireTime)); 74 | } 75 | 76 | public function schedulerError(ErrorEvent $event) 77 | { 78 | $this->debug('Error: '.$event->getMessage()); 79 | 80 | if ($event->getException()) { 81 | $this->debug($event->getException()->getMessage()); 82 | } 83 | } 84 | 85 | /** 86 | * {@inheritdoc} 87 | */ 88 | public static function getSubscribedEvents() 89 | { 90 | return [ 91 | Event::SCHEDULER_STARTING => 'schedulerStarting', 92 | Event::SCHEDULER_STARTED => 'schedulerStarted', 93 | Event::SCHEDULER_SHUTTINGDOWN => 'schedulerShuttingdown', 94 | Event::SCHEDULER_SHUTDOWN => 'schedulerShutdown', 95 | Event::SCHEDULER_ERROR => 'schedulerError', 96 | Event::JOB_TO_BE_EXECUTED => 'jobToBeExecuted', 97 | Event::JOB_WAS_EXECUTED => 'jobWasExecuted', 98 | Event::JOB_EXECUTION_VETOED => 'jobExecutionVetoed', 99 | Event::TRIGGER_COMPLETE => 'triggerComplete', 100 | ]; 101 | } 102 | 103 | private function debug($message) 104 | { 105 | $this->logger->debug(sprintf('[%s] %s', date('H:i:s'), $message)); 106 | } 107 | } 108 | -------------------------------------------------------------------------------- /pkg/quartz/Core/DateBuilder.php: -------------------------------------------------------------------------------- 1 | DateBuilder is used to conveniently create 6 | *java.util.Date instances that meet particular criteria.
7 | *
8 | * Quartz provides a builder-style API for constructing scheduling-related
9 | * entities via a Domain-Specific Language (DSL). The DSL can best be
10 | * utilized through the usage of static imports of the methods on the classes
11 | * TriggerBuilder, JobBuilder,
12 | * DateBuilder, JobKey, TriggerKey
13 | * and the various ScheduleBuilder implementations.
Client code can then use the DSL to write code such as this:
16 | *
17 | * JobDetail job = newJob(MyJob.class)
18 | * .withIdentity("myJob")
19 | * .build();
20 | *
21 | * Trigger trigger = newTrigger()
22 | * .withIdentity(triggerKey("myTrigger", "myTriggerGroup"))
23 | * .withSchedule(simpleSchedule()
24 | * .withIntervalInHours(1)
25 | * .repeatForever())
26 | * .startAt(futureDate(10, MINUTES))
27 | * .build();
28 | *
29 | * scheduler.scheduleJob(job, trigger);
30 | *
31 | */
32 | class DateBuilder
33 | {
34 | // ISO-8601
35 | const MONDAY = 1;
36 | const TUESDAY = 2;
37 | const WEDNESDAY = 3;
38 | const THURSDAY = 4;
39 | const FRIDAY = 5;
40 | const SATURDAY = 6;
41 | const SUNDAY = 7;
42 |
43 | public static function MAX_YEAR()
44 | {
45 | static $maxYear;
46 |
47 | if (null == $maxYear) {
48 | $maxYear = ((int) date('Y')) + 100;
49 | }
50 |
51 | return $maxYear;
52 | }
53 |
54 | ////////////////////////////////////////////////////////////////////////////////////////////////////
55 |
56 | public static function validateDayOfWeek($dayOfWeek)
57 | {
58 | if ($dayOfWeek < self::MONDAY || $dayOfWeek > self::SUNDAY) {
59 | throw new \InvalidArgumentException(sprintf('Invalid day of week: "%s"', $dayOfWeek));
60 | }
61 | }
62 |
63 | public static function validateHour($hour)
64 | {
65 | if ($hour < 0 || $hour > 23) {
66 | throw new \InvalidArgumentException('Invalid hour (must be >= 0 and <= 23).');
67 | }
68 | }
69 |
70 | public static function validateMinute($minute)
71 | {
72 | if ($minute < 0 || $minute > 59) {
73 | throw new \InvalidArgumentException('Invalid minute (must be >= 0 and <= 59).');
74 | }
75 | }
76 |
77 | public static function validateSecond($second)
78 | {
79 | if ($second < 0 || $second > 59) {
80 | throw new \InvalidArgumentException('Invalid second (must be >= 0 and <= 59).');
81 | }
82 | }
83 |
84 | public static function validateDayOfMonth($day)
85 | {
86 | if ($day < 1 || $day > 31) {
87 | throw new \InvalidArgumentException('Invalid day of month (must be >= 1 and <= 31).');
88 | }
89 | }
90 |
91 | public static function validateMonth($month)
92 | {
93 | if ($month < 1 || $month > 12) {
94 | throw new \InvalidArgumentException('Invalid month (must be >= 1 and <= 12.');
95 | }
96 | }
97 |
98 | public static function validateYear($year)
99 | {
100 | if ($year < 0 || $year > self::MAX_YEAR()) {
101 | throw new \InvalidArgumentException('Invalid year (must be >= 0 and <= ' . self::MAX_YEAR());
102 | }
103 | }
104 |
105 | public static function validateIntervalUnit($intervalUnit)
106 | {
107 | if ($intervalUnit < IntervalUnit::SECOND || $intervalUnit > IntervalUnit::YEAR) {
108 | throw new \InvalidArgumentException('Invalid interval unit.');
109 | }
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/pkg/quartz/Tests/Calendar/BaseCalendarTest.php:
--------------------------------------------------------------------------------
1 | assertInstanceOf(Calendar::class, new BaseCalendarImpl(''));
16 | }
17 |
18 | public function testShouldSetInstanceName()
19 | {
20 | $cal = new BaseCalendarImpl('base-calendar');
21 |
22 | $this->assertSame('base-calendar', $cal->getInstance());
23 | }
24 |
25 | public function testCouldSetGetBaseCalendar()
26 | {
27 | $baseCal = new HolidayCalendar(); // have to use real calendar
28 | $baseCal->setDescription('the description');
29 |
30 | $cal = new BaseCalendarImpl('');
31 |
32 | // set base calendar avoid object cache
33 | set_value($cal, 'baseCalendar', get_values($baseCal));
34 |
35 | $this->assertNotNull($cal->getBaseCalendar());
36 | $this->assertInstanceOf(HolidayCalendar::class, $cal->getBaseCalendar());
37 | $this->assertSame('the description', $cal->getBaseCalendar()->getDescription());
38 | }
39 |
40 | public function testCouldSetGetDescription()
41 | {
42 | $cal = new BaseCalendarImpl('');
43 | $cal->setDescription('the description');
44 |
45 | $this->assertSame('the description', $cal->getDescription());
46 | }
47 |
48 | public function testOnIsTimeIncludedShouldReturnTrueIfBaseCalendarNotSet()
49 | {
50 | $cal = new BaseCalendarImpl('');
51 |
52 | $this->assertTrue($cal->isTimeIncluded(1111));
53 | }
54 |
55 | public function testOnIsTimeIncludedShouldThrowExceptionIfTimeIsLessThenZero()
56 | {
57 | $cal = new BaseCalendarImpl('');
58 |
59 | $this->expectException(\InvalidArgumentException::class);
60 | $this->expectExceptionMessage('timeStamp must be greater 0');
61 |
62 | $cal->isTimeIncluded(-1);
63 | }
64 |
65 | public function testOnIsTimeIncludedShouldCallBaseIsTimeIncludedMethod()
66 | {
67 | $cal = new BaseCalendarImpl('');
68 | $cal->setBaseCalendar(new BaseCalendarImpl2(''));
69 |
70 | $this->assertSame(12345, $cal->isTimeIncluded(12345));
71 | }
72 |
73 | public function testOnGetNextIncludedTimeShouldReturnTimeIfBaseCalendarNotSet()
74 | {
75 | $cal = new BaseCalendarImpl('');
76 |
77 | $this->assertSame(1111, $cal->getNextIncludedTime(1111));
78 | }
79 |
80 | public function testOnGetNextIncludedTimeShouldThrowExceptionIfTimeIsLessThenZero()
81 | {
82 | $cal = new BaseCalendarImpl('');
83 |
84 | $this->expectException(\InvalidArgumentException::class);
85 | $this->expectExceptionMessage('timeStamp must be greater 0');
86 |
87 | $cal->getNextIncludedTime(-1);
88 | }
89 |
90 | public function testOnGetNextIncludedTimeShouldCallBaseIsTimeIncludedMethod()
91 | {
92 | $cal = new BaseCalendarImpl('');
93 | $cal->setBaseCalendar(new BaseCalendarImpl2(''));
94 |
95 | $this->assertSame(12345+1, $cal->getNextIncludedTime(12345));
96 | }
97 |
98 | public function testCouldGetSetTimezone()
99 | {
100 | $cal = new BaseCalendarImpl('');
101 | $cal->setTimeZone(new \DateTimeZone('Europe/Simferopol'));
102 |
103 | $this->assertNotNull($cal->getTimeZone());
104 | $this->assertInstanceOf(\DateTimeZone::class, $cal->getTimeZone());
105 | $this->assertSame('Europe/Simferopol', $cal->getTimeZone()->getName());
106 | }
107 | }
108 |
109 | class BaseCalendarImpl extends BaseCalendar
110 | {
111 | public $isTimeIncludedReturnValue;
112 |
113 | public function getInstance()
114 | {
115 | return $this->getValue('instance');
116 | }
117 | }
118 |
119 | class BaseCalendarImpl2 extends BaseCalendar
120 | {
121 | public function isTimeIncluded($timeStamp)
122 | {
123 | return $timeStamp;
124 | }
125 |
126 | public function getNextIncludedTime($timeStamp)
127 | {
128 | return $timeStamp + 1;
129 | }
130 | }
131 |
--------------------------------------------------------------------------------
/pkg/quartz/Tests/Calendar/WeeklyCalendarTest.php:
--------------------------------------------------------------------------------
1 | assertInstanceOf(Calendar::class, new WeeklyCalendar());
14 | }
15 |
16 | public function testShouldReturnDefaultExcludedWeekDays()
17 | {
18 | $cal = new WeeklyCalendar();
19 |
20 | $this->assertSame([DateBuilder::SATURDAY, DateBuilder::SUNDAY], $cal->getDaysExcluded());
21 | }
22 |
23 | public function testOnSetDaysExcludedShouldThrowExceptionIfArrayKeyIsNotDayOfWeek()
24 | {
25 | $cal = new WeeklyCalendar();
26 |
27 | $this->expectException(\InvalidArgumentException::class);
28 | $this->expectExceptionMessage('Invalid day of week: "8"');
29 |
30 | $cal->setDaysExcluded([8]);
31 | }
32 |
33 | public function testShouldSetExcludedDaysOfWeek()
34 | {
35 | $cal = new WeeklyCalendar();
36 |
37 | $cal->setDaysExcluded([DateBuilder::MONDAY, DateBuilder::FRIDAY]);
38 |
39 | $this->assertSame([DateBuilder::MONDAY, DateBuilder::FRIDAY], $cal->getDaysExcluded());
40 | }
41 |
42 | public function testOnSetDayExcludedShouldThrowExceptionIfArgumentIsNotDayOfWeek()
43 | {
44 | $cal = new WeeklyCalendar();
45 |
46 | $this->expectException(\InvalidArgumentException::class);
47 | $this->expectExceptionMessage('Invalid day of week: "9"');
48 |
49 | $cal->setDayExcluded(9, true);
50 | }
51 |
52 | public function testShouldSetExcludedDayOfWeek()
53 | {
54 | $cal = new WeeklyCalendar();
55 |
56 | $cal->setDayExcluded(DateBuilder::THURSDAY, true);
57 | $cal->setDayExcluded(DateBuilder::FRIDAY, true);
58 |
59 | $this->assertSame([
60 | DateBuilder::THURSDAY,
61 | DateBuilder::FRIDAY,
62 | DateBuilder::SATURDAY,
63 | DateBuilder::SUNDAY
64 | ], $cal->getDaysExcluded());
65 | }
66 |
67 | public function testShouldUnsetExcludedDayOfWeek()
68 | {
69 | $cal = new WeeklyCalendar();
70 |
71 | $cal->setDayExcluded(DateBuilder::FRIDAY, true);
72 |
73 | $this->assertSame([
74 | DateBuilder::FRIDAY,
75 | DateBuilder::SATURDAY,
76 | DateBuilder::SUNDAY
77 | ], $cal->getDaysExcluded());
78 |
79 | // unset
80 | $cal->setDayExcluded(DateBuilder::FRIDAY, false);
81 | $cal->setDayExcluded(DateBuilder::SUNDAY, false);
82 |
83 | $this->assertSame([
84 | DateBuilder::SATURDAY,
85 | ], $cal->getDaysExcluded());
86 | }
87 |
88 | public function testShouldReturnTrueWhenAllDaysAreExcluded()
89 | {
90 | $cal = new WeeklyCalendar();
91 |
92 | $this->assertFalse($cal->areAllDaysExcluded());
93 |
94 | $cal->setDaysExcluded(range(1, 7));
95 |
96 | $this->assertTrue($cal->areAllDaysExcluded());
97 | }
98 |
99 | public function testShouldReturnTrueWhenTimeIsIncluded()
100 | {
101 | $cal = new WeeklyCalendar();
102 |
103 | $cal->setDaysExcluded([4]);
104 |
105 | $included = new \DateTime('2012-12-12 12:12:12');
106 | $excluded = new \DateTime('2012-12-13 12:12:12');
107 |
108 | // included
109 | $this->assertSame(3, (int) $included->format('N'));
110 | $this->assertTrue($cal->isTimeIncluded((int) $included->format('U')));
111 |
112 | // excluded
113 | $this->assertSame(4, (int) $excluded->format('N'));
114 | $this->assertFalse($cal->isTimeIncluded((int) $excluded->format('U')));
115 | }
116 |
117 | public function testShouldReturnNextIncludedTime()
118 | {
119 | $cal = new WeeklyCalendar();
120 |
121 | $cal->setDaysExcluded([2, 3, 4, 5]);
122 |
123 | $date = new \DateTime('2012-12-11 12:12:12');
124 |
125 | $this->assertSame(2, (int) $date->format('N'));
126 |
127 | $nextIncludedTime = $cal->getNextIncludedTime((int) $date->format('U'));
128 |
129 | $this->assertInternalType('int', $nextIncludedTime);
130 |
131 | $this->assertEquals(new \DateTime('2012-12-15 00:00:00'), \DateTime::createFromFormat('U', $nextIncludedTime));
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/pkg/bridge/Scheduler/SchedulerFactory.php:
--------------------------------------------------------------------------------
1 | config = $config;
57 | }
58 |
59 | /**
60 | * {@inheritdoc}
61 | */
62 | public function getScheduler()
63 | {
64 | if (null == $this->scheduler) {
65 | $eventDispatcher = new EventDispatcher();
66 |
67 | $this->scheduler = new StdScheduler(
68 | $this->getStore(),
69 | $this->getJobRunShellFactory(),
70 | $this->getJobFactory(),
71 | $eventDispatcher
72 | );
73 | }
74 |
75 | return $this->scheduler;
76 | }
77 |
78 | public function getRemoteScheduler()
79 | {
80 | $transport = new EnqueueRemoteTransport($this->getEnqueue()->getProducerV2());
81 |
82 | return new RemoteScheduler($transport, new RpcProtocol());
83 | }
84 |
85 | public function getJobRunShellFactory()
86 | {
87 | if (null == $this->jobRunShellFactory) {
88 | $runJobShell = new EnqueueJobRunShell($this->getEnqueue()->getProducerV2());
89 | $this->jobRunShellFactory = new StdJobRunShellFactory($runJobShell);
90 | }
91 |
92 | return $this->jobRunShellFactory;
93 | }
94 |
95 | /**
96 | * @return SimpleJobFactory
97 | */
98 | public function getJobFactory()
99 | {
100 | if (null == $this->jobFactory) {
101 | $job = new EnqueueResponseJob($this->getEnqueue()->getProducerV2());
102 |
103 | $this->jobFactory = new SimpleJobFactory([
104 | EnqueueResponseJob::class => $job,
105 | ]);
106 | }
107 |
108 | return $this->jobFactory;
109 | }
110 |
111 | /**
112 | * @return JobRunShellProcessor
113 | */
114 | public function getJobRunShellProcessor()
115 | {
116 | $jobRunShell = new StdJobRunShell();
117 | $jobRunShell->initialize($this->getScheduler());
118 |
119 | return new JobRunShellProcessor($this->getStore(), $jobRunShell);
120 | }
121 |
122 | /**
123 | * @return EnqueueRemoteTransportProcessor
124 | */
125 | public function getRemoteSchedulerProcessor()
126 | {
127 | return new EnqueueRemoteTransportProcessor($this->getScheduler(), new RpcProtocol());
128 | }
129 |
130 | /**
131 | * @return YadmStore
132 | */
133 | public function getStore()
134 | {
135 | if (null == $this->store) {
136 | $config = isset($this->config['store']) ? $this->config['store'] : [];
137 | $this->store = new YadmStore(new SimpleStoreResource($config));
138 | }
139 |
140 | return $this->store;
141 | }
142 |
143 | /**
144 | * @return SimpleClient
145 | */
146 | public function getEnqueue()
147 | {
148 | if (null == $this->enqueue) {
149 | $config = isset($this->config['enqueue']) ? $this->config['enqueue'] : [];
150 | $this->enqueue = new SimpleClient($config);
151 | }
152 |
153 | return $this->enqueue;
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/pkg/quartz/Scheduler/StdJobRunShell.php:
--------------------------------------------------------------------------------
1 | scheduler = $scheduler;
21 | }
22 |
23 | /**
24 | * {@inheritdoc}
25 | */
26 | public function execute(Trigger $trigger)
27 | {
28 | if (false == $jobDetail = $this->scheduler->getJobDetail($trigger->getJobKey())) {
29 | $trigger->setErrorMessage(sprintf('Job was not found with key: "%s"', (string) $trigger->getJobKey()));
30 | $this->scheduler->notifyJobStoreJobComplete($trigger, null, CompletedExecutionInstruction::SET_ALL_JOB_TRIGGERS_ERROR);
31 |
32 | return;
33 | }
34 |
35 | $calendar = null;
36 | if ($trigger->getCalendarName()) {
37 | if (false == $calendar = $this->scheduler->getCalendar($trigger->getCalendarName())) {
38 | $trigger->setErrorMessage(sprintf('Calendar was not found with name: "%s"', (string) $trigger->getCalendarName()));
39 | $this->scheduler->notifyJobStoreJobComplete($trigger, $jobDetail, CompletedExecutionInstruction::SET_ALL_JOB_TRIGGERS_ERROR);
40 |
41 | return;
42 | }
43 | }
44 |
45 | try {
46 | $job = $this->scheduler->getJobFactory()->newJob($jobDetail);
47 | } catch (\Exception $e) {
48 | $trigger->setErrorMessage(sprintf('Job instance was not created: "%s"', (string) $jobDetail->getKey()));
49 | $this->scheduler->notifyJobStoreJobComplete($trigger, $jobDetail, CompletedExecutionInstruction::SET_ALL_JOB_TRIGGERS_ERROR);
50 |
51 | return;
52 | }
53 |
54 | $context = new JobExecutionContext($this->scheduler, $trigger, $jobDetail, $calendar);
55 |
56 | $now = time();
57 | $scheduledFireTime = (int) $context->getTrigger()->getScheduledFireTime()->format('U');
58 |
59 | // sleep until execution time is came up
60 | if ($scheduledFireTime > $now) {
61 | $sleepTime = $scheduledFireTime - $now;
62 |
63 | if ($sleepTime > 120) { // 2 min
64 | $trigger->setErrorMessage(sprintf('Sleep time is too long. "%d"', $sleepTime));
65 | $this->scheduler->notifyJobStoreJobComplete($trigger, $jobDetail, CompletedExecutionInstruction::NOOP);
66 | }
67 |
68 | sleep($scheduledFireTime - $now);
69 | }
70 |
71 | $startTime = microtime(true);
72 | while (true) {
73 | if ($this->scheduler->notifyTriggerListenersFired($context)) {
74 | // trigger vetoed
75 | $this->scheduler->notifyJobListenersWasVetoed($context);
76 |
77 | $instructionCode = $trigger->executionComplete($context);
78 | $this->scheduler->notifyJobStoreJobComplete($trigger, $jobDetail, $instructionCode);
79 |
80 | if (null == $trigger->getNextFireTime()) {
81 | $this->scheduler->notifySchedulerListenersFinalized($trigger);
82 | }
83 |
84 | break;
85 | }
86 |
87 | $this->scheduler->notifyJobListenersToBeExecuted($context);
88 |
89 | try {
90 | $job->execute($context);
91 | } catch (\Exception $e) {
92 | $context->setException($e);
93 | } catch (\Error $e) {
94 | $context->setException($e);
95 | }
96 |
97 | $endTime = microtime(true);
98 | $context->setJobRunTime(($endTime - $startTime) * 1000);
99 |
100 | $this->scheduler->notifyJobListenersWasExecuted($context);
101 |
102 | $instructionCode = $trigger->executionComplete($context);
103 |
104 | $this->scheduler->notifyTriggerListenersComplete($context);
105 |
106 | if ($instructionCode === CompletedExecutionInstruction::RE_EXECUTE_JOB) {
107 | $context->incrementRefireCount();
108 |
109 | continue;
110 | }
111 |
112 | $this->scheduler->notifyJobStoreJobComplete($trigger, $jobDetail, $instructionCode);
113 |
114 | break;
115 | }
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/pkg/quartz/Calendar/BaseCalendar.php:
--------------------------------------------------------------------------------
1 | setInstance($instance);
19 | $this->setBaseCalendar($baseCalendar);
20 | $this->setTimeZone($timeZone);
21 | }
22 |
23 | /**
24 | * @param string $instance
25 | */
26 | protected function setInstance($instance)
27 | {
28 | $this->setValue('instance', $instance);
29 | }
30 |
31 | /**
32 | * {@inheritdoc}
33 | */
34 | public function setBaseCalendar(Calendar $baseCalendar = null)
35 | {
36 | $this->setObject('baseCalendar', $baseCalendar);
37 | }
38 |
39 | /**
40 | * {@inheritdoc}
41 | */
42 | public function getBaseCalendar()
43 | {
44 | return $this->getObject('baseCalendar', function ($values) {
45 | return ModelClassFactory::getClass($values);
46 | });
47 | }
48 |
49 | /**
50 | * {@inheritdoc}
51 | */
52 | public function getDescription()
53 | {
54 | return $this->getValue('description');
55 | }
56 |
57 | /**
58 | * {@inheritdoc}
59 | */
60 | public function setDescription($description)
61 | {
62 | $this->setValue('description', $description);
63 | }
64 |
65 | /**
66 | * {@inheritdoc}
67 | */
68 | public function isTimeIncluded($timeStamp)
69 | {
70 | if ($timeStamp <= 0) {
71 | throw new InvalidArgumentException('timeStamp must be greater 0');
72 | }
73 |
74 | if (null != $baseCalendar = $this->getBaseCalendar()) {
75 | return $baseCalendar->isTimeIncluded($timeStamp);
76 | }
77 |
78 | return true;
79 | }
80 |
81 | /**
82 | * {@inheritdoc}
83 | */
84 | public function getNextIncludedTime($timeStamp)
85 | {
86 | if ($timeStamp <= 0) {
87 | throw new InvalidArgumentException('timeStamp must be greater 0');
88 | }
89 |
90 | if (null != $baseCalendar = $this->getBaseCalendar()) {
91 | return $baseCalendar->getNextIncludedTime($timeStamp);
92 | }
93 |
94 | return $timeStamp;
95 | }
96 |
97 | /**
98 | * Returns the time zone for which this Calendar will be
99 | * resolved.
100 | *
101 | * @return \DateTimeZone This Calendar's timezone, null if Calendar should use the default
102 | */
103 | public function getTimeZone()
104 | {
105 | if ($timezone = $this->getValue('timezone')) {
106 | return new \DateTimeZone($timezone);
107 | }
108 | }
109 |
110 | /**
111 | * Sets the time zone for which this Calendar will be resolved.
112 | *
113 | * @param \DateTimeZone $timeZone The time zone to use for this Calendar, null if default should be used
114 | */
115 | public function setTimeZone(\DateTimeZone $timeZone = null)
116 | {
117 | if ($timeZone) {
118 | $value = $timeZone->getName();
119 | } else {
120 | $value = null;
121 | }
122 |
123 | $this->setValue('timezone', $value);
124 | }
125 |
126 | /**
127 | * @param int $timeStamp
128 | *
129 | * @return \DateTime
130 | */
131 | protected function createDateTime($timeStamp)
132 | {
133 | $date = \DateTime::createFromFormat('U', $timeStamp);
134 |
135 | if ($tz = $this->getTimeZone()) {
136 | $date->setTimezone($tz);
137 | }
138 |
139 | return $date;
140 | }
141 |
142 | /**
143 | * @param int $timeStamp
144 | *
145 | * @return \DateTime
146 | */
147 | protected function getStartOfDayDateTime($timeStamp)
148 | {
149 | $date = $this->createDateTime($timeStamp);
150 | $date->setTime(0, 0, 0);
151 |
152 | return $date;
153 | }
154 |
155 | /**
156 | * @param int $timeStamp
157 | *
158 | * @return \DateTime
159 | */
160 | protected function getEndOfDayDateTime($timeStamp)
161 | {
162 | $date = $this->createDateTime($timeStamp);
163 | $date->setTime(23, 59, 59);
164 |
165 | return $date;
166 | }
167 | }
168 |
--------------------------------------------------------------------------------
/pkg/bridge/Yadm/SimpleStoreResource.php:
--------------------------------------------------------------------------------
1 | options = array_replace([
33 | 'uri' => 'mongodb://localhost:27017',
34 | 'uriOptions' => [],
35 | 'driverOptions' => [],
36 | 'sessionId' => 'quartz',
37 | 'dbName' => 'quartz',
38 | 'managementLockCol' => 'managementLock',
39 | 'calendarCol' => 'calendar',
40 | 'triggerCol' => 'trigger',
41 | 'firedTriggerCol' => 'firedTrigger',
42 | 'jobCol' => 'job',
43 | 'pausedTriggerCol' => 'pausedTrigger',
44 |
45 | ], $options);
46 | }
47 |
48 | public function getClient(): Client
49 | {
50 | return $this->getClientProvider()->getClient();
51 | }
52 |
53 | public function getClientProvider(): ClientProvider
54 | {
55 | if (false == $this->clientProvider) {
56 | $this->clientProvider = new ClientProvider($this->options['uri'], $this->options['uriOptions'], $this->options['driverOptions']);
57 | }
58 |
59 | return $this->clientProvider;
60 | }
61 |
62 | public function getCollectionFactory(): CollectionFactory
63 | {
64 | if (false == $this->collectionFactory) {
65 | $this->collectionFactory = new CollectionFactory($this->getClientProvider(), $this->options['uri']);
66 | }
67 |
68 | return $this->collectionFactory;
69 | }
70 |
71 | public function getManagementLock(): PessimisticLock
72 | {
73 | if (false == $this->managementLock) {
74 | $collection = $this->getCollectionFactory()->create($this->options['managementLockCol']);
75 |
76 | $this->managementLock = new PessimisticLock($collection, $this->options['sessionId']);
77 | }
78 |
79 | return $this->managementLock;
80 | }
81 |
82 | public function getCalendarStorage(): CalendarStorage
83 | {
84 | if (false == $this->calendarStorage) {
85 | $this->calendarStorage = new CalendarStorage(
86 | $this->options['calendarCol'],
87 | $this->getCollectionFactory(),
88 | new ModelHydrator()
89 | );
90 | }
91 |
92 | return $this->calendarStorage;
93 | }
94 |
95 | public function getTriggerStorage(): TriggerStorage
96 | {
97 | if (false == $this->triggerStorage) {
98 | $this->triggerStorage = new TriggerStorage(
99 | $this->options['triggerCol'],
100 | $this->getCollectionFactory(),
101 | new ModelHydrator()
102 | );
103 | }
104 |
105 | return $this->triggerStorage;
106 | }
107 |
108 | public function getFiredTriggerStorage(): FiredTriggerStorage
109 | {
110 | if (false == $this->firedTriggerStorage) {
111 | $this->firedTriggerStorage = new FiredTriggerStorage(
112 | $this->options['firedTriggerCol'],
113 | $this->getCollectionFactory(),
114 | new ModelHydrator()
115 | );
116 | }
117 |
118 | return $this->firedTriggerStorage;
119 | }
120 |
121 | public function getJobStorage(): JobStorage
122 | {
123 | if (false == $this->jobStorage) {
124 | $this->jobStorage = new JobStorage(
125 | $this->options['jobCol'],
126 | $this->getCollectionFactory(),
127 | new ModelHydrator()
128 | );
129 | }
130 |
131 | return $this->jobStorage;
132 | }
133 |
134 | public function getPausedTriggerStorage(): PausedTriggerStorage
135 | {
136 | if (false == $this->pausedTriggerStorage) {
137 | $this->pausedTriggerStorage = new PausedTriggerStorage(
138 | $this->options['pausedTriggerCol'],
139 | $this->getCollectionFactory(),
140 | new ModelHydrator()
141 | );
142 | }
143 |
144 | return $this->pausedTriggerStorage;
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/pkg/quartz/Tests/Triggers/SimpleTriggerTest.php:
--------------------------------------------------------------------------------
1 | assertInstanceOf(Trigger::class, new SimpleTrigger());
14 | }
15 |
16 | public function testCouldSetGetRepeatCount()
17 | {
18 | $t = new SimpleTrigger();
19 | $t->setRepeatCount(123);
20 |
21 | $this->assertSame(123, $t->getRepeatCount());
22 | }
23 |
24 | public function testCouldSetGetRepeatInterval()
25 | {
26 | $t = new SimpleTrigger();
27 | $t->setRepeatInterval(123);
28 |
29 | $this->assertSame(123, $t->getRepeatInterval());
30 | }
31 |
32 | public function testOnValidateShouldThrowExceptionIfRepeatIntervalIsLessThanOne()
33 | {
34 | $t = new SimpleTrigger();
35 | $t->setRepeatInterval(0);
36 |
37 | $this->expectException(SchedulerException::class);
38 | $this->expectExceptionMessage('Trigger\'s name cannot be null');
39 |
40 | $t->validate();
41 | }
42 |
43 | public function testShouldComputeFirstFireTime()
44 | {
45 | $t = new SimpleTrigger();
46 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
47 | $t->setRepeatInterval(10);
48 |
49 | $this->assertEquals(new \DateTime('2012-12-12 12:00:00'), $t->computeFirstFireTime());
50 | }
51 |
52 | public function testShouldComputeFireTimeAfter()
53 | {
54 | $t = new SimpleTrigger();
55 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
56 | $t->setRepeatInterval(10);
57 | $t->setRepeatCount(SimpleTrigger::REPEAT_INDEFINITELY);
58 |
59 | $this->assertEquals(new \DateTime('2012-12-12 12:00:10'), $t->getFireTimeAfter(new \DateTime('2012-12-12 12:00:00')));
60 | $this->assertEquals(new \DateTime('2012-12-13 00:00:00'), $t->getFireTimeAfter(new \DateTime('2012-12-12 23:59:55')));
61 | }
62 |
63 | public function testOnFireTimeAfterShouldReturnNullIfTimesTriggeredMoreThanRepeatCount()
64 | {
65 | $t = new SimpleTrigger();
66 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
67 | $t->setRepeatInterval(10);
68 | $t->setTimesTriggered(5);
69 | $t->setRepeatCount(3);
70 |
71 | $this->assertNull($t->getFireTimeAfter());
72 | }
73 |
74 | public function testOnFireTimeAfterShouldReturnNullIfRepeatCountZeroAndAfterTimeAfterStartTime()
75 | {
76 | $t = new SimpleTrigger();
77 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
78 | $t->setRepeatInterval(10);
79 | $t->setRepeatCount(0);
80 |
81 | $this->assertNull($t->getFireTimeAfter(new \DateTime('2012-12-12 13:00:00')));
82 | }
83 |
84 | public function testOnFireTimeAfterShouldReturnStartTimeIfAfterTimeBeforeStartTime()
85 | {
86 | $t = new SimpleTrigger();
87 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
88 | $t->setRepeatInterval(10);
89 | $t->setRepeatCount(0);
90 |
91 | $this->assertEquals(new \DateTime('2012-12-12 12:00:00'), $t->getFireTimeAfter(new \DateTime('2012-12-12 11:00:00')));
92 | }
93 |
94 | public function testOnFireTimeAfterShouldReturnNullIfNumTimesExecutedIsMoreThanRepeatCount()
95 | {
96 | $t = new SimpleTrigger();
97 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
98 | $t->setRepeatInterval(10);
99 | $t->setRepeatCount(2);
100 |
101 | $this->assertNull($t->getFireTimeAfter(new \DateTime('2012-12-12 12:00:21')));
102 | }
103 |
104 | public function testOnFireTimeAfterShouldReturnNullIfCalculatedTimeIsAfterEndTime()
105 | {
106 | $t = new SimpleTrigger();
107 | $t->setStartTime(new \DateTime('2012-12-12 12:00:00'));
108 | $t->setEndTime(new \DateTime('2012-12-12 13:00:00'));
109 | $t->setRepeatInterval(10);
110 | $t->setRepeatCount(SimpleTrigger::REPEAT_INDEFINITELY);
111 |
112 | $this->assertNull($t->getFireTimeAfter(new \DateTime('2012-12-12 12:59:55')));
113 | }
114 |
115 | public function testShouldUpdateAfterMisfireWithFireNowInstruction()
116 | {
117 | $t = new SimpleTrigger();
118 | $t->setRepeatCount(0);
119 | $t->setMisfireInstruction(SimpleTrigger::MISFIRE_INSTRUCTION_FIRE_NOW);
120 |
121 | $this->assertNull($t->getNextFireTime());
122 |
123 | $t->updateAfterMisfire();
124 |
125 | $this->assertEquals(new \DateTime(), $t->getNextFireTime(), '', 5); // closer to now
126 | $this->assertSame(0, $t->getRepeatCount());
127 | }
128 | }
129 |
--------------------------------------------------------------------------------
/pkg/bridge/Tests/Scheduler/JobRunShellProcessorTest.php:
--------------------------------------------------------------------------------
1 | createJobStore(), $this->createJobRunShell());
22 |
23 | $this->assertInstanceOf(Processor::class, $processor);
24 | }
25 |
26 | public function testShouldImplementCommandSubscriberInterfaceAndReturnExpectectedSubscribedCommand()
27 | {
28 | $processor = new JobRunShellProcessor($this->createJobStore(), $this->createJobRunShell());
29 |
30 | $this->assertInstanceOf(CommandSubscriberInterface::class, $processor);
31 |
32 | $expectedConfig = [
33 | 'command' => 'quartz_job_run_shell',
34 | 'queue' => 'quartz_job_run_shell',
35 | 'prefix_queue' => false,
36 | 'exclusive' => true,
37 | ];
38 |
39 | $this->assertSame($expectedConfig, JobRunShellProcessor::getSubscribedCommand());
40 | }
41 |
42 | public function testShouldImplementQueueSubscriberInterfaceAndReturnExpectectedSubscribedCommand()
43 | {
44 | $processor = new JobRunShellProcessor($this->createJobStore(), $this->createJobRunShell());
45 |
46 | $this->assertInstanceOf(QueueSubscriberInterface::class, $processor);
47 |
48 | $this->assertSame(['quartz_job_run_shell'], JobRunShellProcessor::getSubscribedQueues());
49 | }
50 |
51 | public function testShouldRejectMessageIfJobInstanceIdIsNotSet()
52 | {
53 | $store = $this->createJobStore();
54 | $store
55 | ->expects($this->never())
56 | ->method('retrieveFireTrigger')
57 | ;
58 |
59 | $shell = $this->createJobRunShell();
60 | $shell
61 | ->expects($this->never())
62 | ->method('execute')
63 | ;
64 |
65 | $processor = new JobRunShellProcessor($store, $shell);
66 |
67 | $result = $processor->process(new NullMessage(), $this->createMock(Context::class));
68 |
69 | $this->assertInstanceOf(Result::class, $result);
70 | $this->assertSame('fire instance id is empty', $result->getReason());
71 | }
72 |
73 | public function testShouldRejectMessageIfJobInstanceWasNotFound()
74 | {
75 | $store = $this->createJobStore();
76 | $store
77 | ->expects($this->once())
78 | ->method('retrieveFireTrigger')
79 | ;
80 |
81 | $shell = $this->createJobRunShell();
82 | $shell
83 | ->expects($this->never())
84 | ->method('execute')
85 | ;
86 |
87 | $processor = new JobRunShellProcessor($store, $shell);
88 |
89 | $message = new NullMessage();
90 | $message->setBody(JSON::encode([
91 | 'fireInstanceId' => '1234',
92 | ]));
93 |
94 | $result = $processor->process($message, $this->createMock(Context::class));
95 |
96 | $this->assertInstanceOf(Result::class, $result);
97 | $this->assertSame('There is not trigger with fire instance id: "1234"', $result->getReason());
98 | }
99 |
100 | public function testShouldPassTriggerToJobRunShell()
101 | {
102 | $trigger = new SimpleTrigger();
103 |
104 | $store = $this->createJobStore();
105 | $store
106 | ->expects($this->once())
107 | ->method('retrieveFireTrigger')
108 | ->willReturn($trigger)
109 | ;
110 |
111 | $shell = $this->createJobRunShell();
112 | $shell
113 | ->expects($this->once())
114 | ->method('execute')
115 | ->with($trigger)
116 | ;
117 |
118 | $processor = new JobRunShellProcessor($store, $shell);
119 |
120 | $message = new NullMessage();
121 | $message->setBody(JSON::encode([
122 | 'fireInstanceId' => '1234',
123 | ]));
124 |
125 | $result = $processor->process($message, $this->createMock(Context::class));
126 |
127 | $this->assertInstanceOf(Result::class, $result);
128 | $this->assertSame(Result::ACK, $result->getStatus());
129 | }
130 |
131 | /**
132 | * @return \PHPUnit_Framework_MockObject_MockObject|YadmStore
133 | */
134 | private function createJobStore()
135 | {
136 | return $this->createMock(YadmStore::class);
137 | }
138 |
139 | /**
140 | * @return \PHPUnit_Framework_MockObject_MockObject|StdJobRunShell
141 | */
142 | private function createJobRunShell()
143 | {
144 | return $this->createMock(StdJobRunShell::class);
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/pkg/bridge/Scheduler/RpcProtocol.php:
--------------------------------------------------------------------------------
1 | encodeValue($arg);
16 | }
17 |
18 | return [
19 | 'method' => $method,
20 | 'args' => $encodedArgs,
21 | ];
22 | }
23 |
24 | public function decodeRequest($data)
25 | {
26 | if (false == isset($data['method'])) {
27 | throw new \InvalidArgumentException('Method property is not set');
28 | }
29 |
30 | if (false == isset($data['args'])) {
31 | throw new \InvalidArgumentException('Args property is not set');
32 | }
33 |
34 | return [
35 | 'method' => $data['method'],
36 | 'args' => $this->decodeValue($data['args']),
37 | ];
38 | }
39 |
40 | public function encodeValue($data)
41 | {
42 | if (is_scalar($data) || is_null($data)) {
43 | return $data;
44 | } elseif (is_object($data)) {
45 | if ($data instanceof Model) {
46 | return [
47 | '__values__' => get_values($data),
48 | ];
49 | } elseif ($data instanceof \Exception) {
50 | return [
51 | '__exception__' => [
52 | 'class' => get_class($data),
53 | 'message' => $data->getMessage(),
54 | 'code' => $data->getCode(),
55 | ]
56 | ];
57 | } elseif ($data instanceof \DateTime) {
58 | return [
59 | '__datetime__' => [
60 | 'iso' => $data->format(DATE_ISO8601),
61 | 'unix' => $data->format('U'),
62 | 'tz' => $data->getTimezone()->getName(),
63 | ]
64 | ];
65 | }
66 |
67 | throw new \InvalidArgumentException('Object arguments are not allowed');
68 | } elseif (is_array($data)) {
69 | $result = [];
70 |
71 | foreach ($data as $key => $value) {
72 | $result[$key] = $this->encodeValue($value);
73 | }
74 |
75 | return $result;
76 | } else {
77 | throw new \InvalidArgumentException('Invalid argument');
78 | }
79 | }
80 |
81 | public function decodeValue($data)
82 | {
83 | if (is_scalar($data) || is_null($data)) {
84 | return $data;
85 | } elseif (is_array($data)) {
86 | // values object
87 | if (isset($data['__values__'])) {
88 | $class = ModelClassFactory::getClass($data['__values__']);
89 | $rc = new \ReflectionClass($class);
90 | $object = $rc->newInstanceWithoutConstructor();
91 | set_values($object, $data['__values__']);
92 |
93 | return $object;
94 | }
95 |
96 | // datetime
97 | if (isset($data['__datetime__'])) {
98 | $time = new \DateTime('@'.$data['__datetime__']['unix']);
99 | $time->setTimezone(new \DateTimeZone($data['__datetime__']['tz']));
100 |
101 | return $time;
102 | }
103 |
104 | // exception
105 | if (isset($data['__exception__'])) {
106 | return $this->decodeException($data['__exception__']);
107 | }
108 |
109 | // just an array
110 | $result = [];
111 | foreach ($data as $key => $value) {
112 | $decValue = $this->decodeValue($value);
113 | // only top level exception is allowed
114 |
115 | if ($decValue instanceof \Exception) {
116 | throw new \InvalidArgumentException('Only top level exception is allowed');
117 | }
118 |
119 | $result[$key] = $decValue;
120 | }
121 |
122 | return $result;
123 | } else {
124 | throw new \InvalidArgumentException('Unexpected value');
125 | }
126 | }
127 |
128 | private function decodeException(array $data)
129 | {
130 | if (false == isset($data['class'])) {
131 | throw new \InvalidArgumentException('Exception class property is not set');
132 | }
133 |
134 | if (false == isset($data['message'])) {
135 | throw new \InvalidArgumentException('Exception message property is not set');
136 | }
137 |
138 | if (false == isset($data['code'])) {
139 | throw new \InvalidArgumentException('Exception code property is not set');
140 | }
141 |
142 | if (class_exists($data['class'])) {
143 | return new $data['class']($data['message'], $data['code']);
144 | } else {
145 | return new \Exception(json_encode($data));
146 | }
147 | }
148 | }
149 |
--------------------------------------------------------------------------------
/pkg/quartz/Tests/Core/DateBuilderTest.php:
--------------------------------------------------------------------------------
1 | format('Y');
13 |
14 | $this->assertSame($year+100, DateBuilder::MAX_YEAR());
15 | }
16 |
17 | public function testOnValidateDayOfWeekShouldThrowExceptionIfInvalidValue()
18 | {
19 | $this->expectException(\InvalidArgumentException::class);
20 | $this->expectExceptionMessage('Invalid day of week: "100"');
21 |
22 | DateBuilder::validateDayOfWeek(100);
23 | }
24 |
25 | public function testOnValidateDayOfWeekShouldNotThrowExceptionIfValidValue()
26 | {
27 | DateBuilder::validateDayOfWeek(DateBuilder::MONDAY);
28 | DateBuilder::validateDayOfWeek(DateBuilder::THURSDAY);
29 | DateBuilder::validateDayOfWeek(DateBuilder::WEDNESDAY);
30 | DateBuilder::validateDayOfWeek(DateBuilder::THURSDAY);
31 | DateBuilder::validateDayOfWeek(DateBuilder::FRIDAY);
32 | DateBuilder::validateDayOfWeek(DateBuilder::SATURDAY);
33 | DateBuilder::validateDayOfWeek(DateBuilder::SUNDAY);
34 | }
35 |
36 | public function testOnValidateHourShouldThrowExceptionIfInvalidValue()
37 | {
38 | $this->expectException(\InvalidArgumentException::class);
39 | $this->expectExceptionMessage('Invalid hour (must be >= 0 and <= 23).');
40 |
41 | DateBuilder::validateHour(24);
42 | }
43 |
44 | public function testOnValidateHourShouldNotThrowExceptionIfValidValue()
45 | {
46 | DateBuilder::validateHour(0);
47 | DateBuilder::validateHour(23);
48 | }
49 |
50 | public function testOnValidateMinuteShouldThrowExceptionIfInvalidValue()
51 | {
52 | $this->expectException(\InvalidArgumentException::class);
53 | $this->expectExceptionMessage('Invalid minute (must be >= 0 and <= 59).');
54 |
55 | DateBuilder::validateMinute(60);
56 | }
57 |
58 | public function testOnValidateMinuteShouldNotThrowExceptionIfValidValue()
59 | {
60 | DateBuilder::validateMinute(0);
61 | DateBuilder::validateMinute(59);
62 | }
63 |
64 | public function testOnValidateSecondShouldThrowExceptionIfInvalidValue()
65 | {
66 | $this->expectException(\InvalidArgumentException::class);
67 | $this->expectExceptionMessage('Invalid second (must be >= 0 and <= 59).');
68 |
69 | DateBuilder::validateSecond(60);
70 | }
71 |
72 | public function testOnValidateSecondShouldNotThrowExceptionIfValidValue()
73 | {
74 | DateBuilder::validateSecond(0);
75 | DateBuilder::validateSecond(59);
76 | }
77 |
78 | public function testOnValidateDayOfMonthShouldThrowExceptionIfInvalidValue()
79 | {
80 | $this->expectException(\InvalidArgumentException::class);
81 | $this->expectExceptionMessage('Invalid day of month (must be >= 1 and <= 31).');
82 |
83 | DateBuilder::validateDayOfMonth(32);
84 | }
85 |
86 | public function testOnValidateDayOfMonthShouldNotThrowExceptionIfValidValue()
87 | {
88 | DateBuilder::validateDayOfMonth(1);
89 | DateBuilder::validateDayOfMonth(31);
90 | }
91 |
92 | public function testOnValidateMonthShouldThrowExceptionIfInvalidValue()
93 | {
94 | $this->expectException(\InvalidArgumentException::class);
95 | $this->expectExceptionMessage('Invalid month (must be >= 1 and <= 12.');
96 |
97 | DateBuilder::validateMonth(13);
98 | }
99 |
100 | public function testOnValidateMonthShouldNotThrowExceptionIfValidValue()
101 | {
102 | DateBuilder::validateMonth(1);
103 | DateBuilder::validateMonth(12);
104 | }
105 |
106 | public function testOnValidateYearShouldThrowExceptionIfInvalidValue()
107 | {
108 | $year = (int) (new \DateTime())->format('Y');
109 |
110 | $this->expectException(\InvalidArgumentException::class);
111 | $this->expectExceptionMessage(sprintf('Invalid year (must be >= 0 and <= %d', $year + 100));
112 |
113 | DateBuilder::validateYear($year + 200);
114 | }
115 |
116 | public function testOnValidateYearShouldNotThrowExceptionIfValidValue()
117 | {
118 | $year = (int) (new \DateTime())->format('Y');
119 |
120 | DateBuilder::validateYear(0);
121 | DateBuilder::validateYear($year + 100);
122 | }
123 |
124 | public function testOnValidateIntervalUnitShouldThrowExceptionIfInvalidValue()
125 | {
126 | $this->expectException(\InvalidArgumentException::class);
127 | $this->expectExceptionMessage('Invalid interval unit.');
128 |
129 | DateBuilder::validateIntervalUnit(100);
130 | }
131 |
132 | public function testOnValidateIntervalUnitShouldNotThrowExceptionIfValidValue()
133 | {
134 | DateBuilder::validateIntervalUnit(IntervalUnit::SECOND);
135 | DateBuilder::validateIntervalUnit(IntervalUnit::MINUTE);
136 | DateBuilder::validateIntervalUnit(IntervalUnit::HOUR);
137 | DateBuilder::validateIntervalUnit(IntervalUnit::DAY);
138 | DateBuilder::validateIntervalUnit(IntervalUnit::WEEK);
139 | DateBuilder::validateIntervalUnit(IntervalUnit::MONTH);
140 | DateBuilder::validateIntervalUnit(IntervalUnit::YEAR);
141 | }
142 | }
143 |
--------------------------------------------------------------------------------
/pkg/quartz/Calendar/MonthlyCalendar.php:
--------------------------------------------------------------------------------
1 |
9 | * This implementation of the Calendar excludes a set of days of the month. You
10 | * may use it to exclude every first day of each month for example. But you may define
11 | * any day of a month.
12 | *
13 | */
14 | class MonthlyCalendar extends BaseCalendar
15 | {
16 | const INSTANCE = 'monthly';
17 |
18 | /**
19 | * {@inheritdoc}
20 | */
21 | public function __construct(Calendar $baseCalendar = null, \DateTimeZone $timeZone = null)
22 | {
23 | parent::__construct(self::INSTANCE, $baseCalendar, $timeZone);
24 | }
25 |
26 | /**
27 | *
28 | * Get the array which defines the exclude-value of each day of month.
29 | * Only the first 31 elements of the array are relevant, with the 1 index
30 | * element representing the first day of the month.
31 | *
32 | */
33 | public function getDaysExcluded()
34 | {
35 | return $this->getValue('excludeDays', []);
36 | }
37 |
38 | /**
39 | *
40 | * Return true, if day is defined to be excluded.
41 | *
42 | *
43 | * @param int $day The day of the month (from 1 to 31) to check.
44 | *
45 | * @return bool
46 | */
47 | public function isDayExcluded($day)
48 | {
49 | DateBuilder::validateDayOfMonth($day);
50 |
51 | $days = $this->getValue('excludeDays', []);
52 |
53 | return in_array($day, $days, true);
54 | }
55 |
56 | /**
57 | *
58 | * Redefine the array of days excluded. The array must non-null and of size
59 | * greater or equal to 31. The 1 index element represents the first day of
60 | * the month.
61 | *
62 | *
63 | * @param array $days
64 | */
65 | public function setDaysExcluded(array $days)
66 | {
67 | foreach ($days as $day) {
68 | DateBuilder::validateDayOfMonth($day);
69 | }
70 |
71 | $this->setValue('excludeDays', $days);
72 | }
73 |
74 | /**
75 | *
76 | * Redefine a certain day of the month to be excluded (true) or included
77 | * (false).
78 | *
79 | *
80 | * @param int $day The day of the month (from 1 to 31) to set.
81 | * @param bool $exclude
82 | */
83 | public function setDayExcluded($day, $exclude)
84 | {
85 | DateBuilder::validateDayOfMonth($day);
86 |
87 | $days = $this->getValue('excludeDays', []);
88 |
89 | if ($exclude) {
90 | if (false === array_search($day, $days, true)) {
91 | $days[] = $day;
92 | sort($days, SORT_NUMERIC);
93 | }
94 | } else {
95 | if (false !== $index = array_search($day, $days, true)) {
96 | unset($days[$index]);
97 | $days = array_values($days);
98 | }
99 | }
100 |
101 | $this->setValue('excludeDays', $days);
102 | }
103 |
104 | /**
105 | *
106 | * Determine whether the given time (in milliseconds) is 'included' by the
107 | * Calendar.
108 | *
109 | *
110 | *
111 | * Note that this Calendar is only has full-day precision.
112 | *
113 | *
114 | * @param $timeStamp
115 | *
116 | * @return bool
117 | */
118 | public function isTimeIncluded($timeStamp)
119 | {
120 | // Test the base calendar first. Only if the base calendar not already
121 | // excludes the time/date, continue evaluating this calendar instance.
122 | if (false == parent::isTimeIncluded($timeStamp)) {
123 | return false;
124 | }
125 |
126 | $date = $this->createDateTime($timeStamp);
127 | $day = (int) $date->format('j');
128 |
129 | return false == $this->isDayExcluded($day);
130 | }
131 |
132 | /**
133 | *
134 | * Check if all days are excluded. That is no day is included.
135 | *
136 | */
137 | public function areAllDaysExcluded()
138 | {
139 | return count($this->getValue('excludeDays', [])) >= 31;
140 | }
141 |
142 | /**
143 | *
144 | * Determine the next time (in milliseconds) that is 'included' by the
145 | * Calendar after the given time. Return the original value if timeStamp is
146 | * included. Return 0 if all days are excluded.
147 | *
148 | *
149 | *
150 | * Note that this Calendar is only has full-day precision.
151 | *
152 | *
153 | * @param int $timeStamp
154 | *
155 | * @return int
156 | */
157 | public function getNextIncludedTime($timeStamp)
158 | {
159 | if ($this->areAllDaysExcluded()) {
160 | return 0;
161 | }
162 |
163 | $baseTime = parent::getNextIncludedTime($timeStamp);
164 | if ($baseTime > 0 && $baseTime > $timeStamp) {
165 | $timeStamp = $baseTime;
166 | }
167 |
168 | // Get timestamp for 00:00:00
169 | $date = $this->getStartOfDayDateTime($timeStamp);
170 | $day = (int) $date->format('j');
171 |
172 | if (false == $this->isDayExcluded($day)) {
173 | return $timeStamp; // return the original value
174 | }
175 |
176 | while ($this->isDayExcluded($day)) {
177 | $date->add(new \DateInterval('P1D'));
178 | $day = (int) $date->format('j');
179 | }
180 |
181 | return (int) $date->format('U');
182 | }
183 | }
184 |
--------------------------------------------------------------------------------