Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Support\Vanilla;

use Clockwork\Clockwork as BaseClockwork;

use Clockwork\Authentication\NullAuthenticator;

use Clockwork\Authentication\SimpleAuthenticator;

use Clockwork\DataSource\PhpDataSource;

use Clockwork\DataSource\PsrMessageDataSource;

use Clockwork\Helpers\Serializer;

use Clockwork\Helpers\ServerTiming;

use Clockwork\Helpers\StackFilter;

use Clockwork\Request\IncomingRequest;

use Clockwork\Storage\FileStorage;

use Clockwork\Storage\Search;

use Clockwork\Storage\SqlStorage;

use Psr\Http\Message\ServerRequestInterface as PsrRequest;

use Psr\Http\Message\ResponseInterface as PsrResponse;

// Clockwork integration for vanilla php and unsupported frameworks

class Clockwork

{

	// Clockwork config

	protected $config;

	// Clockwork instance

	protected $clockwork;

	// PSR-7 request and response

	protected $psrRequest;

	protected $psrResponse;

	// Whether the headers were already sent (header can be sent manually)

	protected $headersSent = false;

	// Static instance when used as singleton

	protected static $defaultInstance;

	// Create new instance, takes an additional config

	public function __construct($config = [])

	{

		$this->config = array_merge(include __DIR__ . '/config.php', $config);

		$this->clockwork = new BaseClockwork;

		$this->clockwork->addDataSource(new PhpDataSource);

		$this->clockwork->storage($this->makeStorage());

		$this->clockwork->authenticator($this->makeAuthenticator());

		$this->configureSerializer();

		$this->configureShouldCollect();

		$this->configureShouldRecord();

		if ($this->config['register_helpers']) include __DIR__ . '/helpers.php';

	}

	// Initialize a singleton instance, takes an additional config

	public static function init($config = [])

	{

		return static::$defaultInstance = new static($config);

	}

	// Return the singleton instance

	public static function instance()

	{

		return static::$defaultInstance;

	}

	// Resolves and records the current request and sends Clockwork headers, should be called at the end of app

	// execution, return PSR-7 response if one was set

	public function requestProcessed()

	{

		if (! $this->config['enable'] && ! $this->config['collect_data_always']) return $this->psrResponse;

		if (! $this->clockwork->shouldCollect()->filter($this->incomingRequest())) return $this->psrResponse;

		if (! $this->clockwork->shouldRecord()->filter($this->clockwork->request())) return $this->psrResponse;

		$this->clockwork->resolveRequest()->storeRequest();

		if (! $this->config['enable']) return $this->psrResponse;

		$this->sendHeaders();

		if (($eventsCount = $this->config['server_timing']) !== false) {

			$this->setHeader('Server-Timing', ServerTiming::fromRequest($this->clockwork->request(), $eventsCount)->value());

		}

		return $this->psrResponse;

	}

	// Resolves and records the current request as a command, should be called at the end of app execution

	public function commandExecuted($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)

	{

		if (! $this->config['enable'] && ! $this->config['collect_data_always']) return;

		if (! $this->clockwork->shouldRecord()->filter($this->clockwork->request())) return;

		$this->clockwork

			->resolveAsCommand($name, $exitCode, $arguments, $options, $argumentsDefaults, $optionsDefaults, $output)

			->storeRequest();

	}

	// Resolves and records the current request as a queue job, should be called at the end of app execution

