Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Storage;

use Clockwork\Clockwork;

use Clockwork\Request\Request;

use PDO;

// SQL storage for requests using PDO

class SqlStorage extends Storage

{

	// PDO instance

	protected $pdo;

	// Name of the table with Clockwork requests metadata

	protected $table;

	// Metadata expiration time in minutes

	protected $expiration;

	// Schema for the Clockwork requests table

	protected $fields = [

		'id'                       => 'VARCHAR(100) PRIMARY KEY',

		'version'                  => 'INTEGER',

		'type'                     => 'VARCHAR(100) NULL',

		'time'                     => 'DOUBLE PRECISION NULL',

		'method'                   => 'VARCHAR(10) NULL',

		'url'                      => 'TEXT NULL',

		'uri'                      => 'TEXT NULL',

		'headers'                  => 'TEXT NULL',

		'controller'               => 'VARCHAR(250) NULL',

		'getData'                  => 'TEXT NULL',

		'postData'                 => 'TEXT NULL',

		'requestData'              => 'TEXT NULL',

		'sessionData'              => 'TEXT NULL',

		'authenticatedUser'        => 'TEXT NULL',

		'cookies'                  => 'TEXT NULL',

		'responseTime'             => 'DOUBLE PRECISION NULL',

		'responseStatus'           => 'INTEGER NULL',

		'responseDuration'         => 'DOUBLE PRECISION NULL',

		'memoryUsage'              => 'DOUBLE PRECISION NULL',

		'middleware'               => 'TEXT NULL',

		'databaseQueries'          => 'TEXT NULL',

		'databaseQueriesCount'     => 'INTEGER NULL',

		'databaseSlowQueries'      => 'INTEGER NULL',

		'databaseSelects'          => 'INTEGER NULL',

		'databaseInserts'          => 'INTEGER NULL',

		'databaseUpdates'          => 'INTEGER NULL',

		'databaseDeletes'          => 'INTEGER NULL',

		'databaseOthers'           => 'INTEGER NULL',

		'databaseDuration'         => 'DOUBLE PRECISION NULL',

		'cacheQueries'             => 'TEXT NULL',

		'cacheReads'               => 'INTEGER NULL',

		'cacheHits'                => 'INTEGER NULL',

		'cacheWrites'              => 'INTEGER NULL',

		'cacheDeletes'             => 'INTEGER NULL',

		'cacheTime'                => 'DOUBLE PRECISION NULL',

		'modelsActions'            => 'TEXT NULL',

		'modelsRetrieved'          => 'TEXT NULL',

		'modelsCreated'            => 'TEXT NULL',

		'modelsUpdated'            => 'TEXT NULL',

		'modelsDeleted'            => 'TEXT NULL',

		'redisCommands'            => 'TEXT NULL',

		'queueJobs'                => 'TEXT NULL',

		'timelineData'             => 'TEXT NULL',

		'log'                      => 'TEXT NULL',

		'events'                   => 'TEXT NULL',

		'routes'                   => 'TEXT NULL',

		'notifications'            => 'TEXT NULL',

		'emailsData'               => 'TEXT NULL',

		'viewsData'                => 'TEXT NULL',

		'userData'                 => 'TEXT NULL',

		'subrequests'              => 'TEXT NULL',

		'xdebug'                   => 'TEXT NULL',

		'commandName'              => 'TEXT NULL',

		'commandArguments'         => 'TEXT NULL',

		'commandArgumentsDefaults' => 'TEXT NULL',

		'commandOptions'           => 'TEXT NULL',

		'commandOptionsDefaults'   => 'TEXT NULL',

		'commandExitCode'          => 'INTEGER NULL',

		'commandOutput'            => 'TEXT NULL',

		'jobName'                  => 'TEXT NULL',

		'jobDescription'           => 'TEXT NULL',

		'jobStatus'                => 'TEXT NULL',

		'jobPayload'               => 'TEXT NULL',

		'jobQueue'                 => 'TEXT NULL',

		'jobConnection'            => 'TEXT NULL',

		'jobOptions'               => 'TEXT NULL',

		'testName'                 => 'TEXT NULL',

		'testStatus'               => 'TEXT NULL',

		'testStatusMessage'        => 'TEXT NULL',

		'testAsserts'              => 'TEXT NULL',

		'clientMetrics'            => 'TEXT NULL',

		'webVitals'                => 'TEXT NULL',

		'parent'                   => 'TEXT NULL',

		'updateToken'              => 'VARCHAR(100) NULL'

	];

