dispatch

laravel/framework

The dispatch function pushes the given job onto the Laravel job queue:

dispatch(new App\Jobs\SendEmails);

    public function dispatchNextJobInChain()

    {

        if (! empty($this->chained)) {

            dispatch(tap(unserialize(array_shift($this->chained)), function ($next) {

                $next->chained = $this->chained;

                $next->onConnection($next->connection ?: $this->chainConnection);

                $next->onQueue($next->queue ?: $this->chainQueue);

                $next->chainConnection = $this->chainConnection;

                $next->chainQueue = $this->chainQueue;

                $next->chainCatchCallbacks = $this->chainCatchCallbacks;

            }));

        }

    }

src/Illuminate/Bus/Queueable.php

    public function resolve()

    {

        return function (...$arguments) {

            dispatch(new CallQueuedListener(InvokeQueuedClosure::class, 'handle', [

                'closure' => new SerializableClosure($this->closure),

                'arguments' => $arguments,

                'catch' => collect($this->catchCallbacks)->map(function ($callback) {

                    return new SerializableClosure($callback);

                })->all(),

            ]))->onConnection($this->connection)->onQueue($this->queue)->delay($this->delay);

        };

    }

}

src/Illuminate/Events/QueuedClosure.php

    public function testJobsCanBeChainedOnSuccessUsingHelper()

    {

        dispatch(new JobChainingTestFirstJob)->chain([

            new JobChainingTestSecondJob,

        ]);

tests/Integration/Queue/JobChainingTest.php

    public function testLockIsReleasedForSuccessfulJobs()

    {

        UniqueTestJob::$handled = false;

        dispatch($job = new UniqueTestJob);

        $this->assertTrue($job::$handled);

        $this->assertTrue($this->app->get(Cache::class)->lock($this->getLockKey($job), 10)->get());

tests/Integration/Queue/UniqueJobTest.php

        $this->expectException(Exception::class);

        try {

            dispatch($job = new UniqueTestFailJob);

        } finally {

            $this->assertTrue($job::$handled);

            $this->assertTrue($this->app->get(Cache::class)->lock($this->getLockKey($job), 10)->get());

tests/Integration/Queue/UniqueJobTest.php

    {

        UniqueTestRetryJob::$handled = false;

        dispatch($job = new UniqueTestRetryJob);

        $this->assertFalse($this->app->get(Cache::class)->lock($this->getLockKey($job), 10)->get());

tests/Integration/Queue/UniqueJobTest.php

    public function testLockIsNotReleasedForJobReleases()

    {

        UniqueTestReleasedJob::$handled = false;

        dispatch($job = new UniqueTestReleasedJob);

        $this->assertFalse($this->app->get(Cache::class)->lock($this->getLockKey($job), 10)->get());

tests/Integration/Queue/UniqueJobTest.php

    {

        UniqueUntilStartTestJob::$handled = false;

        dispatch($job = new UniqueUntilStartTestJob);

        $this->assertFalse($this->app->get(Cache::class)->lock($this->getLockKey($job), 10)->get());

tests/Integration/Queue/UniqueJobTest.php

        $job = new TestJob1;

        dispatch($job);

        dispatch(new TestJob2);

        dispatch($job)->onQueue('Q2');

tests/Queue/QueueSizeTest.php

        $job = new TestJob1;

        dispatch($job);

        dispatch(new TestJob2);

        dispatch($job)->onQueue('Q2');

        $this->assertEquals(2, Queue::size());

tests/Queue/QueueSizeTest.php

        dispatch($job);

        dispatch(new TestJob2);

        dispatch($job)->onQueue('Q2');

        $this->assertEquals(2, Queue::size());

        $this->assertEquals(1, Queue::size('Q2'));

tests/Queue/QueueSizeTest.php