Drupal\mongodb_watchdog\Install\Requirements

Complexity

Total Complexity

20

Size/Duplication

Total Lines	240
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	hasUniqueId()	0	3	2
B	checkDatabaseAliasConsistency()	0	33	6
A	loadConfig()	0	10	2
A	check()	0	20	3
A	create()	0	7	1
A	__construct()	0	12	1
A	checkRequestTracking()	0	46	5

<?php

declare(strict_types=1);

namespace Drupal\mongodb_watchdog\Install;

use Drupal\Component\Serialization\SerializationInterface;

The type Drupal\Component\Serialization\SerializationInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\Config\ConfigFactoryInterface;

The type Drupal\Core\Config\ConfigFactoryInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\DependencyInjection\ContainerInjectionInterface;

The type Drupal\Core\DependencyInjection\ContainerInjectionInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\Messenger\MessengerInterface;

The type Drupal\Core\Messenger\MessengerInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\Site\Settings;

The type Drupal\Core\Site\Settings was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\StringTranslation\StringTranslationTrait;

The type Drupal\Core\StringTranslation\StringTranslationTrait was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\Core\Url;

The type Drupal\Core\Url was not found. Maybe you did not declare it correctly or list all dependencies?

use Drupal\mongodb\MongoDb;
use Drupal\mongodb_watchdog\Logger;
use Symfony\Component\DependencyInjection\ContainerInterface;

The type Symfony\Component\DependencyInjection\ContainerInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\HttpFoundation\RequestStack;

The type Symfony\Component\HttpFoundation\RequestStack was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Class Requirements implements hook_requirements().
 */
class Requirements implements ContainerInjectionInterface {
  use StringTranslationTrait;

  /**
   * The module configuration.
   *
   * @var \Drupal\Core\Config\Config

The type Drupal\Core\Config\Config was not found. Maybe you did not declare it correctly or list all dependencies?

   */
  protected $config;

  /**
   * The config.factory service.
   *
   * @var \Drupal\Core\Config\ConfigFactoryInterface
   */
  protected $configFactory;

  /**
   * The messenger service.
   *
   * @var \Drupal\Core\Messenger\MessengerInterface
   */
  protected $messenger;

  /**
   * The request_stack service.
   *
   * @var \Symfony\Component\HttpFoundation\RequestStack
   */
  protected $requestStack;

  /**
   * The serialization.yaml service.
   *
   * @var \Drupal\Component\Serialization\SerializationInterface
   */
  protected $serialization;

  /**
   * The section of Settings related to the MongoDB package.
   *
   * @var array
   */
  protected $settings;

  /**
   * Requirements constructor.
   *
   * @param \Drupal\Core\Site\Settings $settings
   *   The settings service.
   * @param \Drupal\Core\Config\ConfigFactoryInterface $configFactory
   *   The config.factory service.
   * @param \Symfony\Component\HttpFoundation\RequestStack $requestStack
   *   The request_stack service.
   * @param \Drupal\Component\Serialization\SerializationInterface $serialization
   *   The serialization.yaml service.
   * @param \Drupal\Core\Messenger\MessengerInterface $messenger
   *   The messenger service.
   */
  public function __construct(
    Settings $settings,
    ConfigFactoryInterface $configFactory,
    RequestStack $requestStack,
    SerializationInterface $serialization,
    MessengerInterface $messenger
  ) {
    $this->serialization = $serialization;
    $this->configFactory = $configFactory;
    $this->requestStack = $requestStack;
    $this->settings = $settings->get(MongoDb::MODULE);
    $this->messenger = $messenger;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container): self {
    return new static(
      $container->get('settings'),
      $container->get('config.factory'),
      $container->get('request_stack'),
      $container->get('serialization.yaml'),
      $container->get('messenger'));
  }

  /**
   * Apply database aliases consistency checks.
   *
   * @param array $state
   *   The current state of requirements checks.
   *
   * @return array
   *   - array: The current state of requirements checks.
   *   - bool: true if the checks added an error, false otherwise
   */
  protected function checkDatabaseAliasConsistency(array $state) : array {
    $databases = $this->settings['databases'];
    if (!isset($databases[Logger::DB_LOGGER])) {
      $state[Logger::MODULE] += [
        'severity' => REQUIREMENT_ERROR,

The constant Drupal\mongodb_watchdog\Install\REQUIREMENT_ERROR was not found. Maybe you did not declare it correctly or list all dependencies?

        'value' => $this->t('Missing `@alias` database alias in settings.',
          ['@alias' => Logger::DB_LOGGER]),
      ];
      return [$state, TRUE];
    }

    [$loggerClient, $loggerDb] = $databases[Logger::DB_LOGGER];
    unset($databases[Logger::DB_LOGGER]);
    $duplicates = [];
    foreach ($databases as $alias => $list) {
      [$client, $database] = $list;
      if ($loggerClient == $client && $loggerDb == $database) {
        $duplicates[] = "`$alias`";
      }
    }
    if (!empty($duplicates)) {
      $state[Logger::MODULE] += [
        'severity' => REQUIREMENT_ERROR,
        'value' => $this->t('The `@alias` alias points to the same database as @others.', [
          '@alias' => Logger::DB_LOGGER,
          '@others' => implode(', ', $duplicates),
        ]),
        'description' => $this->t('Those databases would also be dropped when uninstalling the watchdog module.'),
      ];
      return [$state, TRUE];
    }

    return [$state, FALSE];
  }

