Add functionality and customize your Drupal application with thousands of projects contributed by our amazing community.
A module is code that extends Drupal's by altering existing functionality or adding new features. You can use modules contributed by others or create your own. Learn more about creating and using Drupal modules.
The Ultimate Cron handling for Drupal.
Runs cron jobs individually in parallel using configurable rules, pool management and load balancing.
8.x-2.x
This is a port of the 7.x-2.x branch to Drupal 8, using config entities and the Drupal 8+ plugin system.
See https://befused.com/drupal/ultimate-cron/ for an overview on how the module works and how to discover jobs.
2.9 READY!
Ultimate Cron 7.x-2.9 is out now.
Ultimate Cron 1.x documentation can be found at https://drupal.org/node/1666944
The old project page for Ultimate Cron 1.x can be found at https://drupal.org/node/2195381
Changes
- No more dependency to Background Process. Ultimate Cron now works without Background Process. However, Background Process is still supported for true parallelism
- Refactored to use cTools plugins, making it easier to extend Ultimate Cron.
- Now includes the daemonizer and queue throttling features, previously found in the modules Ultimate Cron Daemonizer and Ultimate Cron Queue Scaler
- Hopefully a more robust lock and logging mechanism.
- Integration with nodejs for live update on cron page
- Nagios support has not been re-implemented
Upgrade path from 7.x-1.x and previous
Upgrading from an earlier version of Ultimate Cron to a 7.x-2.x version has some caveats. See the documentation.
Plugins
Ultimate Cron is built upon 4 plugin types.
- Settings: - plugins that provide custom settings for jobs (bundled: general, queue).
- Schedulers: - plugins that provide a mechanism for whether or not a job should run at a certain time (bundled: simple, crontab).
- Launchers: - plugins that provide a way of launching jobs (bundled: serial, background_process).
- Loggers: - plugins that provide a logging backing for job status (bundled: database, cache).
Ultimate Cron 7.x-2.x documentation can be found at https://drupal.org/node/2195383
Features
- Works out-of-the box in most cases (or aims to)
- Parallel execution of cron jobs
- Configuration per job (enable/disable, rules, etc.)
- Multiple rules per cron job
- Pool management and load balancing using Background process
- Support for Drupal Queues
- Overview of cron jobs
- Log history of cron jobs
- Status/error messages per cron job, providing easy debugging of troublesome cron jobs
- Uses hook_cronapi() (Elysia Cron compatible, NOT 2.x, please use hook_cron_alter() for similar functionality)
- hook_cron_alter() for easy adding/manipulating cron jobs
- Poormans cron with keepalive a granularity of 1 minute
- Drush support (list, start, enable/disable jobs from the command line)
Summary
Note: AdvAgg needs a major rework for Drupal 10.1 - recommend holding update or disabling AdvAgg until a new release comes out.
The modular external cache invalidation framework.
Creates a WebP copy of image style derivatives to decrease loading times.
7.x-1.7 regression
If you're using the 7.x branch of Memcache, please be aware that 7.x-1.7 (released 16 July 2020) introduced an unintentional dependency on PHP 7. This is fixed in 7.x-1.8.
Features
This module provides integration between Drupal and Memcached with the following features:
- An API for using Memcached and the PECL Memcache or Memcached libraries with Drupal.
- Memcache backends for the following systems (all drop-in):
- Caching (memcache.inc)
- Locking (memcache-lock.inc)
- Sessions (memcache-session.inc) (D6 only)
- A module that provides a comprehensive administrative overview of Drupal's interaction with Memcached and stats.
- A set of tests that can be run to test your memcache setup.
Integration of Drupal with the Redis key-value store. It provides cache, lock and path optional backends as well as a placeholder module for contribution modules Redis easier usage.
Provided backends
Predis
Redis cache backend using the standalone Predis PHP library.
Requires PHP 5.3. Please read README.Predis.txt file for full install documentation.
This module since the 2.12 version now only officially supports Predis >= 1.x but should still work the 8.x branch. Redis module 3.x only supports Predis >= 1.x
PhpRedis
Redis cache backend using the well performing PhpRedis PHP extension.
Please read README.PhpRedis.txt file for configuration and documentation. PhpRedis is the recommended connector.
Top-notch cache invalidation on Acquia Cloud!
Drupal 8+
A Drupal 8+ version of this module is in active development, a relatively stable beta version is available.
The Drupal 8+ version has been completely re-written and no longer provides an image toolkit. Optimizations are now defined as 'pipelines' that can be applied to images in various ways.
The module has built in support for core Image styles and a service allowing use in third party modules.
The module has been split into several other projects for easier maintainability and more modular installing. At least one or more processor module needs to be installed for the optimization to work.
Open Drupal 8 issues | All issues from all subprojects
Drupal 7
This is a toolkit for ImageAPI. It requires imageapi_gd or imageapi_imagemagick or any ImageAPI toolkit to work.
ImageAPI Optimize allows you to use your preferred toolkit and optimize (losslessly) the image when it is saved. Practice for web performance suggests that images should be optimized for better loading time. With this module enabled, Google's Page Speed will always give you an A in image optimize.
The Node Revision Delete module lets you track and prune old revisions of content types.
This module provides configurable actions upon events that will expire URLs from caches like reverse proxy caches, internal page caches, etc.This module make more sense when Minimum Cache Lifetime setting is set to a value other than none.
There is now integration with the following modules:
- Boost - deletes expired pages (files) from the file system.
- Varnish - integrates over an administrative socket.
- Fastly - Varnish/CDN caching
- Purge - expires urls by sending purge requests to Varnish, Squid and Nginx over HTTP.
- Acquia Purge - allows Drupal sites hosted on Acquia Cloud to automatically purge pages from their Varnish powered load balancers..
- Memcache Storage - allows to delete pages that were cached in a memcached instances.
- Akamai - provides an integration with the Akamai Cache Control Utility (CCU) Web Service
- Recacher - Page cache warmer.
Module's features may extend if next modules are enabled:
- Drush - provides drush commands to expire urls (xp-url), paths (xp-path), nodes (xp-node), users (xp-user), comments (xp-comment) from the command line shell and scripts.
- Rules - provides actions for the Rules module to allow more advanced cache expiration scenarios.
- Token - provides modal dialog with list of available tokens.
- References and Entity reference - module may expire referenced entities' urls.
Description
This module defines the "hierarchical_select" form element, which is a greatly enhanced way for letting the user select items in a hierarchy.
Hierarchical Select has the ability to save the entire lineage of a selection or only the "deepest" selection. You can configure it to force the user to make a selection as deep as possible in the tree, or allow the user to select an item anywhere in the tree. Levels can be labeled, you can configure limit the number of items that can be selected, configure a title for the dropbox, choose a site-wide animation delay, and so on. You can even create new items and levels through Hierarchical Select!
For a good overview of what Hierarchical Select can do, look at this demo!
Drupal 7 version
The Drupal 7 version integrates with:
- Taxonomy (Drupal core)
- Menu (Drupal core)
- Entity Reference (rudimentary support)
This is a simple Drupal module which lets you enable lazy-loading images and iframes.
Elysia Cron extends Drupal standard cron, allowing a fine grain control over each task and several ways to add custom cron jobs to your site.
- Set the timings and frequencies of each cron task (you can run some jobs every day at a specified hour, other only monthly and so on...). For each task you can simply choose between some frequently used options ("once a day", "once a month" ...), or use a powerful "linux crontab"-like syntax to set the accurate timings. You can even define your frequently used options to speed up site configuration.
- Parallel execution of cron task: you can group jobs in channels and execute then simultaneously: so a task that takes a lot of time to execute won't block other tasks that need to be executed every 5 minutes...
- You can disable all tasks, an entire channel or a single task.
- Change the priority/order of task execution.
- Manual force the execution of a cron tasks.
- Detailed overview of cron status with time statistics for single tasks and channels.
- powerful API for module developers: you can define extra cron tasks for your modules, each one with own default timings (site administrators can override them by configuration, other modules via hook_alter).
- Administrators can define custom jobs (call to functions with parameters), via the "script" option.
- Several optimization for frequent cron calls and error handling.
- Protection from external cron calling by cron_key or allowed host list.
Elysia has no dependencies with contributed modules, and doesn't need to patch the core: it can be used in minimal Drupal installation with only core modules.
3rd party integration:
- Ping feature, for external tracking services like host-tracker to tell whether cron is functioning properly on your site.
- Drush support: you can call "drush elysia-cron run" to manually run extended cron.
- CTools support for exports/backup of task settings.
- Features support.
In Drupal 8 core Page Cache max age settings are applied globally to all pages, and there is no way to set a different max age per page or leverage cache metadata max-age to override Cache-Control
This module provides all the necessary infrastructure to orchestrate your cache warming processes.
This module does exactly what the title says - it minifies the source HTML before the data is sent to the browser.
What and Why
Drupal has expensive 404 errors. On an 'average' site with an 'average' module load, you can be looking at 60-100MB of memory being consumed on your server to deliver a 404. Consider a page with a bad .gif link and a missing .css file. That page will generate 2 404s along with the actual load of the page. You are most likely looking at 180MB of memory to server that page rather than the 60MB it should take.
That's where Fast 404 comes in. This module combines a very common method of handling missing image/file 404 errors (discussed here and planned for Drupal 8) with a method created by dpardo (a co-maintainer of this project) to deliver super fast 404 error pages for both missing images and bad paths. Depending on which method of implementation you choose (aggressive or super aggressive) you can deliver 404 errors using less than 1MB of memory on your server.
Drupal 7 Core Updates
Drupal 7 core has updated to add a rudimentary version of what this module implements. It allows you to set an excluded set of paths, a list of extensions to Fast 404 on, as well as the plain HTML that is delivered.
Issue describing: http://drupal.org/node/76824
Patch added: http://drupal.org/files/issues/404_fast_paths_7x-76824-328.patch
Boost provides static page caching for Drupal enabling a very significant performance and scalability boost for sites that receive mostly anonymous traffic. When there is no problem with your file system performance it is a good solution for shared hosting.
Since Drupal 8-Version of this module Boost can serve cached content from files directly via RequestEvent independent from the used webserver. But it is still a good idea to use the webserver for serving static files. In this case there is even no PHP involved to serve content and get the maximal boost.
What is this?
This is the Varnish purger for the Purge module.
Entity cache puts core entities into Drupal's cache API.
Due to the entity loading changes in Drupal 7, no core patches are required.
How to use it
This module has no user interface, if you enable it, entities will start being cached, if you disable it, they'll stop.
Supported core entities
- Nodes
- Comments
- Taxonomy terms
- Taxonomy vocabularies
- Files
- Users
Support for contrib entities:
There is no automated support for contrib entities, to use entitycache for a contrib or custom entity:
- Create a cache_entity_$myentity table/bin.
- Specify EntityCacheDefaultEntityController as your controller class in hook_entity_info(), or extend it.
- Never update your entity tables outside of save/delete API calls.
Tests
Entity cache is now set up for automated testing on Drupal.org, see current HEAD status.
This module is being developed for Drupal 7, and will never be backported to Drupal 6. For Drupal 6 you may want to look at this pressflow merge request or http://drupal.org/project/advcache.
Elasticsearch Connector is a set of modules designed to build a full Elasticsearch eco system in Drupal.
This is a library module. It provides no out of the box functionality other then providing an API that other modules/code can use. Other projects might require/recommend this module. Install HTTPRL only if other modules recommend or require it.
What does httprl do?
Using stream_select() it will send http requests out in parallel. These requests can be made in a blocking or non-blocking way. Blocking will wait for the http response; Non-Blocking will close the connection not waiting for the response back. The API for httprl is similar to the Drupal 7 version of drupal_http_request().
As a bonus, a simple threading library is built on top of the parallel http requests functionality. This allows you to split a job and have multiple http "workers" running this split job in parallel. Anything that takes a long time to do can greatly benefit from using threads.
Benchmarks
Pages