9935584685

Committed 15 Jul 2024 07:44AM UTC coverage: 47.259% (-18.3%) from 65.524%

Build Type

push

github

Committed by darkdarin

Commit Message

fix: tests

Run Details

4 of 4 new or added lines in 2 files covered. (100.0%)

431 existing lines in 40 files now uncovered.

612 of 1295 relevant lines covered (47.26%)

2.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/PromiseServiceProvider.php

<?php

namespace Tochka\Promises;

use Illuminate\Contracts\Container\Container;
use Illuminate\Queue\Events\JobFailed;
use Illuminate\Queue\Events\JobProcessed;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Bus;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\ServiceProvider;
use Tochka\Promises\Commands\PromiseClean;
use Tochka\Promises\Commands\PromiseGc;
use Tochka\Promises\Commands\PromiseMakeMigration;
use Tochka\Promises\Commands\PromiseWatch;
use Tochka\Promises\Contracts\MayPromised;
use Tochka\Promises\Contracts\PromisedEvent;
use Tochka\Promises\Core\Dispatchers\PromiseDispatcher;
use Tochka\Promises\Core\Dispatchers\QueueJobDispatcher;
use Tochka\Promises\Core\Dispatchers\WaitEventDispatcher;
use Tochka\Promises\Core\GarbageCollector;
use Tochka\Promises\Core\GarbageCollectorInterface;
use Tochka\Promises\Core\PromiseRunner;
use Tochka\Promises\Core\PromiseRunnerInterface;
use Tochka\Promises\Core\PromiseWatcher;
use Tochka\Promises\Core\PromiseWatcherInterface;
use Tochka\Promises\Core\Support\BaseJobDispatcher;
use Tochka\Promises\Core\Support\BaseJobDispatcherInterface;
use Tochka\Promises\Core\Support\ConditionTransitionHandler;
use Tochka\Promises\Core\Support\ConditionTransitionHandlerInterface;
use Tochka\Promises\Core\Support\EventDispatcher;
use Tochka\Promises\Core\Support\EventDispatcherInterface;
use Tochka\Promises\Core\Support\QueuePromiseMiddleware;
use Tochka\Promises\Enums\StateEnum;
use Tochka\Promises\Events\PromiseJobStateChanged;
use Tochka\Promises\Events\PromiseStateChanged;
use Tochka\Promises\Events\StateChanged;
use Tochka\Promises\Listeners\CheckStateConditions;
use Tochka\Promises\Listeners\DeletePromisedEvent;
use Tochka\Promises\Listeners\DispatchPromise;
use Tochka\Promises\Listeners\DispatchPromiseJob;
use Tochka\Promises\Listeners\LogStateChanged;
use Tochka\Promises\Models\Observers\PromiseAfterCommitObserver;
use Tochka\Promises\Models\Observers\PromiseBeforeCommitObserver;
use Tochka\Promises\Models\Observers\PromiseJobAfterCommitObserver;
use Tochka\Promises\Models\Observers\PromiseJobBeforeCommitObserver;
use Tochka\Promises\Models\Promise;
use Tochka\Promises\Models\PromiseJob;
use Tochka\Promises\Registry\PromiseEventRegistry;
use Tochka\Promises\Registry\PromiseEventRegistryInterface;
use Tochka\Promises\Registry\PromiseJobRegistry;
use Tochka\Promises\Registry\PromiseJobRegistryInterface;
use Tochka\Promises\Registry\PromiseRegistry;
use Tochka\Promises\Registry\PromiseRegistryInterface;

/**
 * @api
 */
class PromiseServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        if ($this->app->runningInConsole()) {
            $this->commands(
                [
                    PromiseWatch::class,
                    PromiseGc::class,
                    PromiseClean::class,
                    PromiseMakeMigration::class,
                ],
            );

