first commi

system/src/Grav/Common/Processors/AssetsProcessor.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class AssetsProcessor
+ * @package Grav\Common\Processors
+ */
+class AssetsProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = '_assets';
+    /** @var string */
+    public $title = 'Assets';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $this->container['assets']->init();
+        $this->container->fireEvent('onAssetsInitialized');
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/BackupsProcessor.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class BackupsProcessor
+ * @package Grav\Common\Processors
+ */
+class BackupsProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = '_backups';
+    /** @var string */
+    public $title = 'Backups';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $backups = $this->container['backups'];
+        $backups->init();
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/DebuggerAssetsProcessor.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class DebuggerAssetsProcessor
+ * @package Grav\Common\Processors
+ */
+class DebuggerAssetsProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'debugger_assets';
+    /** @var string */
+    public $title = 'Debugger Assets';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $this->container['debugger']->addAssets();
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/Events/RequestHandlerEvent.php

@@ -0,0 +1,82 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors\Events;
+
+use Grav\Framework\RequestHandler\RequestHandler;
+use Grav\Framework\Route\Route;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use RocketTheme\Toolbox\Event\Event;
+
+/**
+ * Class RequestHandlerEvent
+ * @package Grav\Common\Processors\Events
+ */
+class RequestHandlerEvent extends Event
+{
+    /**
+     * @return ServerRequestInterface
+     */
+    public function getRequest(): ServerRequestInterface
+    {
+        return $this->offsetGet('request');
+    }
+
+    /**
+     * @return Route
+     */
+    public function getRoute(): Route
+    {
+        return $this->getRequest()->getAttribute('route');
+    }
+
+    /**
+     * @return RequestHandler
+     */
+    public function getHandler(): RequestHandler
+    {
+        return $this->offsetGet('handler');
+    }
+
+    /**
+     * @return ResponseInterface|null
+     */
+    public function getResponse(): ?ResponseInterface
+    {
+        return $this->offsetGet('response');
+    }
+
+    /**
+     * @param ResponseInterface $response
+     * @return $this
+     */
+    public function setResponse(ResponseInterface $response): self
+    {
+        $this->offsetSet('response', $response);
+        $this->stopPropagation();
+
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     * @param MiddlewareInterface $middleware
+     * @return RequestHandlerEvent
+     */
+    public function addMiddleware(string $name, MiddlewareInterface $middleware): self
+    {
+        /** @var RequestHandler $handler */
+        $handler = $this['handler'];
+        $handler->addMiddleware($name, $middleware);
+
+        return $this;
+    }
+}

system/src/Grav/Common/Processors/InitializeProcessor.php

@@ -0,0 +1,459 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Common\Config\Config;
+use Grav\Common\Debugger;
+use Grav\Common\Errors\Errors;
+use Grav\Common\Grav;
+use Grav\Common\Page\Pages;
+use Grav\Common\Plugins;
+use Grav\Common\Session;
+use Grav\Common\Uri;
+use Grav\Common\Utils;
+use Grav\Framework\File\Formatter\YamlFormatter;
+use Grav\Framework\File\YamlFile;
+use Grav\Framework\Psr7\Response;
+use Grav\Framework\Session\Exceptions\SessionException;
+use Monolog\Formatter\LineFormatter;
+use Monolog\Handler\SyslogHandler;
+use Monolog\Logger;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use function defined;
+use function in_array;
+
+/**
+ * Class InitializeProcessor
+ * @package Grav\Common\Processors
+ */
+class InitializeProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = '_init';
+    /** @var string */
+    public $title = 'Initialize';
+
+    /** @var bool */
+    private static $cli_initialized = false;
+
+    /**
+     * @param Grav $grav
+     * @return void
+     */
+    public static function initializeCli(Grav $grav)
+    {
+        if (!static::$cli_initialized) {
+            static::$cli_initialized = true;
+
+            $instance = new static($grav);
+            $instance->processCli();
+        }
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer('_init', 'Initialize');
+
+        // Load configuration.
+        $config = $this->initializeConfig();
+
+        // Initialize logger.
+        $this->initializeLogger($config);
+
+        // Initialize error handlers.
+        $this->initializeErrors();
+
+        // Initialize debugger.
+        $debugger = $this->initializeDebugger();
+
+        // Debugger can return response right away.
+        $response = $this->handleDebuggerRequest($debugger, $request);
+        if ($response) {
+            $this->stopTimer('_init');
+
+            return $response;
+        }
+
+        // Initialize output buffering.
+        $this->initializeOutputBuffering($config);
+
+        // Set timezone, locale.
+        $this->initializeLocale($config);
+
+        // Load plugins.
+        $this->initializePlugins();
+
+        // Load pages.
+        $this->initializePages($config);
+
+        // Initialize URI.
+        $this->initializeUri($config);
+
+        // Grav may return redirect response right away.
+        if ($config->get('system.pages.redirect_trailing_slash', false)) {
+            $response = $this->handleRedirectRequest($request);
+            if ($response) {
+                $this->stopTimer('_init');
+
+                return $response;
+            }
+        }
+
+        // Load accounts (decides class to be used).
+        // TODO: remove in 2.0.
+        $this->container['accounts'];
+
+        // Initialize session.
+        $this->initializeSession($config);
+
+        $this->stopTimer('_init');
+
+        // Wrap call to next handler so that debugger can profile it.
+        /** @var Response $response */
+        $response = $debugger->profile(static function () use ($handler, $request) {
+            return $handler->handle($request);
+        });
+
+        // Log both request and response and return the response.
+        return $debugger->logRequest($request, $response);
+    }
+
+    public function processCli(): void
+    {
+        // Load configuration.
+        $config = $this->initializeConfig();
+
+        // Initialize logger.
+        $this->initializeLogger($config);
+
+        // Disable debugger.
+        $this->container['debugger']->enabled(false);
+
+        // Set timezone, locale.
+        $this->initializeLocale($config);
+
+        // Load plugins.
+        $this->initializePlugins();
+
+        // Load pages.
+        $this->initializePages($config);
+
+        // Initialize URI.
+        $this->initializeUri($config);
+
+        // Load accounts (decides class to be used).
+        // TODO: remove in 2.0.
+        $this->container['accounts'];
+    }
+
+    /**
+     * @return Config
+     */
+    protected function initializeConfig(): Config
+    {
+        $this->startTimer('_init_config', 'Configuration');
+
+        // Initialize Configuration
+        $grav = $this->container;
+
+        /** @var Config $config */
+        $config = $grav['config'];
+        $config->init();
+        $grav['plugins']->setup();
+
+        if (defined('GRAV_SCHEMA') && $config->get('versions') === null) {
+            $filename = GRAV_ROOT . '/user/config/versions.yaml';
+            if (!is_file($filename)) {
+                $versions = [
+                    'core' => [
+                        'grav' => [
+                            'version' => GRAV_VERSION,
+                            'schema' => GRAV_SCHEMA
+                        ]
+                    ]
+                ];
+                $config->set('versions', $versions);
+
+                $file = new YamlFile($filename, new YamlFormatter(['inline' => 4]));
+                $file->save($versions);
+            }
+        }
+
+        // Override configuration using the environment.
+        $prefix = 'GRAV_CONFIG';
+        $env = getenv($prefix);
+        if ($env) {
+            $cPrefix = $prefix . '__';
+            $aPrefix = $prefix . '_ALIAS__';
+            $cLen = strlen($cPrefix);
+            $aLen = strlen($aPrefix);
+
+            $keys = $aliases = [];
+            $env = $_ENV + $_SERVER;
+            foreach ($env as $key => $value) {
+                if (!str_starts_with($key, $prefix)) {
+                    continue;
+                }
+                if (str_starts_with($key, $cPrefix)) {
+                    $key = str_replace('__', '.', substr($key, $cLen));
+                    $keys[$key] = $value;
+                } elseif (str_starts_with($key, $aPrefix)) {
+                    $key = substr($key, $aLen);
+                    $aliases[$key] = $value;
+                }
+            }
+            $list = [];
+            foreach ($keys as $key => $value) {
+                foreach ($aliases as $alias => $real) {
+                    $key = str_replace($alias, $real, $key);
+                }
+                $list[$key] = $value;
+                $config->set($key, $value);
+            }
+        }
+
+        $this->stopTimer('_init_config');
+
+        return $config;
+    }
+
+    /**
+     * @param Config $config
+     * @return Logger
+     */
+    protected function initializeLogger(Config $config): Logger
+    {
+        $this->startTimer('_init_logger', 'Logger');
+
+        $grav = $this->container;
+
+        // Initialize Logging
+        /** @var Logger $log */
+        $log = $grav['log'];
+
+        if ($config->get('system.log.handler', 'file') === 'syslog') {
+            $log->popHandler();
+
+            $facility = $config->get('system.log.syslog.facility', 'local6');
+            $logHandler = new SyslogHandler('grav', $facility);
+            $formatter = new LineFormatter("%channel%.%level_name%: %message% %extra%");
+            $logHandler->setFormatter($formatter);
+
+            $log->pushHandler($logHandler);
+        }
+
+        $this->stopTimer('_init_logger');
+
+        return $log;
+    }
+
+    /**
+     * @return Errors
+     */
+    protected function initializeErrors(): Errors
+    {
+        $this->startTimer('_init_errors', 'Error Handlers Reset');
+
+        $grav = $this->container;
+
+        // Initialize Error Handlers
+        /** @var Errors $errors */
+        $errors = $grav['errors'];
+        $errors->resetHandlers();
+
+        $this->stopTimer('_init_errors');
+
+        return $errors;
+    }
+
+    /**
+     * @return Debugger
+     */
+    protected function initializeDebugger(): Debugger
+    {
+        $this->startTimer('_init_debugger', 'Init Debugger');
+
+        $grav = $this->container;
+
+        /** @var Debugger $debugger */
+        $debugger = $grav['debugger'];
+        $debugger->init();
+
+        $this->stopTimer('_init_debugger');
+
+        return $debugger;
+    }
+
+    /**
+     * @param Debugger $debugger
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface|null
+     */
+    protected function handleDebuggerRequest(Debugger $debugger, ServerRequestInterface $request): ?ResponseInterface
+    {
+        // Clockwork integration.
+        $clockwork = $debugger->getClockwork();
+        if ($clockwork) {
+            $server = $request->getServerParams();
+//            $baseUri = str_replace('\\', '/', dirname(parse_url($server['SCRIPT_NAME'], PHP_URL_PATH)));
+//            if ($baseUri === '/') {
+//                $baseUri = '';
+//            }
+            $requestTime = $server['REQUEST_TIME_FLOAT'] ?? GRAV_REQUEST_TIME;
+
+            $request = $request->withAttribute('request_time', $requestTime);
+
+            // Handle clockwork API calls.
+            $uri = $request->getUri();
+            if (Utils::contains($uri->getPath(), '/__clockwork/')) {
+                return $debugger->debuggerRequest($request);
+            }
+
+            $this->container['clockwork'] = $clockwork;
+        }
+
+        return null;
+    }
+
+    /**
+     * @param Config $config
+     */
+    protected function initializeOutputBuffering(Config $config): void
+    {
+        $this->startTimer('_init_ob', 'Initialize Output Buffering');
+
+        // Use output buffering to prevent headers from being sent too early.
+        ob_start();
+        if ($config->get('system.cache.gzip') && !@ob_start('ob_gzhandler')) {
+            // Enable zip/deflate with a fallback in case of if browser does not support compressing.
+            ob_start();
+        }
+
+        $this->stopTimer('_init_ob');
+    }
+
+    /**
+     * @param Config $config
+     */
+    protected function initializeLocale(Config $config): void
+    {
+        $this->startTimer('_init_locale', 'Initialize Locale');
+
+        // Initialize the timezone.
+        $timezone = $config->get('system.timezone');
+        if ($timezone) {
+            date_default_timezone_set($timezone);
+        }
+
+        $grav = $this->container;
+        $grav->setLocale();
+
+        $this->stopTimer('_init_locale');
+    }
+
+    protected function initializePlugins(): Plugins
+    {
+        $this->startTimer('_init_plugins_load', 'Load Plugins');
+
+        $grav = $this->container;
+
+        /** @var Plugins $plugins */
+        $plugins = $grav['plugins'];
+        $plugins->init();
+
+        $this->stopTimer('_init_plugins_load');
+
+        return $plugins;
+    }
+
+    protected function initializePages(Config $config): Pages
+    {
+        $this->startTimer('_init_pages_register', 'Load Pages');
+
+        $grav = $this->container;
+
+        /** @var Pages $pages */
+        $pages = $grav['pages'];
+        // Upgrading from older Grav versions won't work without checking if the method exists.
+        if (method_exists($pages, 'register')) {
+            $pages->register();
+        }
+
+        $this->stopTimer('_init_pages_register');
+
+        return $pages;
+    }
+
+
+    protected function initializeUri(Config $config): void
+    {
+        $this->startTimer('_init_uri', 'Initialize URI');
+
+        $grav = $this->container;
+
+        /** @var Uri $uri */
+        $uri = $grav['uri'];
+        $uri->init();
+
+        $this->stopTimer('_init_uri');
+    }
+
+    protected function handleRedirectRequest(RequestInterface $request): ?ResponseInterface
+    {
+        if (!in_array($request->getMethod(), ['GET', 'HEAD'])) {
+            return null;
+        }
+
+        // Redirect pages with trailing slash if configured to do so.
+        $uri = $request->getUri();
+        $path = $uri->getPath() ?: '/';
+        $root = $this->container['uri']->rootUrl();
+
+        if ($path !== $root && $path !== $root . '/' && Utils::endsWith($path, '/')) {
+            // Use permanent redirect for SEO reasons.
+            return $this->container->getRedirectResponse((string)$uri->withPath(rtrim($path, '/')), 301);
+        }
+
+        return null;
+    }
+
+    /**
+     * @param Config $config
+     */
+    protected function initializeSession(Config $config): void
+    {
+        // FIXME: Initialize session should happen later after plugins have been loaded. This is a workaround to fix session issues in AWS.
+        if (isset($this->container['session']) && $config->get('system.session.initialize', true)) {
+            $this->startTimer('_init_session', 'Start Session');
+
+            /** @var Session $session */
+            $session = $this->container['session'];
+
+            try {
+                $session->init();
+            } catch (SessionException $e) {
+                $session->init();
+                $message = 'Session corruption detected, restarting session...';
+                $this->addMessage($message);
+                $this->container['messages']->add($message, 'error');
+            }
+
+            $this->stopTimer('_init_session');
+        }
+    }
+}