	public function queueJobExecuted($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])

	{

		if (! $this->config['enable'] && ! $this->config['collect_data_always']) return;

		if (! $this->clockwork->shouldRecord()->filter($this->clockwork->request())) return;

		$this->clockwork

			->resolveAsQueueJob($name, $description, $status, $payload, $queue, $connection, $options)

			->storeRequest();

	}

	// Manually send the Clockwork headers, this should be manually called only when the headers need to be sent early

	// in the request processing

	public function sendHeaders()

	{

		if (! $this->config['enable'] || $this->headersSent) return;

		$this->headersSent = true;

		$clockworkRequest = $this->request();

		$this->setHeader('X-Clockwork-Id', $clockworkRequest->id);

		$this->setHeader('X-Clockwork-Version', BaseClockwork::VERSION);

		if ($this->config['api'] != '/__clockwork/') {

			$this->setHeader('X-Clockwork-Path', $this->config['api']);

		}

		foreach ($this->config['headers'] as $headerName => $headerValue) {

			$this->setHeader("X-Clockwork-Header-{$headerName}", $headerValue);

		}

		if ($this->config['features']['performance']['client_metrics'] || $this->config['toolbar']) {

			$this->setCookie('x-clockwork', $this->getCookiePayload(), time() + 60);

		}

	}

	// Returns the x-clockwork cookie payload in case you need to set the cookie yourself (cookie can't be http only,

	// expiration time should be 60 seconds)

	public function getCookiePayload()

	{

		$clockworkRequest = $this->request();

		return json_encode([

			'requestId' => $clockworkRequest->id,

			'version'   => BaseClockwork::VERSION,

			'path'      => $this->config['api'],

			'webPath'   => $this->config['web']['enable'],

			'token'     => $clockworkRequest->updateToken,

			'metrics'   => $this->config['features']['performance']['client_metrics'],

			'toolbar'   => $this->config['toolbar']

		]);

	}

	// Handle Clockwork REST api request, retrieves or updates Clockwork metadata

	public function handleMetadata($request = null, $method = null)

	{

		if (! $request) $request = isset($_GET['request']) ? $_GET['request'] : '';

		if (! $method) $method = isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : 'GET';

		if ($method == 'POST' && $request == 'auth') return $this->authenticate();

		return $method == 'POST' ? $this->updateMetadata($request) : $this->returnMetadata($request);

	}

	// Retrieve metadata based on the passed Clockwork REST api request and send HTTP response

	public function returnMetadata($request = null)

	{

		if (! $this->config['enable']) return $this->response(null, 404);

		$authenticator = $this->clockwork->authenticator();

		$authenticated = $authenticator->check(isset($_SERVER['HTTP_X_CLOCKWORK_AUTH']) ? $_SERVER['HTTP_X_CLOCKWORK_AUTH'] : '');

		if ($authenticated !== true) {

			return $this->response([ 'message' => $authenticated, 'requires' => $authenticator->requires() ], 403);

		}

		return $this->response($this->getMetadata($request));

	}

	// Returns metadata based on the passed Clockwork REST api request

	public function getMetadata($request = null)

	{

		if (! $this->config['enable']) return;

		$authenticator = $this->clockwork->authenticator();

		$authenticated = $authenticator->check(isset($_SERVER['HTTP_X_CLOCKWORK_AUTH']) ? $_SERVER['HTTP_X_CLOCKWORK_AUTH'] : '');

		if ($authenticated !== true) return;

		if (! $request) $request = isset($_GET['request']) ? $_GET['request'] : '';

		preg_match('#(?<id>[0-9-]+|latest)(?:/(?<direction>next|previous))?(?:/(?<count>\d+))?#', $request, $matches);

		$id = isset($matches['id']) ? $matches['id'] : null;

		$direction = isset($matches['direction']) ? $matches['direction'] : null;

		$count = isset($matches['count']) ? $matches['count'] : null;

		if ($direction == 'previous') {

			$data = $this->clockwork->storage()->previous($id, $count, Search::fromRequest($_GET));

		} elseif ($direction == 'next') {

			$data = $this->clockwork->storage()->next($id, $count, Search::fromRequest($_GET));

		} elseif ($id == 'latest') {

			$data = $this->clockwork->storage()->latest(Search::fromRequest($_GET));

		} else {

			$data = $this->clockwork->storage()->find($id);

		}

		if (preg_match('#(?<id>[0-9-]+|latest)/extended#', $request)) {

			$this->clockwork->extendRequest($data);

		}

		if ($data) {

			$data = is_array($data) ? array_map(function ($item) { return $item->toArray(); }, $data) : $data->toArray();

		}

		return $data;

	}

	// Update metadata based on the passed Clockwork REST api request and send HTTP response

	public function updateMetadata($request = null)

	{

		if (! $this->config['enable'] || ! $this->config['features']['performance']['client_metrics']) {

			return $this->response(null, 404);

		}

		if (! $request) $request = isset($_GET['request']) ? $_GET['request'] : '';

		$storage = $this->clockwork->storage();

		$request = $storage->find($request);

		if (! $request) {

			return $this->response([ 'message' => 'Request not found.' ], 404);

		}

		$input = json_decode(file_get_contents('php://input'), true);

		$token = isset($input['_token']) ? $input['_token'] : '';

		if (! $request->updateToken || ! hash_equals($request->updateToken, $token)) {

			return $this->response([ 'message' => 'Invalid update token.' ], 403);

		}

		foreach ($input as $key => $value) {

			if (in_array($key, [ 'clientMetrics', 'webVitals' ])) {

				$request->$key = $value;

			}

		}

		$storage->update($request);

		return $this->response();

	}

	// Authanticates access to Clockwork REST api

	public function authenticate($request = null)

	{

		if (! $this->config['enable']) return;

		if (! $request) $request = isset($_GET['request']) ? $_GET['request'] : '';

		$token = $this->clockwork->authenticator()->attempt([

			'username' => isset($_POST['username']) ? $_POST['username'] : '',

			'password' => isset($_POST['password']) ? $_POST['password'] : ''

		]);

		return $this->response([ 'token' => $token ], $token ? 200 : 403);

	}

	// Returns the Clockwork Web UI as a HTTP response, installs the Web UI on the first run

	public function returnWeb()

	{

		if (! $this->config['web']['enable']) return;

		$this->installWeb();

		$asset = function ($uri) { return "{$this->config['web']['uri']}/{$uri}"; };

		$metadataPath = $this->config['api'];

		$url = $this->config['web']['uri'];

		if (! preg_match('#/index.html$#', $url)) {

			$url = rtrim($url, '/') . '/index.html';

		}

		ob_start();

		include __DIR__ . '/iframe.html.php';

		$html = ob_get_clean();

		return $this->response($html, null, false);

	}

	// Installs the Web UI by copying the assets to the public directory, no-op if already installed

	public function installWeb()

	{

		$path = $this->config['web']['path'];

		$source = __DIR__ . '/../../Web/public';

		if (file_exists("{$path}/index.html")) return;

		@mkdir($path, 0755, true);

		$iterator = new \RecursiveIteratorIterator(

			new \RecursiveDirectoryIterator($source, \RecursiveDirectoryIterator::SKIP_DOTS),

			\RecursiveIteratorIterator::SELF_FIRST

		);

		foreach ($iterator as $item) {

			if ($item->isDir()) {

				mkdir("{$path}/" . $iterator->getSubPathName());

			} else {

				copy($item, "{$path}/" . $iterator->getSubPathName());

			}

		}

	}

	// Use a PSR-7 request and response instances instead of vanilla php HTTP apis

	public function usePsrMessage(PsrRequest $request, PsrResponse $response = null)

	{

		$this->psrRequest = $request;

		$this->psrResponse = $response;

		$this->clockwork->addDataSource(new PsrMessageDataSource($request, $response));

		return $this;

	}

	// Make a storage implementation based on user configuration

	protected function makeStorage()

	{

		if ($this->config['storage'] == 'sql') {

			$database = $this->config['storage_sql_database'];

			$table = $this->config['storage_sql_table'];

			$storage = new SqlStorage(

				$this->config['storage_sql_database'],

				$this->config['storage_sql_table'],

				$this->config['storage_sql_username'],

				$this->config['storage_sql_password'],

				$this->config['storage_expiration']

			);

		} else {

			$storage = new FileStorage(

				$this->config['storage_files_path'],

				0700,

				$this->config['storage_expiration'],

				$this->config['storage_files_compress']

			);

		}

		return $storage;

	}

	// Make an authenticator implementation based on user configuration

	protected function makeAuthenticator()

	{

		$authenticator = $this->config['authentication'];

		if (is_string($authenticator)) {

			return new $authenticator;

		} elseif ($authenticator) {

			return new SimpleAuthenticator($this->config['authentication_password']);

		} else {

			return new NullAuthenticator;

		}

	}

	// Configure serializer defaults based on user configuration

	protected function configureSerializer()

	{

		Serializer::defaults([

			'limit'       => $this->config['serialization_depth'],

			'blackbox'    => $this->config['serialization_blackbox'],

			'traces'      => $this->config['stack_traces']['enabled'],

			'tracesSkip'  => StackFilter::make()

				->isNotVendor(array_merge(

					$this->config['stack_traces']['skip_vendors'],

					[ 'itsgoingd', 'laravel', 'illuminate' ]

				))

				->isNotNamespace($this->config['stack_traces']['skip_namespaces'])

				->isNotFunction([ 'call_user_func', 'call_user_func_array' ])

				->isNotClass($this->config['stack_traces']['skip_classes']),

			'tracesLimit' => $this->config['stack_traces']['limit']

		]);

	}

	// Configure should collect rules based on user configuration

	public function configureShouldCollect()

	{

		$this->clockwork->shouldCollect([

			'onDemand'        => $this->config['requests']['on_demand'],

			'sample'          => $this->config['requests']['sample'],

			'except'          => $this->config['requests']['except'],

			'only'            => $this->config['requests']['only'],

			'exceptPreflight' => $this->config['requests']['except_preflight']

		]);

		// don't collect data for Clockwork requests

		$this->clockwork->shouldCollect()->except(preg_quote(rtrim($this->config['api'], '/'), '#'));

	}

	// Configure should record rules based on user configuration

	public function configureShouldRecord()

	{

		$this->clockwork->shouldRecord([

			'errorsOnly' => $this->config['requests']['errors_only'],

			'slowOnly'   => $this->config['requests']['slow_only'] ? $this->config['requests']['slow_threshold'] : false

		]);

	}

	// Set a cookie on PSR-7 response or using vanilla php

	protected function setCookie($name, $value, $expires) {

		if ($this->psrResponse) {

			$this->psrResponse = $this->psrResponse->withAddedHeader(

				'Set-Cookie', "{$name}=" . urlencode($value) . '; expires=' . gmdate('D, d M Y H:i:s T', $expires)

			);

		} else {

			setcookie($name, $value, $expires);

		}

	}

	// Set a header on PSR-7 response or using vanilla php

	protected function setHeader($header, $value)

	{

		if ($this->psrResponse) {

			$this->psrResponse = $this->psrResponse->withHeader($header, $value);

		} else {

			header("{$header}: {$value}");

		}

	}

	// Send a json response, uses the PSR-7 response if set

	protected function response($data = null, $status = null, $json = true)

	{

		if ($json) $this->setHeader('Content-Type', 'application/json');

		if ($this->psrResponse) {

			if ($status) $this->psrResponse = $this->psrResponse->withStatus($status);

			$this->psrResponse->getBody()->write($json ? json_encode($data, \JSON_PARTIAL_OUTPUT_ON_ERROR) : $data);

			return $this->psrResponse;

		} else {

			if ($status) http_response_code($status);

			echo $json ? json_encode($data, \JSON_PARTIAL_OUTPUT_ON_ERROR) : $data;

		}

	}

	// Make a Clockwork incoming request instance

	protected function incomingRequest()

	{

		return new IncomingRequest([

			'method'  => $_SERVER['REQUEST_METHOD'],

			'uri'     => $_SERVER['REQUEST_URI'],

			'input'   => $_REQUEST,

			'cookies' => $_COOKIE

		]);

	}

	// Return the underlying Clockwork instance

	public function getClockwork()

	{

		return $this->clockwork;

	}

	// Pass any method calls to the underlying Clockwork instance

	public function __call($method, $args = [])

	{

		return $this->clockwork->$method(...$args);

	}

	// Pass any static method calls to the underlying Clockwork instance

	public static function __callStatic($method, $args = [])

	{

		return static::instance()->$method(...$args);

	}

}