	// List of Request keys that need to be serialized before they can be stored in database

	protected $needsSerialization = [

		'headers', 'getData', 'postData', 'requestData', 'sessionData', 'authenticatedUser', 'cookies', 'middleware',

		'databaseQueries', 'cacheQueries', 'modelsActions', 'modelsRetrieved', 'modelsCreated', 'modelsUpdated',

		'modelsDeleted', 'redisCommands', 'queueJobs', 'timelineData', 'log', 'events', 'routes', 'notifications',

		'emailsData', 'viewsData', 'userData', 'subrequests', 'xdebug', 'commandArguments', 'commandArgumentsDefaults',

		'commandOptions', 'commandOptionsDefaults', 'jobPayload', 'jobOptions', 'testAsserts', 'parent',

		'clientMetrics', 'webVitals'

	];

	// Return a new storage, takes PDO object or DSN and optionally a table name and database credentials as arguments

	public function __construct($dsn, $table = 'clockwork', $username = null, $password = null, $expiration = null)

	{

		$this->pdo = $dsn instanceof PDO ? $dsn : new PDO($dsn, $username, $password);

		$this->table = $table;

		$this->expiration = $expiration === null ? 60 * 24 * 7 : $expiration;

	}

	// Returns all requests

	public function all(Search $search = null)

	{

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$search = SqlSearch::fromBase($search, $this->pdo);

		$result = $this->query("SELECT {$fields} FROM {$this->table} {$search->query}", $search->bindings);

		return $this->resultsToRequests($result);

	}

	// Return a single request by id

	public function find($id)

	{

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$result = $this->query("SELECT {$fields} FROM {$this->table} WHERE id = :id", [ 'id' => $id ]);

		$requests = $this->resultsToRequests($result);

		return end($requests);

	}

	// Return the latest request

	public function latest(Search $search = null)

	{

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$search = SqlSearch::fromBase($search, $this->pdo);

		$result = $this->query(

			"SELECT {$fields} FROM {$this->table} {$search->query} ORDER BY id DESC LIMIT 1", $search->bindings

		);

		$requests = $this->resultsToRequests($result);

		return end($requests);

	}

	// Return requests received before specified id, optionally limited to specified count

	public function previous($id, $count = null, Search $search = null)

	{

		$count = (int) $count;

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$search = SqlSearch::fromBase($search, $this->pdo)->addCondition('id < :id', [ 'id' => $id ]);

		$limit = $count ? "LIMIT {$count}" : '';

		$result = $this->query(

			"SELECT {$fields} FROM {$this->table} {$search->query} ORDER BY id DESC {$limit}", $search->bindings

		);

		return array_reverse($this->resultsToRequests($result));

	}

	// Return requests received after specified id, optionally limited to specified count

	public function next($id, $count = null, Search $search = null)

	{

		$count = (int) $count;

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$search = SqlSearch::fromBase($search, $this->pdo)->addCondition('id > :id', [ 'id' => $id ]);

		$limit = $count ? "LIMIT {$count}" : '';

		$result = $this->query(

			"SELECT {$fields} FROM {$this->table} {$search->query} ORDER BY id ASC {$limit}", $search->bindings

		);

		return $this->resultsToRequests($result);

	}

	// Store the request in the database

