Client::getClient() - Code Metrics - Inspection of "Add support for tus concatenation extension" - ankitpokhrel/tus-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#11)

by Ankit

created 2018-01-31 16:02 UTC

Client::getClient() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace TusPhp\Tus;

use TusPhp\File;
use TusPhp\Cache\Cacheable;
use TusPhp\Exception\Exception;
use TusPhp\Exception\FileException;
use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Exception\ClientException;
use TusPhp\Exception\ConnectionException;
use GuzzleHttp\Exception\ConnectException;
use Illuminate\Http\Response as HttpResponse;

class Client extends AbstractTus
{
    /** @var GuzzleClient */
    protected $client;

    /** @var string */
    protected $apiPath = '/files';

    /** @var string */
    protected $filePath;

    /** @var int */
    protected $fileSize;

    /** @var string */
    protected $fileName;

    /** @var string */
    protected $checksum;

    /** @var int */
    protected $partialOffset = -1;

    /** @var bool */
    protected $partial = false;

    /** @var string */
    protected $checksumAlgorithm = 'sha256';

    /**
     * Client constructor.
     *
     * @param string           $baseUrl
     * @param Cacheable|string $cacheAdapter
     */
    public function __construct(string $baseUrl, $cacheAdapter = 'file')
    {
        $this->client = new GuzzleClient([
            'base_uri' => $baseUrl,
        ]);

        $this->setCache($cacheAdapter);
    }

    /**
     * Set file properties.
     *
     * @param string $file File path.
     * @param string $name File name.
     *
     * @return Client
     */
    public function file(string $file, string $name = null) : self
    {
        $this->filePath = $file;

        if ( ! file_exists($file) || ! is_readable($file)) {
            throw new FileException('Cannot read file: ' . $file);
        }

        $this->fileName = $name ?? basename($this->filePath);
        $this->fileSize = filesize($file);

        return $this;
    }

    /**
     * Get file path.
     *
     * @return string|null
     */
    public function getFilePath()
    {
        return $this->filePath;
    }

    /**
     * Set file name.
     *
     * @param string $name
     *
     * @return Client
     */
    public function setFileName(string $name) : self
    {
        $this->fileName = $name;

        return $this;
    }

    /**
     * Get file name.
     *
     * @return string|null
     */
    public function getFileName()
    {
        return $this->fileName;
    }

    /**
     * Get file size.
     *
     * @return int|null
     */
    public function getFileSize()
    {
        return $this->fileSize;
    }

    /**
     * Set API path.
     *
     * @param string $path
     *
     * @return Client
     */
    public function setApiPath(string $path) : self
    {
        $this->apiPath = $path;

        return $this;
    }

    /**
     * Get API path.
     *
     * @return string
     */
    public function getApiPath() : string
    {
        return $this->apiPath;
    }

    /**
     * Get guzzle client.
     *
     * @return GuzzleClient
     */
    public function getClient() : GuzzleClient
    {
        return $this->client;
    }

    /**
     * Get checksum.
     *
     * @return string
     */
    public function getChecksum() : string
    {
        if (empty($this->checksum)) {
            $this->checksum = hash_file($this->getChecksumAlgorithm(), $this->getFilePath());
        }

        return $this->checksum;
    }

    /**
     * Set checksum algorithm.
     *
     * @param string $algorithm
     *
     * @return Client
     */
    public function setChecksumAlgorithm(string $algorithm) : self
    {
        $this->checksumAlgorithm = $algorithm;

        return $this;
    }

    /**
     * Get checksum algorithm.
     *
     * @return string
     */
    public function getChecksumAlgorithm() : string
    {
        return $this->checksumAlgorithm;
    }

    /**
     * Check if this is a partial upload request.
     *
     * @return bool
     */
    public function isPartial() : bool
    {
        return $this->partial;
    }

    /**
     * Get partial offset.
     * @return int
     */
    public function getPartialOffset() : int
    {
        return $this->partialOffset;
    }

    /**
     * Set offset and force this to be a partial upload request.
     *
     * @param int $offset
     *
     * @return $this
     */
    public function seek(int $offset)
    {
        $this->partialOffset = $offset;

        $this->partial();

        return $this;
    }

