Subversion-Projekte lars-tiefland.laravel_shop

<?php namespace Clockwork\Storage;

use Clockwork\Request\Request;

use Clockwork\Storage\Storage;

// File based storage for requests

class FileStorage extends Storage

{

	// Path where files are stored

	protected $path;

	// Metadata expiration time in minutes

	protected $expiration;

	// Compress the files using gzip

	protected $compress;

	// Metadata cleanup chance

	protected $cleanupChance = 100;

	// Index file handle

	protected $indexHandle;

	// Return new storage, takes path where to store files as argument, throws exception if path is not writable

	public function __construct($path, $dirPermissions = 0700, $expiration = null, $compress = false)

	{

		if (! file_exists($path)) {

			// directory doesn't exist, try to create one

			if (! @mkdir($path, $dirPermissions, true)) {

				throw new \Exception("Directory \"{$path}\" does not exist.");

			}

			// create default .gitignore, to ignore stored json files

			file_put_contents("{$path}/.gitignore", "*.json\n*.json.gz\nindex\n");

		} elseif (! is_writable($path)) {

			throw new \Exception("Path \"{$path}\" is not writable.");

		}

		if (! file_exists($indexFile = "{$path}/index")) {

			file_put_contents($indexFile, '');

		} elseif (! is_writable($indexFile)) {

			throw new \Exception("Path \"{$indexFile}\" is not writable.");

		}

		$this->path = $path;

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

		$this->compress = $compress;

	}

	// Returns all requests

	public function all(Search $search = null)

	{

		return $this->loadRequests($this->searchIndexForward($search));

	}

	// Return a single request by id

	public function find($id)

	{

		return $this->loadRequest($id);

	}

	// Return the latest request

	public function latest(Search $search = null)

	{

		$requests = $this->loadRequests($this->searchIndexBackward($search, null, 1));

		return reset($requests);

	}

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

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

	{

		return $this->loadRequests($this->searchIndexBackward($search, $id, $count));

	}

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

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

	{

		return $this->loadRequests($this->searchIndexForward($search, $id, $count));

	}

	// Store request, requests are stored in JSON representation in files named <request id>.json in storage path

	public function store(Request $request, $skipIndex = false)

	{

		$path = "{$this->path}/{$request->id}.json";

		$data = @json_encode($request->toArray(), \JSON_PARTIAL_OUTPUT_ON_ERROR);

		$this->compress

			? file_put_contents("{$path}.gz", gzcompress($data))

			: file_put_contents($path, $data);

		if (! $skipIndex) $this->updateIndex($request);

		$this->cleanup();

	}

	// Update existing request

	public function update(Request $request)

	{

		return $this->store($request, true);

	}

	// Cleanup old requests

	public function cleanup($force = false)

	{

		if ($this->expiration === false || (! $force && rand(1, $this->cleanupChance) != 1)) return;

		$this->openIndex('start', true, true); // reopen index with lock

		$expirationTime = time() - ($this->expiration * 60);

		$old = $this->searchIndexForward(

			new Search([ 'received' => [ '<' . date('c', $expirationTime) ] ], [ 'stopOnFirstMismatch' => true ])

		);

		if (! count($old)) return $this->closeIndex(true);

		$this->readPreviousIndex();

		$this->trimIndex();

		$this->closeIndex(true); // explicitly close index to unlock asap

		foreach ($old as $id) {

			$path = "{$this->path}/{$id}.json";

			@unlink($this->compress ? "{$path}.gz" : $path);

		}

	}

	// Load a single request by id from filesystem

	protected function loadRequest($id)

	{

		$path = "{$this->path}/{$id}.json";

		if (! is_readable($this->compress ? "{$path}.gz" : $path)) return;

		$data = file_get_contents($this->compress ? "{$path}.gz" : $path);

		return new Request(json_decode($this->compress ? gzuncompress($data) : $data, true));

	}

	// Load multiple requests by ids from filesystem

	protected function loadRequests($ids)

	{

		return array_filter(array_map(function ($id) { return $this->loadRequest($id); }, $ids));

	}

	// Search index backward from specified ID or last record, with optional results count limit

	protected function searchIndexBackward(Search $search = null, $id = null, $count = null)

	{

		return $this->searchIndex('previous', $search, $id, $count);

	}

	// Search index forward from specified ID or last record, with optional results count limit

	protected function searchIndexForward(Search $search = null, $id = null, $count = null)

	{

		return $this->searchIndex('next', $search, $id, $count);

	}

	// Search index in specified direction from specified ID or last record, with optional results count limit

	protected function searchIndex($direction, Search $search = null, $id = null, $count = null)