            // публикуем конфигурации
            $this->publishes(
                [__DIR__ . '/../config/promises.php' => $this->app->basePath() . '/config/promises.php'],
                'promises-config',
            );
        }

        Bus::pipeThrough([QueuePromiseMiddleware::class]);

        Queue::createPayloadUsing(
            /** @psalm-suppress MissingClosureParamType */
            static function ($connection, $queue, $payload) {
                $job = $payload['data']['command'] ?? $payload['job'] ?? null;

                if ($job instanceof MayPromised && $job->getBaseJobId() !== null) {
                    return [
                        'promised' => true,
                        'base_job_id' => $job->getBaseJobId(),
                    ];
                }

                return [];
            },
        );

        Queue::failing(
            static function (JobFailed $event) {
                $baseJobId = $event->job->payload()['base_job_id'] ?? null;
                if ($baseJobId === null) {
                    return;
                }

                $job = PromiseJob::find($baseJobId);
                if ($job === null) {
                    return;
                }
                $baseJob = $job->getBaseJob();

                if ($baseJob->getState()->in([StateEnum::WAITING(), StateEnum::RUNNING()])) {
                    $baseJob->setException($event->exception);
                    $baseJob->setState(StateEnum::FAILED());
                    PromiseJob::saveBaseJob($baseJob);
                }
            },
        );

        Queue::after(
            static function (JobProcessed $event) {
                $baseJobId = $event->job->payload()['base_job_id'] ?? null;

                if ($baseJobId === null || $event->job->isReleased()) {
                    return;
                }

                $state = StateEnum::SUCCESS();
                if ($event->job->hasFailed()) {
                    $state = StateEnum::FAILED();
                }

                $job = PromiseJob::find($baseJobId);
                if ($job === null) {
                    return;
                }

                $baseJob = $job->getBaseJob();

                if ($baseJob->getState()->in([StateEnum::WAITING(), StateEnum::RUNNING()])) {
                    $baseJob->setState($state);
                    PromiseJob::saveBaseJob($baseJob);
                }
            },
        );

        Promise::observe(PromiseBeforeCommitObserver::class);
        Promise::observe(PromiseAfterCommitObserver::class);
        PromiseJob::observe(PromiseJobBeforeCommitObserver::class);
        PromiseJob::observe(PromiseJobAfterCommitObserver::class);

        Event::listen(
            PromisedEvent::class,
            static function (PromisedEvent $event) {
                /** @var EventDispatcherInterface $eventDispatcher */
                $eventDispatcher = App::make(EventDispatcherInterface::class);
                $eventDispatcher->dispatch($event);
            },
        );

        Event::listen(StateChanged::class, LogStateChanged::class);

        $watchUpdates = Config::get('promises.fire_updates', false);
        if ($watchUpdates) {
            Event::listen(PromiseStateChanged::class, CheckStateConditions::class);
            Event::listen(PromiseJobStateChanged::class, CheckStateConditions::class);
        }

        Event::listen(PromiseStateChanged::class, DispatchPromise::class);
        Event::listen(PromiseJobStateChanged::class, DispatchPromiseJob::class);
        Event::listen(PromiseJobStateChanged::class, DeletePromisedEvent::class);
    }

    public function register(): void
    {
        if (Config::get('promises.fire_updates', false)) {
            $this->app->instance(
                'watcher_watch_timeout',
                Config::get('promises.watcher_watch_timeout', 60 * 10),
            );
        } else {
            $this->app->instance('watcher_watch_timeout', 0);
        }

        $this->app->singleton(
            BaseJobDispatcherInterface::class,
            static function (): BaseJobDispatcherInterface {
                $dispatcher = new BaseJobDispatcher();
                $dispatcher->addDispatcher(new WaitEventDispatcher());
                $dispatcher->addDispatcher(new QueueJobDispatcher());
                $dispatcher->addDispatcher(new PromiseDispatcher());

                return $dispatcher;
            },
        );

        $this->app->singleton(EventDispatcherInterface::class, EventDispatcher::class);
        $this->app->singleton(PromiseRunnerInterface::class, PromiseRunner::class);
        $this->app->singleton(ConditionTransitionHandlerInterface::class, ConditionTransitionHandler::class);
        $this->app->singleton(PromiseEventRegistryInterface::class, PromiseEventRegistry::class);
        $this->app->singleton(PromiseJobRegistryInterface::class, PromiseJobRegistry::class);
        $this->app->singleton(PromiseRegistryInterface::class, PromiseRegistry::class);

        $this->app->singleton(
            PromiseWatcherInterface::class,
            static function (Container $container): PromiseWatcherInterface {
                return $container->make(PromiseWatcher::class, [
                    'sleepTime' => Config::get('promises.watcher_sleep', 60 * 10),
                    'promisesTable' => Config::get('promises.database.table_promises', 'promises'),
                    'promiseJobsTable' => Config::get('promises.database.table_jobs', 'promise_jobs'),
                    'promiseChunkSize' => Config::get('promises.garbage_collector.promise_chunk_size', 100),
                ]);
            },
        );

        $this->app->singleton(
            GarbageCollectorInterface::class,
            static function (): GarbageCollectorInterface {
                $sleepTime = Config::get('promises.garbage_collector.timeout', 60 * 10);
                $deleteOlderThen = Config::get('promises.garbage_collector.older_then', 60 * 60 * 24 * 7);
                $states = Config::get('promises.garbage_collector.states', []);
                $promisesTable = Config::get('promises.database.table_promises', 'promises');
                $promiseJobsTable = Config::get('promises.database.table_jobs', 'promise_jobs');
                $promiseEventsTable = Config::get('promises.database.table_events', 'promise_events');
                $promiseChunkSize = Config::get('promises.garbage_collector.promise_chunk_size', 100);
                $jobsChunkSize = Config::get('promises.garbage_collector.jobs_chunk_size', 500);

                return new GarbageCollector(
                    $sleepTime,
                    $deleteOlderThen,
                    $states,
                    $promisesTable,
                    $promiseJobsTable,
                    $promiseEventsTable,
                    $promiseChunkSize,
                    $jobsChunkSize,
                );
            },
        );
    }
}

