Authors: Adrian McDonald Tariang, Anish M.M.
Drupal 8 Render Pipeline is the sequence of steps through which Drupal 8 generates a response to an HTTP request. ie, it’s what’s going on under the hood of Drupal 8.
As summer interns, we were trying to understand this process. While going through online material available on the topic, we noted that almost half of it was aimed at people transitioning from Drupal 7 to Drupal 8. Newbies as were to Drupal, we did struggle to figure it out. While digging through the material, it is quite easy to be misled and arrive at wrong conclusions. So, we have come up with this presentation, which targets beginners and keeps it as simple as possible.
This presentation is a walk through of the steps followed by Drupal 8 between getting a request and sending back the corresponding response, in that order, with specific details and examples mentioned when deemed necessary. It will provide an overview of the whole process, with emphasis on the Event Mechanism and the Routing Process.
The presentation will, we hope, give you a broad understanding of the topic and give you pointers on areas to focus. You are encouraged to follow up on this presentation by going through the references mentioned at the end. We cannot emphasize enough the benefits of going through the code, and urge you to download Drupal 8 code and go through it. A little bit of tweaking in there can go a long way in getting to know the concepts. The online documentation of the code will also come in handy.
Few of the tools you could use
- the blackfire.io or the XHProf profiler, can help in understanding Drupal’s routing system and dependency model
- debug_backtrace() for local system debugging. The devel module also provides a ddebug_backtrace() that provides a more readable output
Drupal 8 adopts most of its functionality from the Symfony Framework to implement modern PHP standards and is a platform for more developers to enter the Drupal Community.
The journey begins at the Front Controller, the index.php file, a construct that serves as an entry and exit point for all communications with Drupal. This is where Drupal wraps the request from the user into a Symfony Response Object for a more object oriented approach for request handling. The Request object is then passed through Symfony’s HttpKernel::handle() method, the backbone of the render pipeline that uses an event-based architecture to delegate the task at hand.
This system makes Drupal easily extensible, as Developers can now create their own Subscribers to events and modify the end response. Drupal 8 uses the concept of a Controller, a section of code which performs the main application logic. The Controller is assigned through a process called Routing, where, each path( say /admin), is mapped to its corresponding controller.
The Controller returns its results in the form of a Response object, ready to be sent back to the user, or a classic Drupal Render Array.
This Render Array is then pushed to the MainContentViewSubscriber, which decides how the array is to be converted into the Response object. This process, called Rendering, is performed by a Content Renderer, based on the format the response needs to be sent in.
Now, when a Response Object is received, Drupal prepares placeholders present on it’s HTML, so as to allow them to be replaced with content by popular placeholder strategies such as ESI, Big Pipe or SingleFlush, after which the final headers and assets are attached to the Response.
This Response is then sent back to the user, completing its journey through the Render Pipeline.
Wim Leers, author to material such as the render pipeline diagram and the DrupalCon Los Angeles 2015: Drupal 8's render pipeline session. These were extensively referred to for this presentation.