	{

		$this->openIndex($direction == 'previous' ? 'end' : 'start', false, true);

		if ($id) {

			while ($request = $this->readIndex($direction)) { if ($request->id == $id) break; }

		}

		$found = [];

		while ($request = $this->readIndex($direction)) {

			if (! $search || $search->matches($request)) {

				$found[] = $request->id;

			} elseif ($search->stopOnFirstMismatch) {

				break;

			}

			if ($count && count($found) == $count) break;

		}

		return $direction == 'next' ? $found : array_reverse($found);

	}

	// Open index file, optionally lock or move file pointer to the end, existing handle will be returned by default

	protected function openIndex($position = 'start', $lock = false, $force = false)

	{

		if ($this->indexHandle) {

			if (! $force) return;

			$this->closeIndex();

		}

		$this->indexHandle = fopen("{$this->path}/index", 'r');

		if ($lock) flock($this->indexHandle, LOCK_EX);

		if ($position == 'end') fseek($this->indexHandle, 0, SEEK_END);

	}

	// Close index file, optionally unlock

	protected function closeIndex($lock = false)

	{

		if ($lock) flock($this->indexHandle, LOCK_UN);

		fclose($this->indexHandle);

		$this->indexHandle = null;

	}

	// Read a line from index in the specified direction (next or previous)

	protected function readIndex($direction)

	{

		return $direction == 'next' ? $this->readNextIndex() : $this->readPreviousIndex();

	}

	// Read previous line from index

	protected function readPreviousIndex()

	{

		$position = ftell($this->indexHandle) - 1;

		if ($position <= 0) return;

		$line = '';

		// reads 1024B chunks of the file backwards from the current position, until a newline is found or we reach the top

		while ($position > 0) {

			// find next position to read from, make sure we don't read beyond file boundary

			$position -= $chunkSize = min($position, 1024);

			// read the chunk from the position

			fseek($this->indexHandle, $position);

			$chunk = fread($this->indexHandle, $chunkSize);

			// if a newline is found, append only the part after the last newline, otherwise we can append the whole chunk

			$line = ($newline = strrpos($chunk, "\n")) === false

				? $chunk . $line : substr($chunk, $newline + 1) . $line;

			// if a newline was found, fix the position so we read from that newline next time

			if ($newline !== false) $position += $newline + 1;

			// move file pointer to the correct position (revert fread, apply newline fix)

			fseek($this->indexHandle, $position);

			// if we reached a newline and put together a non-empty line we are done

			if ($newline !== false) break;

		}

		return $this->makeRequestFromIndex(str_getcsv($line));

	}

	// Read next line from index

	protected function readNextIndex()

	{

		if (feof($this->indexHandle)) return;

		// File pointer is always at the start of the line, call extra fgets to skip current line

		fgets($this->indexHandle);

		$line = fgets($this->indexHandle);

		// Check if we read an empty line or reached the end of file

		if ($line === false) return;

		// Reset the file pointer to the start of the read line

		fseek($this->indexHandle, ftell($this->indexHandle) - strlen($line));

		return $this->makeRequestFromIndex(str_getcsv($line));

	}

	// Trim index file from beginning to current position (including)

	protected function trimIndex()

	{

		// File pointer is always at the start of the line, call extra fgets to skip current line

		fgets($this->indexHandle);

		// Read the rest of the index file

		$trimmedLength = filesize("{$this->path}/index") - ftell($this->indexHandle);

		$trimmed = $trimmedLength > 0 ? fread($this->indexHandle, $trimmedLength) : '';

		// Rewrite the index file with a trimmed version

		file_put_contents("{$this->path}/index", $trimmed);

	}

	// Create an incomplete request from index data

	protected function makeRequestFromIndex($record)

	{

		$type = isset($record[7]) ? $record[7] : 'response';

		if ($type == 'command') {

			$nameField = 'commandName';

		} elseif ($type == 'queue-job') {

			$nameField = 'jobName';

		} elseif ($type == 'test') {

			$nameField = 'testName';

		} else {

			$nameField = 'uri';

		}

		return new Request(array_combine(

			[ 'id', 'time', 'method', $nameField, 'controller', 'responseStatus', 'responseDuration', 'type' ],

			array_slice($record, 0, 8) + [ null, null, null, null, null, null, null, 'response' ]

		));

	}

	// Update index with a new request

	protected function updateIndex(Request $request)

	{

		$handle = fopen("{$this->path}/index", 'a');

		if (! $handle) return;

		if (! flock($handle, LOCK_EX)) return fclose($handle);

		if ($request->type == 'command') {

			$nameField = 'commandName';

		} elseif ($request->type == 'queue-job') {

			$nameField = 'jobName';

		} elseif ($request->type == 'test') {

			$nameField = 'testName';

		} else {

			$nameField = 'uri';

		}

		fputcsv($handle, [

			$request->id,

			$request->time,

			$request->method,

			$request->$nameField,

			$request->controller,

			$request->responseStatus,

			$request->getResponseDuration(),

			$request->type

		]);

		flock($handle, LOCK_UN);

		fclose($handle);

	}

}