	public function store(Request $request)

	{

		$data = $request->toArray();

		foreach ($this->needsSerialization as $key) {

			$data[$key] = @json_encode($data[$key], \JSON_PARTIAL_OUTPUT_ON_ERROR);

		}

		$fields = implode(', ', array_map(function ($field) { return $this->quote($field); }, array_keys($this->fields)));

		$bindings = implode(', ', array_map(function ($field) { return ":{$field}"; }, array_keys($this->fields)));

		$this->query("INSERT INTO {$this->table} ($fields) VALUES ($bindings)", $data);

		$this->cleanup();

	}

	// Update an existing request in the database

	public function update(Request $request)

	{

		$data = $request->toArray();

		foreach ($this->needsSerialization as $key) {

			$data[$key] = @json_encode($data[$key], \JSON_PARTIAL_OUTPUT_ON_ERROR);

		}

		$values = implode(', ', array_map(function ($field) {

			return $this->quote($field) . " = :{$field}";

		}, array_keys($this->fields)));

		$this->query("UPDATE {$this->table} SET {$values} WHERE id = :id", $data);

		$this->cleanup();

	}

	// Cleanup old requests

	public function cleanup()

	{

		if ($this->expiration === false) return;

		$this->query("DELETE FROM {$this->table} WHERE time < :time", [ 'time' => time() - ($this->expiration * 60) ]);

	}

	// Create or update the Clockwork metadata table

	protected function initialize()

	{

		// first we get rid of existing table if it exists by renaming it so we won't lose any data

		try {

			$table = $this->quote($this->table);

			$backupTableName = $this->quote("{$this->table}_backup_" . date('Ymd'));

			$this->pdo->exec("ALTER TABLE {$table} RENAME TO {$backupTableName};");

		} catch (\PDOException $e) {

			// this just means the table doesn't yet exist, nothing to do here

		}

		// create the metadata table

		$this->pdo->exec($this->buildSchema($table));

		$indexName = $this->quote("{$this->table}_time_index");

		$this->pdo->exec("CREATE INDEX {$indexName} ON {$table} (". $this->quote('time') .')');

	}

	// Builds the query to create Clockwork database table

	protected function buildSchema($table)

	{

		$textType = $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql' ? 'MEDIUMTEXT' : 'TEXT';

		$columns = implode(', ', array_map(function ($field, $type) use ($textType) {

			return $this->quote($field) . ' ' . str_replace('TEXT', $textType, $type);

		}, array_keys($this->fields), array_values($this->fields)));

		return "CREATE TABLE {$table} ({$columns});";

	}

	// Executes an sql query, lazily initiates the clockwork database schema if it's old or doesn't exist yet, returns

	// executed statement or false on error

	protected function query($query, array $bindings = [], $firstTry = true)

	{

		try {

			if ($stmt = $this->pdo->prepare($query)) {

				if ($stmt->execute($bindings)) return $stmt;

				throw new \PDOException;

			}

		} catch (\PDOException $e) {

			$stmt = false;

		}

		// the query failed to execute, assume it's caused by missing or old schema, try to reinitialize database

		if (! $stmt && $firstTry) {

			$this->initialize();

			return $this->query($query, $bindings, false);

		}

	}

	// Quotes SQL identifier name properly for the current database

	protected function quote($identifier)

	{

		return $this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql' ? "`{$identifier}`" : "\"{$identifier}\"";

	}

	// Returns array of Requests instances from the executed PDO statement

	protected function resultsToRequests($stmt)

	{

		return array_map(function ($data) {

			return $this->dataToRequest($data);

		}, $stmt->fetchAll(PDO::FETCH_ASSOC));

	}

	// Returns a Request instance from a single database record

	protected function dataToRequest($data)

	{

		foreach ($this->needsSerialization as $key) {

			$data[$key] = json_decode($data[$key], true);

		}

		return new Request($data);

	}

}