  /**
   * Load the configuration from default or from active configuration.
   *
   * @param bool $useDefault
   *   Use default configuration ?
   */
  protected function loadConfig(bool $useDefault): void {
    if ($useDefault) {
      $rawDefaultConfig = file_get_contents(__DIR__ . '/../../config/install/mongodb_watchdog.settings.yml');
      $defaultConfigData = $this->serialization->decode($rawDefaultConfig);
      $this->config = $this->configFactory->getEditable(Logger::MODULE);
      $this->config->initWithData($defaultConfigData);
      return;
    }

    $this->config = $this->configFactory->get(Logger::CONFIG_NAME);
  }

  /**
   * Check the consistency of request tracking vs configuration and environment.
   *
   * @param array $state
   *   The current state of requirements.
   *
   * @return array
   *   - array: The current state of requirements checks.
   *   - bool: true if the checks added an error, false otherwise
   */
  protected function checkRequestTracking(array $state) : array {
    $requestTracking = $this->config->get('request_tracking');
    if ($this->hasUniqueId()) {
      $state[Logger::MODULE] += $requestTracking
        ? [
          'value' => $this->t('Mod_unique_id available and used'),
          'severity' => REQUIREMENT_OK,

The constant Drupal\mongodb_watchdog\Install\REQUIREMENT_OK was not found. Maybe you did not declare it correctly or list all dependencies?

          'description' => $this->t('Request tracking is available and active.'),
        ]
        : [
          'value' => $this->t('Unused mod_unique_id'),
          'severity' => REQUIREMENT_INFO,

The constant Drupal\mongodb_watchdog\Install\REQUIREMENT_INFO was not found. Maybe you did not declare it correctly or list all dependencies?

          'description' => $this->t('The site could track requests, but request tracking is not enabled. You could disable mod_unique_id to save resources, or enable request tracking</a> for a better logging experience.'),
        ];

      return [$state, FALSE];
    }

    $state[Logger::MODULE] += [
      'value' => $this->t('No mod_unique_id'),
    ];
    if ($requestTracking) {
      if (php_sapi_name() === 'cli') {
        $message = $this->t('Request tracking is configured, but the site cannot check the working mod_unique_id configuration from the CLI. Be sure to validate configuration on the <a href=":report">status page</a>.', [
          ':report' => Url::fromRoute('system.status')->toString(),
        ]);
        $state[Logger::MODULE] += [
          'severity' => REQUIREMENT_WARNING,

The constant Drupal\mongodb_watchdog\Install\REQUIREMENT_WARNING was not found. Maybe you did not declare it correctly or list all dependencies?

          'description' => $message,
        ];
        $this->messenger->addWarning($message);
        return [$state, FALSE];
      }

      $state[Logger::MODULE] += [
        'severity' => REQUIREMENT_ERROR,

The constant Drupal\mongodb_watchdog\Install\REQUIREMENT_ERROR was not found. Maybe you did not declare it correctly or list all dependencies?

        'description' => $this->t('Request tracking is configured, but the site is not served by Apache with a working mod_unique_id.'),
      ];
      return [$state, TRUE];
    }

    $state[Logger::MODULE] += [
      'severity' => REQUIREMENT_OK,
      'description' => $this->t('Request tracking is not configured.'),
    ];
    return [$state, FALSE];
  }

  /**
   * Implements hook_requirements().
   */
  public function check(string $phase): array {
    $state = [
      Logger::MODULE => [
        'title' => 'MongoDB watchdog',
      ],
    ];

    [$state, $err] = $this->checkDatabaseAliasConsistency($state);
    if ($err) {
      return $state;
    }

    $this->loadConfig($phase !== 'runtime');

    [$state, $err] = $this->checkRequestTracking($state);
    if ($err) {
      return $state;
    }

    return $state;
  }

  /**
   * Is mod_unique_id available on this instance ?
   *
   * @return bool
   *   Is it ?
   */
  protected function hasUniqueId(): bool {
    $server = $this->requestStack->getCurrentRequest()->server;
    return $server->has('UNIQUE_ID') || $server->has('REDIRECT_UNIQUE_ID');
  }

}