public static function RulesEventSet::rebuildEventCache in Rules 7.2

Rebuilds the event cache.

We cache event-sets per event in order to allow efficient usage via rules_invoke_event().

See also

rules_get_cache()

rules_invoke_event()

5 calls to RulesEventSet::rebuildEventCache()

RulesEventDispatcherTestCase::testStartAndStop in tests/rules.test

Tests start and stop functionality.

RulesEventDispatcherTestCase::testStartAndStopMultiple in tests/rules.test

Tests start and stop functionality when used with multiple events.

rules_admin_settings_cache_rebuild_submit in rules_admin/rules_admin.inc

Form submit callback: Rebuild the Rules' cache.

rules_get_cache in ./rules.module

Gets a rules cache entry.

rules_update_7214 in ./rules.install

Switch out the rules_event_whitelist variable for a cache equivalent.

File

includes/rules.plugins.inc, line 851

Contains plugin info and implementations not needed for rule evaluation.

Class

RulesEventSet

This class is used for caching the rules to be evaluated per event.

Code

public static function rebuildEventCache() {

  // Set up the per-event cache.
  $events = rules_fetch_data('event_info');
  $sets = array();

  // Add all rules associated with this event to an EventSet for caching.
  $rules = rules_config_load_multiple(FALSE, array(
    'plugin' => 'reaction rule',
    'active' => TRUE,
  ));
  foreach ($rules as $name => $rule) {
    foreach ($rule
      ->events() as $event_name) {
      $event_base_name = rules_get_event_base_name($event_name);

      // Skip not defined events.
      if (empty($events[$event_base_name])) {
        continue;
      }

      // Create an event set if not yet done.
      if (!isset($sets[$event_name])) {
        $handler = rules_get_event_handler($event_name, $rule
          ->getEventSettings($event_name));

        // Start the event dispatcher for this event, if any.
        if ($handler instanceof RulesEventDispatcherInterface && !$handler
          ->isWatching()) {
          $handler
            ->startWatching();
        }

        // Update the event info with the variables available based on the
        // event settings.
        $event_info = $events[$event_base_name];
        $event_info['variables'] = $handler
          ->availableVariables();
        $sets[$event_name] = new RulesEventSet($event_info);
        $sets[$event_name]->name = $event_name;
      }

      // If a rule is marked as dirty, check if this still applies.
      if ($rule->dirty) {
        rules_config_update_dirty_flag($rule);
      }
      if (!$rule->dirty) {

        // Clone the rule to avoid modules getting the changed version from
        // the static cache.
        $sets[$event_name]
          ->rule(clone $rule);
      }
    }
  }

  // Create cache items for all created sets.
  foreach ($sets as $event_name => $set) {
    $set
      ->sortChildren();
    $set
      ->optimize();

    // Allow modules to alter the cached event set.
    drupal_alter('rules_event_set', $event_name, $set);
    rules_set_cache('event_' . $event_name, $set);
  }

  // Cache a whitelist of configured events so we can use it to speed up later
  // calls. See rules_invoke_event().
  rules_set_cache('rules_event_whitelist', array_flip(array_keys($sets)));
}