system/src/Grav/Common/Processors/PagesProcessor.php

@@ -0,0 +1,83 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Common\Page\Interfaces\PageInterface;
+use RocketTheme\Toolbox\Event\Event;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use RuntimeException;
+
+/**
+ * Class PagesProcessor
+ * @package Grav\Common\Processors
+ */
+class PagesProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'pages';
+    /** @var string */
+    public $title = 'Pages';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+
+        // Dump Cache state
+        $this->container['debugger']->addMessage($this->container['cache']->getCacheStatus());
+
+        $this->container['pages']->init();
+        $this->container->fireEvent('onPagesInitialized', new Event(['pages' => $this->container['pages']]));
+        $this->container->fireEvent('onPageInitialized', new Event(['page' => $this->container['page']]));
+
+        /** @var PageInterface $page */
+        $page = $this->container['page'];
+
+        if (!$page->routable()) {
+            // If no page found, fire event
+            $event = new Event(['page' => $page]);
+            $event->page = null;
+            $event = $this->container->fireEvent('onPageNotFound', $event);
+
+            if (isset($event->page)) {
+                unset($this->container['page']);
+                $this->container['page'] = $page = $event->page;
+            } else {
+                throw new RuntimeException('Page Not Found', 404);
+            }
+
+            $this->addMessage("Routed to page {$page->rawRoute()} (type: {$page->template()}) [Not Found fallback]");
+        } else {
+            $this->addMessage("Routed to page {$page->rawRoute()} (type: {$page->template()})");
+
+            $task = $this->container['task'];
+            $action = $this->container['action'];
+            if ($task) {
+                $event = new Event(['task' => $task, 'page' => $page]);
+                $this->container->fireEvent('onPageTask', $event);
+                $this->container->fireEvent('onPageTask.' . $task, $event);
+            } elseif ($action) {
+                $event = new Event(['action' => $action, 'page' => $page]);
+                $this->container->fireEvent('onPageAction', $event);
+                $this->container->fireEvent('onPageAction.' . $action, $event);
+            }
+        }
+
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/PluginsProcessor.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class PluginsProcessor
+ * @package Grav\Common\Processors
+ */
+class PluginsProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'plugins';
+    /** @var string */
+    public $title = 'Initialize Plugins';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $grav = $this->container;
+        $grav->fireEvent('onPluginsInitialized');
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/ProcessorBase.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Common\Debugger;
+use Grav\Common\Grav;
+
+/**
+ * Class ProcessorBase
+ * @package Grav\Common\Processors
+ */
+abstract class ProcessorBase implements ProcessorInterface
+{
+    /** @var Grav */
+    protected $container;
+
+    /** @var string */
+    public $id = 'processorbase';
+    /** @var string */
+    public $title = 'ProcessorBase';
+
+    /**
+     * ProcessorBase constructor.
+     * @param Grav $container
+     */
+    public function __construct(Grav $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * @param string|null $id
+     * @param string|null $title
+     */
+    protected function startTimer($id = null, $title = null): void
+    {
+        /** @var Debugger $debugger */
+        $debugger = $this->container['debugger'];
+        $debugger->startTimer($id ?? $this->id, $title ?? $this->title);
+    }
+
+    /**
+     * @param string|null $id
+     */
+    protected function stopTimer($id = null): void
+    {
+        /** @var Debugger $debugger */
+        $debugger = $this->container['debugger'];
+        $debugger->stopTimer($id ?? $this->id);
+    }
+
+    /**
+     * @param string $message
+     * @param string $label
+     * @param bool $isString
+     */
+    protected function addMessage($message, $label = 'info', $isString = true): void
+    {
+        /** @var Debugger $debugger */
+        $debugger = $this->container['debugger'];
+        $debugger->addMessage($message, $label, $isString);
+    }
+}

system/src/Grav/Common/Processors/ProcessorInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Server\MiddlewareInterface;
+
+/**
+ * Interface ProcessorInterface
+ * @package Grav\Common\Processors
+ */
+interface ProcessorInterface extends MiddlewareInterface
+{
+}

system/src/Grav/Common/Processors/RenderProcessor.php

@@ -0,0 +1,66 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Common\Page\Interfaces\PageInterface;
+use Grav\Framework\Psr7\Response;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class RenderProcessor
+ * @package Grav\Common\Processors
+ */
+class RenderProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'render';
+    /** @var string */
+    public $title = 'Render';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+
+        $container = $this->container;
+        $output =  $container['output'];
+
+        if ($output instanceof ResponseInterface) {
+            return $output;
+        }
+
+        ob_start();
+
+        // Use internal Grav output.
+        $container->output = $output;
+        $container->fireEvent('onOutputGenerated');
+
+        echo $container->output;
+
+        // remove any output
+        $container->output = '';
+
+        $this->container->fireEvent('onOutputRendered');
+
+        $html = ob_get_clean();
+
+        /** @var PageInterface $page */
+        $page = $this->container['page'];
+        $this->stopTimer();
+
+        return new Response($page->httpResponseCode(), $page->httpHeaders(), $html);
+    }
+}

system/src/Grav/Common/Processors/RequestProcessor.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Common\Processors\Events\RequestHandlerEvent;
+use Grav\Common\Uri;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class RequestProcessor
+ * @package Grav\Common\Processors
+ */
+class RequestProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'request';
+    /** @var string */
+    public $title = 'Request';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+
+        $header = $request->getHeaderLine('Content-Type');
+        $type = trim(strstr($header, ';', true) ?: $header);
+        if ($type === 'application/json') {
+            $request = $request->withParsedBody(json_decode($request->getBody()->getContents(), true));
+        }
+
+        $uri = $request->getUri();
+        $ext = mb_strtolower(pathinfo($uri->getPath(), PATHINFO_EXTENSION));
+
+        $request = $request
+            ->withAttribute('grav', $this->container)
+            ->withAttribute('time', $_SERVER['REQUEST_TIME_FLOAT'] ?? GRAV_REQUEST_TIME)
+            ->withAttribute('route', Uri::getCurrentRoute()->withExtension($ext))
+            ->withAttribute('referrer', $this->container['uri']->referrer());
+
+        $event = new RequestHandlerEvent(['request' => $request, 'handler' => $handler]);
+        /** @var RequestHandlerEvent $event */
+        $event = $this->container->fireEvent('onRequestHandlerInit', $event);
+        $response = $event->getResponse();
+        $this->stopTimer();
+
+        if ($response) {
+            return $response;
+        }
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/SchedulerProcessor.php

@@ -0,0 +1,42 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use RocketTheme\Toolbox\Event\Event;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class SchedulerProcessor
+ * @package Grav\Common\Processors
+ */
+class SchedulerProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = '_scheduler';
+    /** @var string */
+    public $title = 'Scheduler';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $scheduler = $this->container['scheduler'];
+        $this->container->fireEvent('onSchedulerInitialized', new Event(['scheduler' => $scheduler]));
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/TasksProcessor.php

@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Grav\Framework\RequestHandler\Exception\NotFoundException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class TasksProcessor
+ * @package Grav\Common\Processors
+ */
+class TasksProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'tasks';
+    /** @var string */
+    public $title = 'Tasks';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+
+        $task = $this->container['task'];
+        $action = $this->container['action'];
+        if ($task || $action) {
+            $attributes = $request->getAttribute('controller');
+
+            $controllerClass = $attributes['class'] ?? null;
+            if ($controllerClass) {
+                /** @var RequestHandlerInterface $controller */
+                $controller = new $controllerClass($attributes['path'] ?? '', $attributes['params'] ?? []);
+                try {
+                    $response = $controller->handle($request);
+
+                    if ($response->getStatusCode() === 418) {
+                        $response = $handler->handle($request);
+                    }
+
+                    $this->stopTimer();
+
+                    return $response;
+                } catch (NotFoundException $e) {
+                    // Task not found: Let it pass through.
+                }
+            }
+
+            if ($task) {
+                $this->container->fireEvent('onTask.' . $task);
+            } elseif ($action) {
+                $this->container->fireEvent('onAction.' . $action);
+            }
+        }
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/ThemesProcessor.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class ThemesProcessor
+ * @package Grav\Common\Processors
+ */
+class ThemesProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'themes';
+    /** @var string */
+    public $title = 'Themes';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $this->container['themes']->init();
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}

system/src/Grav/Common/Processors/TwigProcessor.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * @package    Grav\Common\Processors
+ *
+ * @copyright  Copyright (c) 2015 - 2021 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Common\Processors;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * Class TwigProcessor
+ * @package Grav\Common\Processors
+ */
+class TwigProcessor extends ProcessorBase
+{
+    /** @var string */
+    public $id = 'twig';
+    /** @var string */
+    public $title = 'Twig';
+
+    /**
+     * @param ServerRequestInterface $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->startTimer();
+        $this->container['twig']->init();
+        $this->stopTimer();
+
+        return $handler->handle($request);
+    }
+}