    /**
     * Upload file.
     *
     * @param int $bytes Bytes to upload
     *
     * @throws ConnectionException
     *
     * @return int
     */
    public function upload(int $bytes = -1) : int
    {
        $bytes    = $bytes < 0 ? $this->getFileSize() : $bytes;
        $checksum = $this->getChecksum();

        try {
            // Check if this upload exists with HEAD request
            $this->sendHeadRequest($checksum);
        } catch (FileException | ClientException $e) {
            $this->create($checksum);
        } catch (ConnectException $e) {
            throw new ConnectionException("Couldn't connect to server.");
        }

        // Now, resume upload with PATCH request
        return $this->sendPatchRequest($checksum, $bytes);
    }

    /**
     * Returns offset if file is partially uploaded.
     *
     * @return bool|int
     */
    public function getOffset()
    {
        $checksum = $this->getChecksum();

        try {
            $offset = $this->sendHeadRequest($checksum);
        } catch (FileException | ClientException $e) {
            return false;
        }

        return $offset;
    }

    /**
     * Create resource with POST request.
     *
     * @param string $checksum
     *
     * @throws FileException
     *
     * @return string
     */
    public function create(string $checksum) : string
    {
        $headers = [
            'Upload-Length' => $this->fileSize,
            'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
            'Upload-Metadata' => 'filename ' . base64_encode($this->fileName),
        ];

        if ($this->isPartial()) {
            $headers += ['Upload-Concat' => 'partial'];
        }

        $response = $this->getClient()->post($this->apiPath, [
            'headers' => $headers,
        ]);

        $data       = json_decode($response->getBody(), true);
        $checksum   = $data['data']['checksum'] ?? null;
        $statusCode = $response->getStatusCode();

        if (HttpResponse::HTTP_CREATED !== $statusCode || ! $checksum) {
            throw new FileException('Unable to create resource.');
        }

        return $checksum;
    }

    /**
     * Concatenate 2 or more partial uploads.
     *
     * @param string $checksum
     * @param array  $partials
     *
     * @return string
     */
    public function concat(string $checksum, ...$partials) : string
    {
        $response = $this->getClient()->post($this->apiPath, [
            'headers' => [
                'Upload-Length' => $this->fileSize,
                'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
                'Upload-Metadata' => 'filename ' . base64_encode($this->fileName),
                'Upload-Concat' => self::UPLOAD_TYPE_FINAL . ';' . implode(' ', $partials),
            ],
        ]);

        $data       = json_decode($response->getBody(), true);
        $checksum   = $data['data']['checksum'] ?? null;
        $statusCode = $response->getStatusCode();

        if (HttpResponse::HTTP_CREATED !== $statusCode || ! $checksum) {
            throw new FileException('Unable to create resource.');
        }

        return $checksum;
    }

    /**
     * Send DELETE request.
     *
     * @param string $checksum
     *
     * @throws FileException
     *
     * @return void
     */
    public function delete(string $checksum)
    {
        try {
            $this->getClient()->delete($this->apiPath . '/' . $checksum, [
                'headers' => [
                    'Tus-Resumable' => self::TUS_PROTOCOL_VERSION,
                ],
            ]);
        } catch (ClientException $e) {
            $statusCode = $e->getResponse()->getStatusCode();

            if (HttpResponse::HTTP_NOT_FOUND === $statusCode || HttpResponse::HTTP_GONE === $statusCode) {
                throw new FileException('File not found.');
            }
        }
    }

    /**
     * Set as partial request.
     *
     * @param bool $state
     */
    protected function partial(bool $state = true)
    {
        $this->partial = $state;

        if ( ! $this->partial) {
            return;
        }

        $checksum = $this->getChecksum();

        if (false !== strpos($checksum, self::PARTIAL_UPLOAD_NAME_SEPARATOR)) {
            list($checksum) = explode(self::PARTIAL_UPLOAD_NAME_SEPARATOR, $checksum);
        }

        $this->checksum = $checksum . uniqid(self::PARTIAL_UPLOAD_NAME_SEPARATOR);
    }