1	<?php
2
3	namespace Tochka\Promises;
4
5	use Illuminate\Contracts\Container\Container;
6	use Illuminate\Queue\Events\JobFailed;
7	use Illuminate\Queue\Events\JobProcessed;
8	use Illuminate\Support\Facades\App;
9	use Illuminate\Support\Facades\Bus;
10	use Illuminate\Support\Facades\Config;
11	use Illuminate\Support\Facades\Event;
12	use Illuminate\Support\Facades\Queue;
13	use Illuminate\Support\ServiceProvider;
14	use Tochka\Promises\Commands\PromiseClean;
15	use Tochka\Promises\Commands\PromiseGc;
16	use Tochka\Promises\Commands\PromiseMakeMigration;
17	use Tochka\Promises\Commands\PromiseWatch;
18	use Tochka\Promises\Contracts\MayPromised;
19	use Tochka\Promises\Contracts\PromisedEvent;
20	use Tochka\Promises\Core\Dispatchers\PromiseDispatcher;
21	use Tochka\Promises\Core\Dispatchers\QueueJobDispatcher;
22	use Tochka\Promises\Core\Dispatchers\WaitEventDispatcher;
23	use Tochka\Promises\Core\GarbageCollector;
24	use Tochka\Promises\Core\GarbageCollectorInterface;
25	use Tochka\Promises\Core\PromiseRunner;
26	use Tochka\Promises\Core\PromiseRunnerInterface;
27	use Tochka\Promises\Core\PromiseWatcher;
28	use Tochka\Promises\Core\PromiseWatcherInterface;
29	use Tochka\Promises\Core\Support\BaseJobDispatcher;
30	use Tochka\Promises\Core\Support\BaseJobDispatcherInterface;
31	use Tochka\Promises\Core\Support\ConditionTransitionHandler;
32	use Tochka\Promises\Core\Support\ConditionTransitionHandlerInterface;
33	use Tochka\Promises\Core\Support\EventDispatcher;
34	use Tochka\Promises\Core\Support\EventDispatcherInterface;
35	use Tochka\Promises\Core\Support\QueuePromiseMiddleware;
36	use Tochka\Promises\Enums\StateEnum;
37	use Tochka\Promises\Events\PromiseJobStateChanged;
38	use Tochka\Promises\Events\PromiseStateChanged;
39	use Tochka\Promises\Events\StateChanged;
40	use Tochka\Promises\Listeners\CheckStateConditions;
41	use Tochka\Promises\Listeners\DeletePromisedEvent;
42	use Tochka\Promises\Listeners\DispatchPromise;
43	use Tochka\Promises\Listeners\DispatchPromiseJob;
44	use Tochka\Promises\Listeners\LogStateChanged;
45	use Tochka\Promises\Models\Observers\PromiseAfterCommitObserver;
46	use Tochka\Promises\Models\Observers\PromiseBeforeCommitObserver;
47	use Tochka\Promises\Models\Observers\PromiseJobAfterCommitObserver;
48	use Tochka\Promises\Models\Observers\PromiseJobBeforeCommitObserver;
49	use Tochka\Promises\Models\Promise;
50	use Tochka\Promises\Models\PromiseJob;
51	use Tochka\Promises\Registry\PromiseEventRegistry;
52	use Tochka\Promises\Registry\PromiseEventRegistryInterface;
53	use Tochka\Promises\Registry\PromiseJobRegistry;
54	use Tochka\Promises\Registry\PromiseJobRegistryInterface;
55	use Tochka\Promises\Registry\PromiseRegistry;
56	use Tochka\Promises\Registry\PromiseRegistryInterface;
57
58	/**
59	* @api
60	*/
61	class PromiseServiceProvider extends ServiceProvider
62	{
63	public function boot(): void
64	{
UNCOV 65	if ($this->app->runningInConsole()) {	×
UNCOV 66	$this->commands(	×
UNCOV 67	[	×
UNCOV 68	PromiseWatch::class,	×
UNCOV 69	PromiseGc::class,	×
UNCOV 70	PromiseClean::class,	×
UNCOV 71	PromiseMakeMigration::class,	×
UNCOV 72	],	×
UNCOV 73	);	×
74
75	// публикуем конфигурации
UNCOV 76	$this->publishes(	×
UNCOV 77	[__DIR__ . '/../config/promises.php' => $this->app->basePath() . '/config/promises.php'],	×
UNCOV 78	'promises-config',	×
UNCOV 79	);	×
80	}
81
UNCOV 82	Bus::pipeThrough([QueuePromiseMiddleware::class]);	×
83
UNCOV 84	Queue::createPayloadUsing(	×
85	/** @psalm-suppress MissingClosureParamType */
UNCOV 86	static function ($connection, $queue, $payload) {	×
UNCOV 87	$job = $payload['data']['command'] ?? $payload['job'] ?? null;	×
88
UNCOV 89	if ($job instanceof MayPromised && $job->getBaseJobId() !== null) {	×
UNCOV 90	return [	×
UNCOV 91	'promised' => true,	×
UNCOV 92	'base_job_id' => $job->getBaseJobId(),	×
UNCOV 93	];	×
94	}
95
UNCOV 96	return [];	×
UNCOV 97	},	×
UNCOV 98	);	×
99
UNCOV 100	Queue::failing(	×
UNCOV 101	static function (JobFailed $event) {	×
UNCOV 102	$baseJobId = $event->job->payload()['base_job_id'] ?? null;	×
UNCOV 103	if ($baseJobId === null) {	×
UNCOV 104	return;	×
105	}
106
UNCOV 107	$job = PromiseJob::find($baseJobId);	×
UNCOV 108	if ($job === null) {	×
UNCOV 109	return;	×
110	}
UNCOV 111	$baseJob = $job->getBaseJob();	×
112
UNCOV 113	if ($baseJob->getState()->in([StateEnum::WAITING(), StateEnum::RUNNING()])) {	×
UNCOV 114	$baseJob->setException($event->exception);	×
UNCOV 115	$baseJob->setState(StateEnum::FAILED());	×
UNCOV 116	PromiseJob::saveBaseJob($baseJob);	×
117	}
UNCOV 118	},	×
UNCOV 119	);	×
120
UNCOV 121	Queue::after(	×
UNCOV 122	static function (JobProcessed $event) {	×
UNCOV 123	$baseJobId = $event->job->payload()['base_job_id'] ?? null;	×
124
UNCOV 125	if ($baseJobId === null \|\| $event->job->isReleased()) {	×
UNCOV 126	return;	×
127	}
128
UNCOV 129	$state = StateEnum::SUCCESS();	×
UNCOV 130	if ($event->job->hasFailed()) {	×
UNCOV 131	$state = StateEnum::FAILED();	×
132	}
133
UNCOV 134	$job = PromiseJob::find($baseJobId);	×
UNCOV 135	if ($job === null) {	×
UNCOV 136	return;	×
137	}
138
UNCOV 139	$baseJob = $job->getBaseJob();	×
140
UNCOV 141	if ($baseJob->getState()->in([StateEnum::WAITING(), StateEnum::RUNNING()])) {	×
UNCOV 142	$baseJob->setState($state);	×
UNCOV 143	PromiseJob::saveBaseJob($baseJob);	×
144	}
UNCOV 145	},	×
UNCOV 146	);	×
147
UNCOV 148	Promise::observe(PromiseBeforeCommitObserver::class);	×
UNCOV 149	Promise::observe(PromiseAfterCommitObserver::class);	×
UNCOV 150	PromiseJob::observe(PromiseJobBeforeCommitObserver::class);	×
UNCOV 151	PromiseJob::observe(PromiseJobAfterCommitObserver::class);	×
152
UNCOV 153	Event::listen(	×
UNCOV 154	PromisedEvent::class,	×
UNCOV 155	static function (PromisedEvent $event) {	×
156	/** @var EventDispatcherInterface $eventDispatcher */
UNCOV 157	$eventDispatcher = App::make(EventDispatcherInterface::class);	×
UNCOV 158	$eventDispatcher->dispatch($event);	×
UNCOV 159	},	×
UNCOV 160	);	×
161
UNCOV 162	Event::listen(StateChanged::class, LogStateChanged::class);	×
163
UNCOV 164	$watchUpdates = Config::get('promises.fire_updates', false);	×
UNCOV 165	if ($watchUpdates) {	×
UNCOV 166	Event::listen(PromiseStateChanged::class, CheckStateConditions::class);	×
UNCOV 167	Event::listen(PromiseJobStateChanged::class, CheckStateConditions::class);	×
168	}
169
UNCOV 170	Event::listen(PromiseStateChanged::class, DispatchPromise::class);	×
UNCOV 171	Event::listen(PromiseJobStateChanged::class, DispatchPromiseJob::class);	×
UNCOV 172	Event::listen(PromiseJobStateChanged::class, DeletePromisedEvent::class);	×
173	}
174
175	public function register(): void
176	{
UNCOV 177	if (Config::get('promises.fire_updates', false)) {	×
UNCOV 178	$this->app->instance(	×
UNCOV 179	'watcher_watch_timeout',	×
UNCOV 180	Config::get('promises.watcher_watch_timeout', 60 * 10),	×
UNCOV 181	);	×
182	} else {
UNCOV 183	$this->app->instance('watcher_watch_timeout', 0);	×
184	}
185
UNCOV 186	$this->app->singleton(	×
UNCOV 187	BaseJobDispatcherInterface::class,	×
UNCOV 188	static function (): BaseJobDispatcherInterface {	×
UNCOV 189	$dispatcher = new BaseJobDispatcher();	×
UNCOV 190	$dispatcher->addDispatcher(new WaitEventDispatcher());	×
UNCOV 191	$dispatcher->addDispatcher(new QueueJobDispatcher());	×
UNCOV 192	$dispatcher->addDispatcher(new PromiseDispatcher());	×
193
UNCOV 194	return $dispatcher;	×
UNCOV 195	},	×
UNCOV 196	);	×
197
UNCOV 198	$this->app->singleton(EventDispatcherInterface::class, EventDispatcher::class);	×
UNCOV 199	$this->app->singleton(PromiseRunnerInterface::class, PromiseRunner::class);	×
UNCOV 200	$this->app->singleton(ConditionTransitionHandlerInterface::class, ConditionTransitionHandler::class);	×
UNCOV 201	$this->app->singleton(PromiseEventRegistryInterface::class, PromiseEventRegistry::class);	×
UNCOV 202	$this->app->singleton(PromiseJobRegistryInterface::class, PromiseJobRegistry::class);	×
UNCOV 203	$this->app->singleton(PromiseRegistryInterface::class, PromiseRegistry::class);	×
204
UNCOV 205	$this->app->singleton(	×
UNCOV 206	PromiseWatcherInterface::class,	×
UNCOV 207	static function (Container $container): PromiseWatcherInterface {	×
UNCOV 208	return $container->make(PromiseWatcher::class, [	×
UNCOV 209	'sleepTime' => Config::get('promises.watcher_sleep', 60 * 10),	×
UNCOV 210	'promisesTable' => Config::get('promises.database.table_promises', 'promises'),	×
UNCOV 211	'promiseJobsTable' => Config::get('promises.database.table_jobs', 'promise_jobs'),	×
UNCOV 212	'promiseChunkSize' => Config::get('promises.garbage_collector.promise_chunk_size', 100),	×
UNCOV 213	]);	×
UNCOV 214	},	×
UNCOV 215	);	×
216
UNCOV 217	$this->app->singleton(	×
UNCOV 218	GarbageCollectorInterface::class,	×
UNCOV 219	static function (): GarbageCollectorInterface {	×
UNCOV 220	$sleepTime = Config::get('promises.garbage_collector.timeout', 60 * 10);	×
UNCOV 221	$deleteOlderThen = Config::get('promises.garbage_collector.older_then', 60 * 60 * 24 * 7);	×
UNCOV 222	$states = Config::get('promises.garbage_collector.states', []);	×
UNCOV 223	$promisesTable = Config::get('promises.database.table_promises', 'promises');	×
UNCOV 224	$promiseJobsTable = Config::get('promises.database.table_jobs', 'promise_jobs');	×
UNCOV 225	$promiseEventsTable = Config::get('promises.database.table_events', 'promise_events');	×
UNCOV 226	$promiseChunkSize = Config::get('promises.garbage_collector.promise_chunk_size', 100);	×
UNCOV 227	$jobsChunkSize = Config::get('promises.garbage_collector.jobs_chunk_size', 500);	×
228
UNCOV 229	return new GarbageCollector(	×
UNCOV 230	$sleepTime,	×
UNCOV 231	$deleteOlderThen,	×
UNCOV 232	$states,	×
UNCOV 233	$promisesTable,	×
UNCOV 234	$promiseJobsTable,	×
UNCOV 235	$promiseEventsTable,	×
UNCOV 236	$promiseChunkSize,	×
UNCOV 237	$jobsChunkSize,	×
UNCOV 238	);	×
UNCOV 239	},	×
UNCOV 240	);	×
241	}
242	}

tochka-developers / queue-promises / 9935584685

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous