nextcloud/lib/private/AppFramework/Middleware/MiddlewareDispatcher.php

168 lines
5.4 KiB
PHP
Raw Normal View History

2013-08-17 13:16:48 +04:00
<?php
declare(strict_types=1);
2013-08-17 13:16:48 +04:00
/**
2016-07-21 18:07:57 +03:00
* @copyright Copyright (c) 2016, ownCloud, Inc.
*
* @author Christoph Wurst <christoph@winzerhof-wurst.at>
2015-03-26 13:44:34 +03:00
* @author Jörn Friedrich Dreyer <jfd@butonic.de>
2016-05-26 20:56:05 +03:00
* @author Lukas Reschke <lukas@statuscode.ch>
2015-03-26 13:44:34 +03:00
* @author Morris Jobke <hey@morrisjobke.de>
* @author Roeland Jago Douma <roeland@famdouma.nl>
2016-05-26 20:56:05 +03:00
* @author Stefan Weil <sw@weilnetz.de>
2015-03-26 13:44:34 +03:00
* @author Thomas Müller <thomas.mueller@tmit.eu>
* @author Thomas Tanghus <thomas@tanghus.net>
2013-08-17 13:16:48 +04:00
*
2015-03-26 13:44:34 +03:00
* @license AGPL-3.0
2013-08-17 13:16:48 +04:00
*
2015-03-26 13:44:34 +03:00
* This code is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
2013-08-17 13:16:48 +04:00
*
2015-03-26 13:44:34 +03:00
* This program is distributed in the hope that it will be useful,
2013-08-17 13:16:48 +04:00
* but WITHOUT ANY WARRANTY; without even the implied warranty of
2015-03-26 13:44:34 +03:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
2013-08-17 13:16:48 +04:00
*
2015-03-26 13:44:34 +03:00
* You should have received a copy of the GNU Affero General Public License, version 3,
* along with this program. If not, see <http://www.gnu.org/licenses/>
2013-08-17 13:16:48 +04:00
*
*/
2013-08-17 13:16:48 +04:00
namespace OC\AppFramework\Middleware;
use OCP\AppFramework\Controller;
2013-08-21 03:00:26 +04:00
use OCP\AppFramework\Http\Response;
use OCP\AppFramework\Middleware;
2013-08-17 13:16:48 +04:00
/**
* This class is used to store and run all the middleware in correct order
*/
class MiddlewareDispatcher {
/**
* @var array array containing all the middlewares
*/
private $middlewares;
/**
* @var int counter which tells us what middlware was executed once an
* exception occurs
*/
private $middlewareCounter;
/**
* Constructor
*/
public function __construct() {
$this->middlewares = [];
2013-08-17 13:16:48 +04:00
$this->middlewareCounter = 0;
}
/**
* Adds a new middleware
* @param Middleware $middleWare the middleware which will be added
2013-08-17 13:16:48 +04:00
*/
public function registerMiddleware(Middleware $middleWare) {
$this->middlewares[] = $middleWare;
2013-08-17 13:16:48 +04:00
}
/**
* returns an array with all middleware elements
* @return array the middlewares
*/
public function getMiddlewares(): array {
2013-08-17 13:16:48 +04:00
return $this->middlewares;
}
/**
* This is being run in normal order before the controller is being
* called which allows several modifications and checks
*
* @param Controller $controller the controller that is being called
* @param string $methodName the name of the method that will be called on
* the controller
*/
public function beforeController(Controller $controller, string $methodName) {
2013-08-17 13:16:48 +04:00
// we need to count so that we know which middlewares we have to ask in
// case there is an exception
$middlewareCount = \count($this->middlewares);
for ($i = 0; $i < $middlewareCount; $i++) {
2013-08-17 13:16:48 +04:00
$this->middlewareCounter++;
$middleware = $this->middlewares[$i];
$middleware->beforeController($controller, $methodName);
}
}
/**
* This is being run when either the beforeController method or the
* controller method itself is throwing an exception. The middleware is asked
* in reverse order to handle the exception and to return a response.
* If the response is null, it is assumed that the exception could not be
* handled and the error will be thrown again
*
* @param Controller $controller the controller that is being called
* @param string $methodName the name of the method that will be called on
* the controller
* @param \Exception $exception the thrown exception
* @return Response a Response object if the middleware can handle the
* exception
* @throws \Exception the passed in exception if it can't handle it
2013-08-17 13:16:48 +04:00
*/
public function afterException(Controller $controller, string $methodName, \Exception $exception): Response {
for ($i=$this->middlewareCounter-1; $i>=0; $i--) {
2013-08-17 13:16:48 +04:00
$middleware = $this->middlewares[$i];
try {
return $middleware->afterException($controller, $methodName, $exception);
} catch (\Exception $exception) {
2013-08-17 13:16:48 +04:00
continue;
}
}
throw $exception;
}
/**
* This is being run after a successful controllermethod call and allows
* the manipulation of a Response object. The middleware is run in reverse order
*
* @param Controller $controller the controller that is being called
* @param string $methodName the name of the method that will be called on
* the controller
* @param Response $response the generated response from the controller
* @return Response a Response object
*/
public function afterController(Controller $controller, string $methodName, Response $response): Response {
for ($i= \count($this->middlewares)-1; $i>=0; $i--) {
2013-08-17 13:16:48 +04:00
$middleware = $this->middlewares[$i];
$response = $middleware->afterController($controller, $methodName, $response);
}
return $response;
}
/**
* This is being run after the response object has been rendered and
* allows the manipulation of the output. The middleware is run in reverse order
*
* @param Controller $controller the controller that is being called
* @param string $methodName the name of the method that will be called on
* the controller
* @param string $output the generated output from a response
* @return string the output that should be printed
*/
public function beforeOutput(Controller $controller, string $methodName, string $output): string {
for ($i= \count($this->middlewares)-1; $i>=0; $i--) {
2013-08-17 13:16:48 +04:00
$middleware = $this->middlewares[$i];
$output = $middleware->beforeOutput($controller, $methodName, $output);
}
return $output;
}
}