DEV Community: Wisdom Ebong

Execute an action after Laravel returns response

Wisdom Ebong — Thu, 13 Feb 2020 15:28:54 +0000

In this article, we want to explore the various ways we can execute small tasks or actions in laravel after a response is sent. You will see how these tasks are processed after the application responds to an incoming request.

Let’s take a peep at the entry point for all requests to a Laravel application, which is the public/index.php file. We’re only interested in the part where the request is handled through the kernel and a response is sent back to the client (e.g browser).

// public/index.php
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);

$response = $kernel->handle(
    $request = Illuminate\Http\Request::capture()
);

$response->send();

$kernel->terminate($request, $response);

An Http kernel instance is resolved from the laravel container and is used to handle the incoming request, and then returns a response. This response is sent back to the client, by calling the $response→send() method on the response variable gotten from handling the request. The send method outputs the content and sends defined headers for the response, it then tries to close the output buffering by ending the open connection with the client. In a case PHP FPM is used, the fastcgi_finish_request is used to close the connection.

The fastcgi_finish_request function flushes all response data to the client and finishes the request. This allows for time-consuming tasks to be performed without leaving the connection to the client open. Read more here

Just after the $response→send() line, we have the $kernel→terminate($request, $response) line next. We know the former sends a response, but what about that of the later. The latter expression seems self-explaining, indicating the application Http kernel is terminating the request and response.

After a response has been sent and the client connection closed, the PHP process is still alive to continue execution. In this case, the application Http kernel terminate method can be used to run little tasks. To run such little task or action, we can achieve them using:

Terminable Middleware
Terminating Callbacks

// vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php
    public function terminate($request, $response)
    {
        $this->terminateMiddleware($request, $response);
        $this->app->terminate();
    }

The above code snippet happens to be the content of the kernel terminate method. The first line calls the method terminateMiddleware on the application Http kernel, and the second calls the terminate method on the application container, which runs through all the terminating callbacks and execute them.

Terminable Middlewares

In laravel, we can define middlewares to intercept incoming requests and perform little tasks before reaching the main controller logic. This middleware class usually have a handle method to run the task. We can also define a terminate method on this middleware class, this method will perform little tasks after the response has been sent to the client. A middleware class with the terminate method can be described as a Terminable Middleware.

<?php

namespace App\Http\Middleware;

use Closure;

class AfterResponseMiddleware
{
    public function handle($request, Closure $next)
    {
        return $next($request);
    }

    public function terminate($request, $response)
    {
        // Perform tasks after response as been sent to the client
    }
}

Remember the method terminateMiddleware we found being used in the application Http kernel terminate method. This method is what calls the terminate method on any terminable middleware.

So in what case would one need to use a terminable middleware: Activity logging, Request logging and Session tracking.

Terminating Callbacks

Terminating callbacks are executed just after all terminable middlewares have been executed. These callbacks are functions registered to the laravel application. The snippet below, shows how to register a terminating callback:

App::terminating(function () {
});

app()->terminating(function () {

});

From the above code block, we can observe the use of a terminating method to register the callback function. This terminating method also exists in the application container. When the terminate method is called after the terminable middleware execution, all the terminating callbacks are then executed.

  foreach ($this->terminatingCallbacks as $terminating) {
      $this->call($terminating);
  }

A pretty much use case for a terminating callback is reporting on guzzle requests made during an Http request in laravel. Also, Mohamed Said contributed a new method that allows a job to dispatch after the response is sent back to the client, he wrote about this on his blog here. This is needed to dispatch a short job instantly instead of sending it to the regular queue system.

ShortInstantJob::dispatchAfterResponse();

The dispatchAfterResponse attaches the Job class as a terminating callback to the laravel application which is then executed when the application terminate is called.

Conclusion

Right here, we have seen the possible ways there is to execute actions after a response is sent in laravel and how this is achieved. Note that the kind of actions or tasks we want to execute after returning a response are meant to be a short-lived process.

Using Asynchronous Processes in PHP.

Wisdom Ebong — Sat, 08 Feb 2020 08:33:38 +0000

For most programs written in PHP, its sole purpose is to execute a simple process consisting of multiple tasks, where the tasks must be executed in sequence such as data processing. We always have to tolerate the stop and wait aspect of synchronous programming. The synchronous style of code execution is referred to as blocking, this implies that tasks will be executed one by one. So what if we want to run tasks without them blocking each other, that means we need to have a non-blocking process? This approach would require applying asynchronous programming approaches in PHP, here tasks will be executed without depending on of each other.

A common approach to achieve a non-blocking execution in PHP is to implement queue processing. Tasks are persisted to a transport system e.g MySQL, Redis, Amazon SQS e.t.c, which is retrieved by a background worker and executed accordingly, thereby not blocking the main process in which it was created. A laravel application provides a queue mechanism that allows tasks in this case called jobs to be deferred for to a later time for processing.

Another approach would be to run all defined tasks in parallel. What we get out of this approach is that a particular task is done it can return control back to the main process immediately with a promise to execute code and notify us about the result later(e.g. callback). One might see little use case for the parallel processing approach; example use case could be performing image processing and making a get request to some external service.

Let’s see the difference between synchronous and asynchronous (parallel) process in PHP using a very simple use case.

Synchronous code

  foreach (range(1, 5) as $i) {
     $output = $i * 2;
     echo $output . "\n";
  }

Asynchronous code

    use Spatie\Async\Pool;

    $pool = Pool::create();

    foreach (range(1, 5) as $i) {
        $pool[] = async(function () use ($i) {
           $output = $i * 2;
           return $output;
        })->then(function (int $output) {
           echo $output . "\n";
        });
    }
    await($pool);

When we execute the first code we will get the output values in this order:

Retrying the execution, we will get the output in this same sequence above … hence each multiplication operation waits to execute before the next one. Next, running the second code block, let’s see what we get.

Retrying the execution for the second time:

One process happens to produce two different results. This exactly is what we get for utilising the asynchronous approach … our little tasks can be executed in a fashion they don’t block each other. Each multiplication task executes independently, some faster than others hence the disorderliness in the output. Also, notice our async function as a then method attached to it, this method is responsible for taking back control and it accepts a callback function as its parameter which can now perform extra operations with the received output.

The folks at Spatie made this nice spatie/async package, which helps in performing tasks in parallel. You can install the package via composer:

composer require spatie/async

The package provides a neat way to interact with the tasks created, that are to be executed in parallel. The Event Listeners on the tasks are described below:

Performing another operation when the task is done as the callback is achievable with its then method.
Error handling is easier to control when a particular task throws an exception using the catch method.
Take for instance a task does not complete its operation, a timeout method allows one to handle such a scenario.

The event listeners are hooked to a task as shown below:

    $pool
        ->add(function () {
            // Task to be performed in a Parallel process
        })
        ->then(function ($output) {
            // On success, `$output` is returned by the process or callable you passed to           the queue.
        })
        ->catch(function ($exception) {
            // When an exception is thrown from within a process, it's caught and passed here.
        })
        ->timeout(function () {
            // Ohh No! A process took too long to finish. Let's do something 
        })
    ;

To learn more about the spatie/async package read this article from one of its contributors here and you can also refer to the GitHub repo.