    /**
     * Send HEAD request.
     *
     * @param string $checksum
     *
     * @throws FileException
     *
     * @return int
     */
    protected function sendHeadRequest(string $checksum) : int
    {
        $response = $this->getClient()->head($this->apiPath . '/' . $checksum);

        $statusCode = $response->getStatusCode();

        if (HttpResponse::HTTP_OK !== $statusCode) {
            throw new FileException('File not found.');
        }

        return (int) current($response->getHeader('upload-offset'));
    }

    /**
     * Send PATCH request.
     *
     * @param string $checksum
     * @param int    $bytes
     *
     * @throws Exception
     * @throws FileException
     * @throws ConnectionException
     *
     * @return int
     */
    protected function sendPatchRequest(string $checksum, int $bytes) : int
    {
        $data    = $this->getData($checksum, $bytes);
        $headers = [
            'Content-Type' => 'application/offset+octet-stream',
            'Content-Length' => strlen($data),
            'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
        ];

        if ($this->isPartial()) {
            $headers += ['Upload-Concat' => self::UPLOAD_TYPE_PARTIAL];
        }

        try {
            $response = $this->getClient()->patch($this->apiPath . '/' . $checksum, [
                'body' => $data,
                'headers' => $headers,
            ]);

            return (int) current($response->getHeader('upload-offset'));
        } catch (ClientException $e) {
            $statusCode = $e->getResponse()->getStatusCode();

            if (HttpResponse::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE === $statusCode) {
                throw new FileException('The uploaded file is corrupt.');
            }

            if (HttpResponse::HTTP_CONTINUE === $statusCode) {
                throw new ConnectionException('Connection aborted by user.');
            }

            throw new Exception($e->getResponse()->getBody(), $statusCode);
        } catch (ConnectException $e) {
            throw new ConnectionException("Couldn't connect to server.");
        }
    }

    /**
     * Get X bytes of data from file.
     *
     * @param string $checksum
     * @param int    $bytes
     *
     * @return string
     */
    protected function getData(string $checksum, int $bytes) : string
    {
        $file   = new File;
        $handle = $file->open($this->getFilePath(), $file::READ_BINARY);
        $offset = $this->partialOffset;

        if ($offset < 0) {
            $fileMeta = $this->getCache()->get($checksum);
            $offset   = $fileMeta['offset'];
        }

        $file->seek($handle, $offset);

        $data = $file->read($handle, $bytes);

        $file->close($handle);

        return (string) $data;
    }

    /**
     * Get upload checksum header.
     *
     * @param string|null $checksum
     *
     * @return string
     */
    protected function getUploadChecksumHeader(string $checksum = null) : string
    {
        if (empty($checksum)) {
            $checksum = $this->getChecksum();
        }

        return $this->getChecksumAlgorithm() . ' ' . base64_encode($checksum);
    }
}


1		<?php
2
3		namespace TusPhp\Tus;
4
5		use TusPhp\File;
6		use TusPhp\Cache\Cacheable;
7		use TusPhp\Exception\Exception;
8		use TusPhp\Exception\FileException;
9		use GuzzleHttp\Client as GuzzleClient;
10		use GuzzleHttp\Exception\ClientException;
11		use TusPhp\Exception\ConnectionException;
12		use GuzzleHttp\Exception\ConnectException;
13		use Illuminate\Http\Response as HttpResponse;
14
15		class Client extends AbstractTus
16		{
17		/** @var GuzzleClient */
18		protected $client;
19
20		/** @var string */
21		protected $apiPath = '/files';
22
23		/** @var string */
24		protected $filePath;
25
26		/** @var int */
27		protected $fileSize;
28
29		/** @var string */
30		protected $fileName;
31
32		/** @var string */
33		protected $checksum;
34
35		/** @var int */
36		protected $partialOffset = -1;
37
38		/** @var bool */
39		protected $partial = false;
40
41		/** @var string */
42		protected $checksumAlgorithm = 'sha256';
43
44		/**
45		* Client constructor.
46		*
47		* @param string $baseUrl
48		* @param Cacheable\|string $cacheAdapter
49		*/
50	1	public function __construct(string $baseUrl, $cacheAdapter = 'file')
51		{
52	1	$this->client = new GuzzleClient([
53	1	'base_uri' => $baseUrl,
54		]);
55
56	1	$this->setCache($cacheAdapter);
57	1	}
58
59		/**
60		* Set file properties.
61		*
62		* @param string $file File path.
63		* @param string $name File name.
64		*
65		* @return Client
66		*/
67	3	public function file(string $file, string $name = null) : self
68		{
69	3	$this->filePath = $file;
70
71	3	if ( ! file_exists($file) \|\| ! is_readable($file)) {
72	2	throw new FileException('Cannot read file: ' . $file);
73		}
74
75	1	$this->fileName = $name ?? basename($this->filePath);
76	1	$this->fileSize = filesize($file);
77
78	1	return $this;
79		}
80
81		/**
82		* Get file path.
83		*
84		* @return string\|null
85		*/
86	1	public function getFilePath()
87		{
88	1	return $this->filePath;
89		}
90
91		/**
92		* Set file name.
93		*
94		* @param string $name
95		*
96		* @return Client
97		*/
98	1	public function setFileName(string $name) : self
99		{
100	1	$this->fileName = $name;
101
102	1	return $this;
103		}
104
105		/**
106		* Get file name.
107		*
108		* @return string\|null
109		*/
110	2	public function getFileName()
111		{
112	2	return $this->fileName;
113		}
114
115		/**
116		* Get file size.
117		*
118		* @return int\|null
119		*/
120	1	public function getFileSize()
121		{
122	1	return $this->fileSize;
123		}
124
125		/**
126		* Set API path.
127		*
128		* @param string $path
129		*
130		* @return Client
131		*/
132	1	public function setApiPath(string $path) : self
133		{
134	1	$this->apiPath = $path;
135
136	1	return $this;
137		}
138
139		/**
140		* Get API path.
141		*
142		* @return string
143		*/
144	1	public function getApiPath() : string
145		{
146	1	return $this->apiPath;
147		}
148
149		/**
150		* Get guzzle client.
151		*
152		* @return GuzzleClient
153		*/
154	1	public function getClient() : GuzzleClient
155		{
156	1	return $this->client;
157		}
158
159		/**
160		* Get checksum.
161		*
162		* @return string
163		*/
164	1	public function getChecksum() : string
165		{
166	1	if (empty($this->checksum)) {
167	1	$this->checksum = hash_file($this->getChecksumAlgorithm(), $this->getFilePath());
168		}
169
170	1	return $this->checksum;
171		}
172
173		/**
174		* Set checksum algorithm.
175		*
176		* @param string $algorithm
177		*
178		* @return Client
179		*/
180	1	public function setChecksumAlgorithm(string $algorithm) : self
181		{
182	1	$this->checksumAlgorithm = $algorithm;
183
184	1	return $this;
185		}
186
187		/**
188		* Get checksum algorithm.
189		*
190		* @return string
191		*/
192	1	public function getChecksumAlgorithm() : string
193		{
194	1	return $this->checksumAlgorithm;
195		}
196
197		/**
198		* Check if this is a partial upload request.
199		*
200		* @return bool
201		*/
202	2	public function isPartial() : bool
203		{
204	2	return $this->partial;
205		}
206
207		/**
208		* Get partial offset.
209		* @return int
210		*/
211	1	public function getPartialOffset() : int
212		{
213	1	return $this->partialOffset;
214		}
215
216		/**
217		* Set offset and force this to be a partial upload request.
218		*
219		* @param int $offset
220		*
221		* @return $this
222		*/
223	1	public function seek(int $offset)
224		{
225	1	$this->partialOffset = $offset;
226
227	1	$this->partial();
228
229	1	return $this;
230		}
231
232		/**
233		* Upload file.
234		*
235		* @param int $bytes Bytes to upload
236		*
237		* @throws ConnectionException
238		*
239		* @return int
240		*/
241	5	public function upload(int $bytes = -1) : int
242		{
243	5	$bytes = $bytes < 0 ? $this->getFileSize() : $bytes;
244	5	$checksum = $this->getChecksum();
245
246		try {
247		// Check if this upload exists with HEAD request
248	5	$this->sendHeadRequest($checksum);
249	3	} catch (FileException \| ClientException $e) {
250	2	$this->create($checksum);
251	1	} catch (ConnectException $e) {
252	1	throw new ConnectionException("Couldn't connect to server.");
253		}
254
255		// Now, resume upload with PATCH request
256	4	return $this->sendPatchRequest($checksum, $bytes);
257		}
258
259		/**
260		* Returns offset if file is partially uploaded.
261		*
262		* @return bool\|int
263		*/
264	3	public function getOffset()
265		{
266	3	$checksum = $this->getChecksum();
267
268		try {
269	3	$offset = $this->sendHeadRequest($checksum);
270	2	} catch (FileException \| ClientException $e) {
271	2	return false;
272		}
273
274	1	return $offset;
275		}
276
277		/**
278		* Create resource with POST request.
279		*
280		* @param string $checksum
281		*
282		* @throws FileException
283		*
284		* @return string
285		*/
286	4	public function create(string $checksum) : string
287		{
288		$headers = [
289	4	'Upload-Length' => $this->fileSize,
290	4	'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
291	4	'Upload-Metadata' => 'filename ' . base64_encode($this->fileName),
292		];
293
294	4	if ($this->isPartial()) {
295	1	$headers += ['Upload-Concat' => 'partial'];
296		}
297
298	4	$response = $this->getClient()->post($this->apiPath, [
299	4	'headers' => $headers,
300		]);
301
302	4	$data = json_decode($response->getBody(), true);
303	4	$checksum = $data['data']['checksum'] ?? null;
304	4	$statusCode = $response->getStatusCode();
305
306	4	if (HttpResponse::HTTP_CREATED !== $statusCode \|\| ! $checksum) {
307	2	throw new FileException('Unable to create resource.');
308		}
309
310	2	return $checksum;
311		}
312
313		/**
314		* Concatenate 2 or more partial uploads.
315		*
316		* @param string $checksum
317		* @param array $partials
318		*
319		* @return string
320		*/
321	3	public function concat(string $checksum, ...$partials) : string
322		{
323	3	$response = $this->getClient()->post($this->apiPath, [
324		'headers' => [
325	3	'Upload-Length' => $this->fileSize,
326	3	'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
327	3	'Upload-Metadata' => 'filename ' . base64_encode($this->fileName),
328	3	'Upload-Concat' => self::UPLOAD_TYPE_FINAL . ';' . implode(' ', $partials),
329		],
330		]);
331
332	3	$data = json_decode($response->getBody(), true);
333	3	$checksum = $data['data']['checksum'] ?? null;
334	3	$statusCode = $response->getStatusCode();
335
336	3	if (HttpResponse::HTTP_CREATED !== $statusCode \|\| ! $checksum) {
337	2	throw new FileException('Unable to create resource.');
338		}
339
340	1	return $checksum;
341		}
342
343		/**
344		* Send DELETE request.
345		*
346		* @param string $checksum
347		*
348		* @throws FileException
349		*
350		* @return void
351		*/
352	3	public function delete(string $checksum)
353		{
354		try {
355	3	$this->getClient()->delete($this->apiPath . '/' . $checksum, [
356		'headers' => [
357	3	'Tus-Resumable' => self::TUS_PROTOCOL_VERSION,
358		],
359		]);
360	2	} catch (ClientException $e) {
361	2	$statusCode = $e->getResponse()->getStatusCode();
362
363	2	if (HttpResponse::HTTP_NOT_FOUND === $statusCode \|\| HttpResponse::HTTP_GONE === $statusCode) {
364	2	throw new FileException('File not found.');
365		}
366		}
367	1	}
368
369		/**
370		* Set as partial request.
371		*
372		* @param bool $state
373		*/
374	3	protected function partial(bool $state = true)
375		{
376	3	$this->partial = $state;
377
378	3	if ( ! $this->partial) {
379	1	return;
380		}
381
382	2	$checksum = $this->getChecksum();
383
384	2	if (false !== strpos($checksum, self::PARTIAL_UPLOAD_NAME_SEPARATOR)) {
385	1	list($checksum) = explode(self::PARTIAL_UPLOAD_NAME_SEPARATOR, $checksum);
386		}
387
388	2	$this->checksum = $checksum . uniqid(self::PARTIAL_UPLOAD_NAME_SEPARATOR);
389	2	}
390
391		/**
392		* Send HEAD request.
393		*
394		* @param string $checksum
395		*
396		* @throws FileException
397		*
398		* @return int
399		*/
400	2	protected function sendHeadRequest(string $checksum) : int
401		{
402	2	$response = $this->getClient()->head($this->apiPath . '/' . $checksum);
403
404	2	$statusCode = $response->getStatusCode();
405
406	2	if (HttpResponse::HTTP_OK !== $statusCode) {
407	1	throw new FileException('File not found.');
408		}
409
410	1	return (int) current($response->getHeader('upload-offset'));
411		}
412
413		/**
414		* Send PATCH request.
415		*
416		* @param string $checksum
417		* @param int $bytes
418		*
419		* @throws Exception
420		* @throws FileException
421		* @throws ConnectionException
422		*
423		* @return int
424		*/
425	6	protected function sendPatchRequest(string $checksum, int $bytes) : int
426		{
427	6	$data = $this->getData($checksum, $bytes);
428		$headers = [
429	6	'Content-Type' => 'application/offset+octet-stream',
430	6	'Content-Length' => strlen($data),
431	6	'Upload-Checksum' => $this->getUploadChecksumHeader($checksum),
432		];
433
434	6	if ($this->isPartial()) {
435	1	$headers += ['Upload-Concat' => self::UPLOAD_TYPE_PARTIAL];
436		}
437
438		try {
439	6	$response = $this->getClient()->patch($this->apiPath . '/' . $checksum, [
440	6	'body' => $data,
441	6	'headers' => $headers,
442		]);
443
444	2	return (int) current($response->getHeader('upload-offset'));
445	4	} catch (ClientException $e) {
446	3	$statusCode = $e->getResponse()->getStatusCode();
447
448	3	if (HttpResponse::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE === $statusCode) {
449	1	throw new FileException('The uploaded file is corrupt.');
450		}
451
452	2	if (HttpResponse::HTTP_CONTINUE === $statusCode) {
453	1	throw new ConnectionException('Connection aborted by user.');
454		}
455
456	1	throw new Exception($e->getResponse()->getBody(), $statusCode);
457	1	} catch (ConnectException $e) {
458	1	throw new ConnectionException("Couldn't connect to server.");
459		}
460		}
461
462		/**
463		* Get X bytes of data from file.
464		*
465		* @param string $checksum
466		* @param int $bytes
467		*
468		* @return string
469		*/
470	2	protected function getData(string $checksum, int $bytes) : string
471		{
472	2	$file = new File;
473	2	$handle = $file->open($this->getFilePath(), $file::READ_BINARY);
474	2	$offset = $this->partialOffset;
475
476	2	if ($offset < 0) {
477	2	$fileMeta = $this->getCache()->get($checksum);
478	2	$offset = $fileMeta['offset'];
479		}
480
481	2	$file->seek($handle, $offset);
482
483	2	$data = $file->read($handle, $bytes);
484
485	2	$file->close($handle);
486
487	2	return (string) $data;
488		}
489
490		/**
491		* Get upload checksum header.
492		*
493		* @param string\|null $checksum
494		*
495		* @return string
496		*/
497	1	protected function getUploadChecksumHeader(string $checksum = null) : string
498		{
499	1	if (empty($checksum)) {
500	1	$checksum = $this->getChecksum();
501		}
502
503	1	return $this->getChecksumAlgorithm() . ' ' . base64_encode($checksum);
504		}
505		}
506

ankitpokhrel / tus-php

Pull Request — master (#11)

Client::getClient() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like