Client::getFile() - Code Metrics - Inspection of "Merge pull request #62 from mlambley/mark-file-fro..." - gliterd/backblaze-b2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( bab9fc...a75c4c )

unknown

created 2021-02-03 10:18 UTC

Client::getFile() B

↳ Parent: Client

Complexity

Conditions	9
Paths	5

Size

Total Lines	35
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	13.2714

Importance

Changes	4
Bugs	1	Features	0

Metric	Value
eloc	23
c	4
b	1
f	0
dl	0
loc	35
ccs	15
cts	24
cp	0.625
rs	8.0555
cc	9
nc	5
nop	1
crap	13.2714

<?php

namespace BackblazeB2;

use BackblazeB2\Exceptions\B2Exception;
use BackblazeB2\Exceptions\NotFoundException;
use BackblazeB2\Exceptions\ValidationException;
use BackblazeB2\Http\Client as HttpClient;
use Carbon\Carbon;
use GuzzleHttp\Exception\GuzzleException;

class Client
{
    const B2_API_BASE_URL = 'https://api.backblazeb2.com';
    const B2_API_V1 = '/b2api/v1/';
    protected $accountId;
    protected $applicationKey;
    protected $authToken;
    protected $apiUrl;
    protected $downloadUrl;
    protected $client;
    protected $reAuthTime;
    protected $authTimeoutSeconds;

    /**
     * Accepts the account ID, application key and an optional array of options.
     *
     * @param $accountId
     * @param $applicationKey
     * @param array $options
     *
     * @throws \Exception
     */
    public function __construct($accountId, $applicationKey, array $options = [])
    {
        $this->accountId = $accountId;
        $this->applicationKey = $applicationKey;

        $this->authTimeoutSeconds = 12 * 60 * 60; // 12 hour default
        if (isset($options['auth_timeout_seconds'])) {
            $this->authTimeoutSeconds = $options['auth_timeout_seconds'];
        }

        // set reauthorize time to force an authentication to take place
        $this->reAuthTime = Carbon::now('UTC')->subSeconds($this->authTimeoutSeconds * 2);

        $this->client = new HttpClient(['exceptions' => false]);
        if (isset($options['client'])) {
            $this->client = $options['client'];
        }
    }

    /**
     * Create a bucket with the given name and type.
     *
     * @param array $options
     *
     * @throws ValidationException
     * @throws GuzzleException     If the request fails.
     * @throws B2Exception         If the B2 server replies with an error.
     *
     * @return Bucket
     */
    public function createBucket(array $options)
    {
        if (!in_array($options['BucketType'], [Bucket::TYPE_PUBLIC, Bucket::TYPE_PRIVATE])) {
            throw new ValidationException(
                sprintf('Bucket type must be %s or %s', Bucket::TYPE_PRIVATE, Bucket::TYPE_PUBLIC)
            );
        }

        $response = $this->sendAuthorizedRequest('POST', 'b2_create_bucket', [
            'accountId'  => $this->accountId,
            'bucketName' => $options['BucketName'],
            'bucketType' => $options['BucketType'],
        ]);

        return new Bucket($response['bucketId'], $response['bucketName'], $response['bucketType']);
    }

    /**
     * Updates the type attribute of a bucket by the given ID.
     *
     * @param array $options
     *
     * @throws ValidationException
     * @throws GuzzleException     If the request fails.
     * @throws B2Exception         If the B2 server replies with an error.
     *
     * @return Bucket
     */
    public function updateBucket(array $options)
    {
        if (!in_array($options['BucketType'], [Bucket::TYPE_PUBLIC, Bucket::TYPE_PRIVATE])) {
            throw new ValidationException(
                sprintf('Bucket type must be %s or %s', Bucket::TYPE_PRIVATE, Bucket::TYPE_PUBLIC)
            );
        }

        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        $response = $this->sendAuthorizedRequest('POST', 'b2_update_bucket', [
            'accountId'  => $this->accountId,
            'bucketId'   => $options['BucketId'],
            'bucketType' => $options['BucketType'],
        ]);

        return new Bucket($response['bucketId'], $response['bucketName'], $response['bucketType']);
    }

    /**
     * Returns a list of bucket objects representing the buckets on the account.
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return array
     */
    public function listBuckets()
    {
        $buckets = [];

        $response = $this->sendAuthorizedRequest('POST', 'b2_list_buckets', [
            'accountId' => $this->accountId,
        ]);

        foreach ($response['buckets'] as $bucket) {
            $buckets[] = new Bucket($bucket['bucketId'], $bucket['bucketName'], $bucket['bucketType']);
        }

        return $buckets;
    }

    /**
     * Deletes the bucket identified by its ID.
     *
     * @param array $options
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return bool
     */
    public function deleteBucket(array $options)
    {
        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        $this->sendAuthorizedRequest('POST', 'b2_delete_bucket', [
            'accountId' => $this->accountId,
            'bucketId'  => $options['BucketId'],
        ]);

        return true;
    }

    /**
     * Uploads a file to a bucket and returns a File object.
     *
     * @param array $options
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return File
     */
    public function upload(array $options)
    {
        // Clean the path if it starts with /.
        if (substr($options['FileName'], 0, 1) === '/') {
            $options['FileName'] = ltrim($options['FileName'], '/');
        }

        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        // Retrieve the URL that we should be uploading to.

        $response = $this->sendAuthorizedRequest('POST', 'b2_get_upload_url', [
            'bucketId' => $options['BucketId'],
        ]);

        $uploadEndpoint = $response['uploadUrl'];
        $uploadAuthToken = $response['authorizationToken'];

        if (is_resource($options['Body'])) {
            // We need to calculate the file's hash incrementally from the stream.
            $context = hash_init('sha1');
            hash_update_stream($context, $options['Body']);
            $hash = hash_final($context);

            // Similarly, we have to use fstat to get the size of the stream.
            $size = fstat($options['Body'])['size'];

            // Rewind the stream before passing it to the HTTP client.
            rewind($options['Body']);
        } else {
            // We've been given a simple string body, it's super simple to calculate the hash and size.
            $hash = sha1($options['Body']);
            $size = strlen($options['Body']);
        }

        if (!isset($options['FileLastModified'])) {
            $options['FileLastModified'] = round(microtime(true) * 1000);
        }

        if (!isset($options['FileContentType'])) {
            $options['FileContentType'] = 'b2/x-auto';
        }

        $customHeaders = $options['Headers'] ?? [];
        $response = $this->client->guzzleRequest('POST', $uploadEndpoint, [
            'headers' => array_merge([
                'Authorization'                      => $uploadAuthToken,
                'Content-Type'                       => $options['FileContentType'],
                'Content-Length'                     => $size,
                'X-Bz-File-Name'                     => $options['FileName'],
                'X-Bz-Content-Sha1'                  => $hash,
                'X-Bz-Info-src_last_modified_millis' => $options['FileLastModified'],
            ], $customHeaders),
            'body' => $options['Body'],
        ]);

        return new File(
            $response['fileId'],
            $response['fileName'],
            $response['contentSha1'],
            $response['contentLength'],
            $response['contentType'],
            $response['fileInfo']
        );
    }

    /**
     * Download a file from a B2 bucket.
     *
     * @param array $options
     *
     * @return bool
     */
    public function download(array $options)
    {
        if (!isset($options['FileId']) && !isset($options['BucketName']) && isset($options['BucketId'])) {
            $options['BucketName'] = $this->getBucketNameFromId($options['BucketId']);
        }

        $this->authorizeAccount();

        $requestUrl = null;
        $customHeaders = $options['Headers'] ?? [];
        $requestOptions = [
            'headers' => array_merge([
                'Authorization' => $this->authToken,
            ], $customHeaders),
            'sink' => isset($options['SaveAs']) ? $options['SaveAs'] : null,
        ];

        if (isset($options['FileId'])) {
            $requestOptions['query'] = ['fileId' => $options['FileId']];
            $requestUrl = $this->downloadUrl.'/b2api/v1/b2_download_file_by_id';
        } else {
            $requestUrl = sprintf('%s/file/%s/%s', $this->downloadUrl, $options['BucketName'], $options['FileName']);
        }

        $response = $this->client->guzzleRequest('GET', $requestUrl, $requestOptions, false);

        return isset($options['SaveAs']) ? true : $response;
    }

    /**
     * Retrieve a collection of File objects representing the files stored inside a bucket.
     *
     * @param array $options
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return array
     */
    public function listFiles(array $options)
    {
        // if FileName is set, we only attempt to retrieve information about that single file.
        $fileName = !empty($options['FileName']) ? $options['FileName'] : null;

        $nextFileName = null;
        $maxFileCount = 1000;

        $prefix = isset($options['Prefix']) ? $options['Prefix'] : '';
        $delimiter = isset($options['Delimiter']) ? $options['Delimiter'] : null;

        $files = [];

        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        if ($fileName) {
            $nextFileName = $fileName;
            $maxFileCount = 1;
        }

        $this->authorizeAccount();

        // B2 returns, at most, 1000 files per "page". Loop through the pages and compile an array of File objects.
        while (true) {
            $response = $this->sendAuthorizedRequest('POST', 'b2_list_file_names', [
                'bucketId'      => $options['BucketId'],
                'startFileName' => $nextFileName,
                'maxFileCount'  => $maxFileCount,
                'prefix'        => $prefix,
                'delimiter'     => $delimiter,
            ]);

            foreach ($response['files'] as $file) {
                // if we have a file name set, only retrieve information if the file name matches
                if (!$fileName || ($fileName === $file['fileName'])) {
                    $files[] = new File($file['fileId'], $file['fileName'], null, $file['size']);
                }
            }

            if ($fileName || $response['nextFileName'] === null) {
                // We've got all the files - break out of loop.
                break;
            }

            $nextFileName = $response['nextFileName'];
        }

        return $files;
    }

    /**
     * Test whether a file exists in B2 for the given bucket.
     *
     * @param array $options
     *
     * @return bool
     */
    public function fileExists(array $options)
    {
        $files = $this->listFiles($options);

        return !empty($files);
    }

    /**
     * Returns a single File object representing a file stored on B2.
     *
     * @param array $options
     *
     * @throws GuzzleException
     * @throws NotFoundException If no file id was provided and BucketName + FileName does not resolve to a file, a NotFoundException is thrown.
     * @throws GuzzleException   If the request fails.
     * @throws B2Exception       If the B2 server replies with an error.
     *
     * @return File
     */
    public function getFile(array $options)
    {
        if (!isset($options['FileId']) && isset($options['BucketId']) && isset($options['FileName'])) {
            $files = $this->listFiles([
                'BucketId' => $options['BucketId'],
                'FileName' => $options['FileName'],
            ]);

            if (empty($files)) {
                throw new NotFoundException();
            }

            $options['FileId'] = $files[0]->getId();
        } elseif (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
            $options['FileId'] = $this->getFileIdFromBucketAndFileName($options['BucketName'], $options['FileName']);

            if (!$options['FileId']) {
                throw new NotFoundException();
            }
        }

        $response = $this->sendAuthorizedRequest('POST', 'b2_get_file_info', [
            'fileId' => $options['FileId'],
        ]);

        return new File(
            $response['fileId'],
            $response['fileName'],
            $response['contentSha1'],
            $response['contentLength'],
            $response['contentType'],
            $response['fileInfo'],
            $response['bucketId'],
            $response['action'],
            $response['uploadTimestamp']
        );
    }

    /**
     * Deletes the file identified by ID from Backblaze B2.
     *
     * @param array $options
     *
     * @throws GuzzleException
     * @throws NotFoundException
     * @throws GuzzleException   If the request fails.
     * @throws B2Exception       If the B2 server replies with an error.
     *
     * @return bool
     */
    public function deleteFile(array $options)
    {
        if (!isset($options['FileName'])) {
            $file = $this->getFile($options);

            $options['FileName'] = $file->getName();
        }

        if (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
            $file = $this->getFile($options);

            $options['FileId'] = $file->getId();
        }

        $this->sendAuthorizedRequest('POST', 'b2_delete_file_version', [
            'fileName' => $options['FileName'],
            'fileId'   => $options['FileId'],
        ]);

        return true;
    }

    /**
     * Authorize the B2 account in order to get an auth token and API/download URLs.
     */
    protected function authorizeAccount()
    {
        if (Carbon::now('UTC')->timestamp < $this->reAuthTime->timestamp) {
            return;
        }

        $response = $this->client->guzzleRequest('GET', self::B2_API_BASE_URL.self::B2_API_V1.'/b2_authorize_account', [
            'auth' => [$this->accountId, $this->applicationKey],
        ]);

        $this->authToken = $response['authorizationToken'];
        $this->apiUrl = $response['apiUrl'].self::B2_API_V1;
        $this->downloadUrl = $response['downloadUrl'];
        $this->reAuthTime = Carbon::now('UTC');
        $this->reAuthTime->addSeconds($this->authTimeoutSeconds);
    }

    /**
     * Maps the provided bucket name to the appropriate bucket ID.
     *
     * @param $name
     *
     * @return mixed
     */
    protected function getBucketIdFromName($name)
    {
        $buckets = $this->listBuckets();

        foreach ($buckets as $bucket) {
            if ($bucket->getName() === $name) {
                return $bucket->getId();
            }
        }
    }

    /**
     * Maps the provided bucket ID to the appropriate bucket name.
     *
     * @param $id
     *
     * @return mixed
     */
    protected function getBucketNameFromId($id)
    {
        $buckets = $this->listBuckets();

        foreach ($buckets as $bucket) {
            if ($bucket->getId() === $id) {
                return $bucket->getName();
            }
        }
    }

    /**
     * @param $bucketName
     * @param $fileName
     *
     * @return mixed
     */
    protected function getFileIdFromBucketAndFileName($bucketName, $fileName)
    {
        $files = $this->listFiles([
            'BucketName' => $bucketName,
            'FileName'   => $fileName,
        ]);

        foreach ($files as $file) {
            if ($file->getName() === $fileName) {
                return $file->getId();
            }
        }
    }

    /**
     * Uploads a large file using b2 large file procedure.
     *
     * @param array $options
     *
     * @return File
     */
    public function uploadLargeFile(array $options)
    {
        if (substr($options['FileName'], 0, 1) === '/') {
            $options['FileName'] = ltrim($options['FileName'], '/');
        }

        //if last char of path is not a "/" then add a "/"
        if (substr($options['FilePath'], -1) != '/') {
            $options['FilePath'] = $options['FilePath'].'/';
        }

        if (!isset($options['BucketId']) && isset($options['BucketName'])) {
            $options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
        }

        if (!isset($options['FileContentType'])) {
            $options['FileContentType'] = 'b2/x-auto';
        }

        $this->authorizeAccount();

        // 1) b2_start_large_file, (returns fileId)

        $start = $this->startLargeFile($options['FileName'], $options['FileContentType'], $options['BucketId']);

        // 2) b2_get_upload_part_url for each thread uploading (takes fileId)
        $url = $this->getUploadPartUrl($start['fileId']);

        // 3) b2_upload_part for each part of the file
        $parts = $this->uploadParts($options['FilePath'].$options['FileName'], $url['uploadUrl'], $url['authorizationToken'], $options);

        $sha1s = [];

        foreach ($parts as $part) {
            $sha1s[] = $part['contentSha1'];
        }

        // 4) b2_finish_large_file.
        return $this->finishLargeFile($start['fileId'], $sha1s);
    }

    /**
     * Starts the large file upload process.
     *
     * @param $fileName
     * @param $contentType
     * @param $bucketId
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return mixed
     */
    protected function startLargeFile($fileName, $contentType, $bucketId)
    {
        return $this->sendAuthorizedRequest('POST', 'b2_start_large_file', [
            'fileName'      => $fileName,
            'contentType'   => $contentType,
            'bucketId'      => $bucketId,
        ]);
    }

    /**
     * Gets the url for the next large file part upload.
     *
     * @param $fileId
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return mixed
     */
    protected function getUploadPartUrl($fileId)
    {
        return $this->sendAuthorizedRequest('POST', 'b2_get_upload_part_url', [
            'fileId' => $fileId,
        ]);
    }

    /**
     * Uploads the file as "parts" of 100MB each.
     *
     * @param $filePath
     * @param $uploadUrl
     * @param $largeFileAuthToken
     * @param $options
     *
     * @return array
     */
    protected function uploadParts($filePath, $uploadUrl, $largeFileAuthToken, $options = [])
    {
        $return = [];

        $minimum_part_size = 100 * (1000 * 1000);

        $local_file_size = filesize($filePath);
        $total_bytes_sent = 0;
        $bytes_sent_for_part = $minimum_part_size;
        $sha1_of_parts = [];
        $part_no = 1;
        $file_handle = fopen($filePath, 'r');

        while ($total_bytes_sent < $local_file_size) {

            // Determine the number of bytes to send based on the minimum part size
            if (($local_file_size - $total_bytes_sent) < $minimum_part_size) {
                $bytes_sent_for_part = ($local_file_size - $total_bytes_sent);
            }

            // Get a sha1 of the part we are going to send
            fseek($file_handle, $total_bytes_sent);
            $data_part = fread($file_handle, $bytes_sent_for_part);
            array_push($sha1_of_parts, sha1($data_part));
            fseek($file_handle, $total_bytes_sent);

            $customHeaders = $options['Headers'] ?? [];
            $response = $this->client->guzzleRequest('POST', $uploadUrl, [
                'headers' => array_merge([
                    'Authorization'                      => $largeFileAuthToken,
                    'Content-Length'                     => $bytes_sent_for_part,
                    'X-Bz-Part-Number'                   => $part_no,
                    'X-Bz-Content-Sha1'                  => $sha1_of_parts[$part_no - 1],
                ], $customHeaders),
                'body' => $data_part,
            ]);

            $return[] = $response;

            // Prepare for the next iteration of the loop
            $part_no++;
            $total_bytes_sent = $bytes_sent_for_part + $total_bytes_sent;
        }

        fclose($file_handle);

        return $return;
    }

    /**
     * Finishes the large file upload procedure.
     *
     * @param       $fileId
     * @param array $sha1s
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return File
     */
    protected function finishLargeFile($fileId, array $sha1s)
    {
        $response = $this->sendAuthorizedRequest('POST', 'b2_finish_large_file', [
            'fileId'        => $fileId,
            'partSha1Array' => $sha1s,
        ]);

        return new File(
            $response['fileId'],
            $response['fileName'],
            $response['contentSha1'],
            $response['contentLength'],
            $response['contentType'],
            $response['fileInfo'],
            $response['bucketId'],
            $response['action'],
            $response['uploadTimestamp']
        );
    }

    /**
     * Sends a authorized request to b2 API.
     *
     * @param string $method
     * @param string $route
     * @param array  $json
     *
     * @throws GuzzleException If the request fails.
     * @throws B2Exception     If the B2 server replies with an error.
     *
     * @return mixed
     */
    protected function sendAuthorizedRequest($method, $route, $json = [])
    {
        $this->authorizeAccount();

        return $this->client->guzzleRequest($method, $this->apiUrl.$route, [
            'headers' => [
                'Authorization' => $this->authToken,
            ],
            'json' => $json,
        ]);
    }
}


1		<?php
2
3		namespace BackblazeB2;
4
5		use BackblazeB2\Exceptions\B2Exception;
6		use BackblazeB2\Exceptions\NotFoundException;
7		use BackblazeB2\Exceptions\ValidationException;
8		use BackblazeB2\Http\Client as HttpClient;
9		use Carbon\Carbon;
10		use GuzzleHttp\Exception\GuzzleException;
11
12		class Client
13		{
14		const B2_API_BASE_URL = 'https://api.backblazeb2.com';
15		const B2_API_V1 = '/b2api/v1/';
16		protected $accountId;
17		protected $applicationKey;
18		protected $authToken;
19		protected $apiUrl;
20		protected $downloadUrl;
21		protected $client;
22		protected $reAuthTime;
23		protected $authTimeoutSeconds;
24
25		/**
26		* Accepts the account ID, application key and an optional array of options.
27		*
28		* @param $accountId
29		* @param $applicationKey
30		* @param array $options
31		*
32		* @throws \Exception
33		*/
34	29	public function __construct($accountId, $applicationKey, array $options = [])
35		{
36	29	$this->accountId = $accountId;
37	29	$this->applicationKey = $applicationKey;
38
39	29	$this->authTimeoutSeconds = 12 * 60 * 60; // 12 hour default
40	29	if (isset($options['auth_timeout_seconds'])) {
41	1	$this->authTimeoutSeconds = $options['auth_timeout_seconds'];
42		}
43
44		// set reauthorize time to force an authentication to take place
45	29	$this->reAuthTime = Carbon::now('UTC')->subSeconds($this->authTimeoutSeconds * 2);
46
47	29	$this->client = new HttpClient(['exceptions' => false]);
48	29	if (isset($options['client'])) {
49	29	$this->client = $options['client'];
50		}
51	29	}
52
53		/**
54		* Create a bucket with the given name and type.
55		*
56		* @param array $options
57		*
58		* @throws ValidationException
59		* @throws GuzzleException If the request fails.
60		* @throws B2Exception If the B2 server replies with an error.
61		*
62		* @return Bucket
63		*/
64	5	public function createBucket(array $options)
65		{
66	5	if (!in_array($options['BucketType'], [Bucket::TYPE_PUBLIC, Bucket::TYPE_PRIVATE])) {
67	1	throw new ValidationException(
68	1	sprintf('Bucket type must be %s or %s', Bucket::TYPE_PRIVATE, Bucket::TYPE_PUBLIC)
69		);
70		}
71
72	4	$response = $this->sendAuthorizedRequest('POST', 'b2_create_bucket', [
73	4	'accountId' => $this->accountId,
74	4	'bucketName' => $options['BucketName'],
75	4	'bucketType' => $options['BucketType'],
76		]);
77
78	3	return new Bucket($response['bucketId'], $response['bucketName'], $response['bucketType']);
79		}
80
81		/**
82		* Updates the type attribute of a bucket by the given ID.
83		*
84		* @param array $options
85		*
86		* @throws ValidationException
87		* @throws GuzzleException If the request fails.
88		* @throws B2Exception If the B2 server replies with an error.
89		*
90		* @return Bucket
91		*/
92	2	public function updateBucket(array $options)
93		{
94	2	if (!in_array($options['BucketType'], [Bucket::TYPE_PUBLIC, Bucket::TYPE_PRIVATE])) {
95		throw new ValidationException(
96		sprintf('Bucket type must be %s or %s', Bucket::TYPE_PRIVATE, Bucket::TYPE_PUBLIC)
97		);
98		}
99
100	2	if (!isset($options['BucketId']) && isset($options['BucketName'])) {
101		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
102		}
103
104	2	$response = $this->sendAuthorizedRequest('POST', 'b2_update_bucket', [
105	2	'accountId' => $this->accountId,
106	2	'bucketId' => $options['BucketId'],
107	2	'bucketType' => $options['BucketType'],
108		]);
109
110	2	return new Bucket($response['bucketId'], $response['bucketName'], $response['bucketType']);
111		}
112
113		/**
114		* Returns a list of bucket objects representing the buckets on the account.
115		*
116		* @throws GuzzleException If the request fails.
117		* @throws B2Exception If the B2 server replies with an error.
118		*
119		* @return array
120		*/
121	2	public function listBuckets()
122		{
123	2	$buckets = [];
124
125	2	$response = $this->sendAuthorizedRequest('POST', 'b2_list_buckets', [
126	2	'accountId' => $this->accountId,
127		]);
128
129	2	foreach ($response['buckets'] as $bucket) {
130	1	$buckets[] = new Bucket($bucket['bucketId'], $bucket['bucketName'], $bucket['bucketType']);
131		}
132
133	2	return $buckets;
134		}
135
136		/**
137		* Deletes the bucket identified by its ID.
138		*
139		* @param array $options
140		*
141		* @throws GuzzleException If the request fails.
142		* @throws B2Exception If the B2 server replies with an error.
143		*
144		* @return bool
145		*/
146	3	public function deleteBucket(array $options)
147		{
148	3	if (!isset($options['BucketId']) && isset($options['BucketName'])) {
149		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
150		}
151
152	3	$this->sendAuthorizedRequest('POST', 'b2_delete_bucket', [
153	3	'accountId' => $this->accountId,
154	3	'bucketId' => $options['BucketId'],
155		]);
156
157	1	return true;
158		}
159
160		/**
161		* Uploads a file to a bucket and returns a File object.
162		*
163		* @param array $options
164		*
165		* @throws GuzzleException If the request fails.
166		* @throws B2Exception If the B2 server replies with an error.
167		*
168		* @return File
169		*/
170	3	public function upload(array $options)
171		{
172		// Clean the path if it starts with /.
173	3	if (substr($options['FileName'], 0, 1) === '/') {
174		$options['FileName'] = ltrim($options['FileName'], '/');
175		}
176
177	3	if (!isset($options['BucketId']) && isset($options['BucketName'])) {
178		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
179		}
180
181		// Retrieve the URL that we should be uploading to.
182
183	3	$response = $this->sendAuthorizedRequest('POST', 'b2_get_upload_url', [
184	3	'bucketId' => $options['BucketId'],
185		]);
186
187	3	$uploadEndpoint = $response['uploadUrl'];
188	3	$uploadAuthToken = $response['authorizationToken'];
189
190	3	if (is_resource($options['Body'])) {
191		// We need to calculate the file's hash incrementally from the stream.
192	1	$context = hash_init('sha1');
193	1	hash_update_stream($context, $options['Body']);
194	1	$hash = hash_final($context);
195
196		// Similarly, we have to use fstat to get the size of the stream.
197	1	$size = fstat($options['Body'])['size'];
198
199		// Rewind the stream before passing it to the HTTP client.
200	1	rewind($options['Body']);
201		} else {
202		// We've been given a simple string body, it's super simple to calculate the hash and size.
203	2	$hash = sha1($options['Body']);
204	2	$size = strlen($options['Body']);
205		}
206
207	3	if (!isset($options['FileLastModified'])) {
208	2	$options['FileLastModified'] = round(microtime(true) * 1000);
209		}
210
211	3	if (!isset($options['FileContentType'])) {
212	2	$options['FileContentType'] = 'b2/x-auto';
213		}
214
215	3	$customHeaders = $options['Headers'] ?? [];
216	3	$response = $this->client->guzzleRequest('POST', $uploadEndpoint, [
217	3	'headers' => array_merge([
218	3	'Authorization' => $uploadAuthToken,
219	3	'Content-Type' => $options['FileContentType'],
220	3	'Content-Length' => $size,
221	3	'X-Bz-File-Name' => $options['FileName'],
222	3	'X-Bz-Content-Sha1' => $hash,
223	3	'X-Bz-Info-src_last_modified_millis' => $options['FileLastModified'],
224	3	], $customHeaders),
225	3	'body' => $options['Body'],
226		]);
227
228	3	return new File(
229	3	$response['fileId'],
230	3	$response['fileName'],
231	3	$response['contentSha1'],
232	3	$response['contentLength'],
233	3	$response['contentType'],
234	3	$response['fileInfo']
235		);
236		}
237
238		/**
239		* Download a file from a B2 bucket.
240		*
241		* @param array $options
242		*
243		* @return bool
244		*/
245	7	public function download(array $options)
246		{
247	7	if (!isset($options['FileId']) && !isset($options['BucketName']) && isset($options['BucketId'])) {
248		$options['BucketName'] = $this->getBucketNameFromId($options['BucketId']);
249		}
250
251	7	$this->authorizeAccount();
252
253	7	$requestUrl = null;
254	7	$customHeaders = $options['Headers'] ?? [];
255		$requestOptions = [
256	7	'headers' => array_merge([
257	7	'Authorization' => $this->authToken,
258	7	], $customHeaders),
259	7	'sink' => isset($options['SaveAs']) ? $options['SaveAs'] : null,
260		];
261
262	7	if (isset($options['FileId'])) {
263	4	$requestOptions['query'] = ['fileId' => $options['FileId']];
264	4	$requestUrl = $this->downloadUrl.'/b2api/v1/b2_download_file_by_id';
265		} else {
266	3	$requestUrl = sprintf('%s/file/%s/%s', $this->downloadUrl, $options['BucketName'], $options['FileName']);
267		}
268
269	7	$response = $this->client->guzzleRequest('GET', $requestUrl, $requestOptions, false);
270
271	5	return isset($options['SaveAs']) ? true : $response;
272		}
273
274		/**
275		* Retrieve a collection of File objects representing the files stored inside a bucket.
276		*
277		* @param array $options
278		*
279		* @throws GuzzleException If the request fails.
280		* @throws B2Exception If the B2 server replies with an error.
281		*
282		* @return array
283		*/
284	2	public function listFiles(array $options)
285		{
286		// if FileName is set, we only attempt to retrieve information about that single file.
287	2	$fileName = !empty($options['FileName']) ? $options['FileName'] : null;
288
289	2	$nextFileName = null;
290	2	$maxFileCount = 1000;
291
292	2	$prefix = isset($options['Prefix']) ? $options['Prefix'] : '';
293	2	$delimiter = isset($options['Delimiter']) ? $options['Delimiter'] : null;
294
295	2	$files = [];
296
297	2	if (!isset($options['BucketId']) && isset($options['BucketName'])) {
298		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
299		}
300
301	2	if ($fileName) {
302		$nextFileName = $fileName;
303		$maxFileCount = 1;
304		}
305
306	2	$this->authorizeAccount();
307
308		// B2 returns, at most, 1000 files per "page". Loop through the pages and compile an array of File objects.
309	2	while (true) {
310	2	$response = $this->sendAuthorizedRequest('POST', 'b2_list_file_names', [
311	2	'bucketId' => $options['BucketId'],
312	2	'startFileName' => $nextFileName,
313	2	'maxFileCount' => $maxFileCount,
314	2	'prefix' => $prefix,
315	2	'delimiter' => $delimiter,
316		]);
317
318	2	foreach ($response['files'] as $file) {
319		// if we have a file name set, only retrieve information if the file name matches
320	1	if (!$fileName \|\| ($fileName === $file['fileName'])) {
321	1	$files[] = new File($file['fileId'], $file['fileName'], null, $file['size']);
322		}
323		}
324
325	2	if ($fileName \|\| $response['nextFileName'] === null) {
326		// We've got all the files - break out of loop.
327	2	break;
328		}
329
330	1	$nextFileName = $response['nextFileName'];
331		}
332
333	2	return $files;
334		}
335
336		/**
337		* Test whether a file exists in B2 for the given bucket.
338		*
339		* @param array $options
340		*
341		* @return bool
342		*/
343		public function fileExists(array $options)
344		{
345		$files = $this->listFiles($options);
346
347		return !empty($files);
348		}
349
350		/**
351		* Returns a single File object representing a file stored on B2.
352		*
353		* @param array $options
354		*
355		* @throws GuzzleException
356		* @throws NotFoundException If no file id was provided and BucketName + FileName does not resolve to a file, a NotFoundException is thrown.
357		* @throws GuzzleException If the request fails.
358		* @throws B2Exception If the B2 server replies with an error.
359		*
360		* @return File
361		*/
362	4	public function getFile(array $options)
363		{
364	4	if (!isset($options['FileId']) && isset($options['BucketId']) && isset($options['FileName'])) {
365		$files = $this->listFiles([
366		'BucketId' => $options['BucketId'],
367		'FileName' => $options['FileName'],
368		]);
369
370		if (empty($files)) {
371		throw new NotFoundException();
372		}
373
374		$options['FileId'] = $files[0]->getId();
375	4	} elseif (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
376		$options['FileId'] = $this->getFileIdFromBucketAndFileName($options['BucketName'], $options['FileName']);
377
378		if (!$options['FileId']) {
379		throw new NotFoundException();
380		}
381		}
382
383	4	$response = $this->sendAuthorizedRequest('POST', 'b2_get_file_info', [
384	4	'fileId' => $options['FileId'],
385		]);
386
387	3	return new File(
388	3	$response['fileId'],
389	3	$response['fileName'],
390	3	$response['contentSha1'],
391	3	$response['contentLength'],
392	3	$response['contentType'],
393	3	$response['fileInfo'],
394	3	$response['bucketId'],
395	3	$response['action'],
396	3	$response['uploadTimestamp']
397		);
398		}
399
400		/**
401		* Deletes the file identified by ID from Backblaze B2.
402		*
403		* @param array $options
404		*
405		* @throws GuzzleException
406		* @throws NotFoundException
407		* @throws GuzzleException If the request fails.
408		* @throws B2Exception If the B2 server replies with an error.
409		*
410		* @return bool
411		*/
412	3	public function deleteFile(array $options)
413		{
414	3	if (!isset($options['FileName'])) {
415	2	$file = $this->getFile($options);
416
417	2	$options['FileName'] = $file->getName();
418		}
419
420	3	if (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
421		$file = $this->getFile($options);
422
423		$options['FileId'] = $file->getId();
424		}
425
426	3	$this->sendAuthorizedRequest('POST', 'b2_delete_file_version', [
427	3	'fileName' => $options['FileName'],
428	3	'fileId' => $options['FileId'],
429		]);
430
431	2	return true;
432		}
433
434		/**
435		* Authorize the B2 account in order to get an auth token and API/download URLs.
436		*/
437	28	protected function authorizeAccount()
438		{
439	28	if (Carbon::now('UTC')->timestamp < $this->reAuthTime->timestamp) {
440	4	return;
441		}
442
443	28	$response = $this->client->guzzleRequest('GET', self::B2_API_BASE_URL.self::B2_API_V1.'/b2_authorize_account', [
444	28	'auth' => [$this->accountId, $this->applicationKey],
445		]);
446
447	28	$this->authToken = $response['authorizationToken'];
448	28	$this->apiUrl = $response['apiUrl'].self::B2_API_V1;
449	28	$this->downloadUrl = $response['downloadUrl'];
450	28	$this->reAuthTime = Carbon::now('UTC');
451	28	$this->reAuthTime->addSeconds($this->authTimeoutSeconds);
452	28	}
453
454		/**
455		* Maps the provided bucket name to the appropriate bucket ID.
456		*
457		* @param $name
458		*
459		* @return mixed
460		*/
461		protected function getBucketIdFromName($name)
462		{
463		$buckets = $this->listBuckets();
464
465		foreach ($buckets as $bucket) {
466		if ($bucket->getName() === $name) {
467		return $bucket->getId();
468		}
469		}
470		}
471
472		/**
473		* Maps the provided bucket ID to the appropriate bucket name.
474		*
475		* @param $id
476		*
477		* @return mixed
478		*/
479		protected function getBucketNameFromId($id)
480		{
481		$buckets = $this->listBuckets();
482
483		foreach ($buckets as $bucket) {
484		if ($bucket->getId() === $id) {
485		return $bucket->getName();
486		}
487		}
488		}
489
490		/**
491		* @param $bucketName
492		* @param $fileName
493		*
494		* @return mixed
495		*/
496		protected function getFileIdFromBucketAndFileName($bucketName, $fileName)
497		{
498		$files = $this->listFiles([
499		'BucketName' => $bucketName,
500		'FileName' => $fileName,
501		]);
502
503		foreach ($files as $file) {
504		if ($file->getName() === $fileName) {
505		return $file->getId();
506		}
507		}
508		}
509
510		/**
511		* Uploads a large file using b2 large file procedure.
512		*
513		* @param array $options
514		*
515		* @return File
516		*/
517		public function uploadLargeFile(array $options)
518		{
519		if (substr($options['FileName'], 0, 1) === '/') {
520		$options['FileName'] = ltrim($options['FileName'], '/');
521		}
522
523		//if last char of path is not a "/" then add a "/"
524		if (substr($options['FilePath'], -1) != '/') {
525		$options['FilePath'] = $options['FilePath'].'/';
526		}
527
528		if (!isset($options['BucketId']) && isset($options['BucketName'])) {
529		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
530		}
531
532		if (!isset($options['FileContentType'])) {
533		$options['FileContentType'] = 'b2/x-auto';
534		}
535
536		$this->authorizeAccount();
537
538		// 1) b2_start_large_file, (returns fileId)
		0 ignored issues – show Unused Code Comprehensibility introduced 2018-12-29 10:40 UTC by Report Bug Copy Issue Report `37%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
539		$start = $this->startLargeFile($options['FileName'], $options['FileContentType'], $options['BucketId']);
540
541		// 2) b2_get_upload_part_url for each thread uploading (takes fileId)
542		$url = $this->getUploadPartUrl($start['fileId']);
543
544		// 3) b2_upload_part for each part of the file
545		$parts = $this->uploadParts($options['FilePath'].$options['FileName'], $url['uploadUrl'], $url['authorizationToken'], $options);
546
547		$sha1s = [];
548
549		foreach ($parts as $part) {
550		$sha1s[] = $part['contentSha1'];
551		}
552
553		// 4) b2_finish_large_file.
554		return $this->finishLargeFile($start['fileId'], $sha1s);
555		}
556
557		/**
558		* Starts the large file upload process.
559		*
560		* @param $fileName
561		* @param $contentType
562		* @param $bucketId
563		*
564		* @throws GuzzleException If the request fails.
565		* @throws B2Exception If the B2 server replies with an error.
566		*
567		* @return mixed
568		*/
569		protected function startLargeFile($fileName, $contentType, $bucketId)
570		{
571		return $this->sendAuthorizedRequest('POST', 'b2_start_large_file', [
572		'fileName' => $fileName,
573		'contentType' => $contentType,
574		'bucketId' => $bucketId,
575		]);
576		}
577
578		/**
579		* Gets the url for the next large file part upload.
580		*
581		* @param $fileId
582		*
583		* @throws GuzzleException If the request fails.
584		* @throws B2Exception If the B2 server replies with an error.
585		*
586		* @return mixed
587		*/
588		protected function getUploadPartUrl($fileId)
589		{
590		return $this->sendAuthorizedRequest('POST', 'b2_get_upload_part_url', [
591		'fileId' => $fileId,
592		]);
593		}
594
595		/**
596		* Uploads the file as "parts" of 100MB each.
597		*
598		* @param $filePath
599		* @param $uploadUrl
600		* @param $largeFileAuthToken
601		* @param $options
602		*
603		* @return array
604		*/
605		protected function uploadParts($filePath, $uploadUrl, $largeFileAuthToken, $options = [])
606		{
607		$return = [];
608
609		$minimum_part_size = 100 * (1000 * 1000);
610
611		$local_file_size = filesize($filePath);
612		$total_bytes_sent = 0;
613		$bytes_sent_for_part = $minimum_part_size;
614		$sha1_of_parts = [];
615		$part_no = 1;
616		$file_handle = fopen($filePath, 'r');
617
618		while ($total_bytes_sent < $local_file_size) {
619
620		// Determine the number of bytes to send based on the minimum part size
621		if (($local_file_size - $total_bytes_sent) < $minimum_part_size) {
622		$bytes_sent_for_part = ($local_file_size - $total_bytes_sent);
623		}
624
625		// Get a sha1 of the part we are going to send
626		fseek($file_handle, $total_bytes_sent);
627		$data_part = fread($file_handle, $bytes_sent_for_part);
628		array_push($sha1_of_parts, sha1($data_part));
629		fseek($file_handle, $total_bytes_sent);
630
631		$customHeaders = $options['Headers'] ?? [];
632		$response = $this->client->guzzleRequest('POST', $uploadUrl, [
633		'headers' => array_merge([
634		'Authorization' => $largeFileAuthToken,
635		'Content-Length' => $bytes_sent_for_part,
636		'X-Bz-Part-Number' => $part_no,
637		'X-Bz-Content-Sha1' => $sha1_of_parts[$part_no - 1],
638		], $customHeaders),
639		'body' => $data_part,
640		]);
641
642		$return[] = $response;
643
644		// Prepare for the next iteration of the loop
645		$part_no++;
646		$total_bytes_sent = $bytes_sent_for_part + $total_bytes_sent;
647		}
648
649		fclose($file_handle);
650
651		return $return;
652		}
653
654		/**
655		* Finishes the large file upload procedure.
656		*
657		* @param $fileId
658		* @param array $sha1s
659		*
660		* @throws GuzzleException If the request fails.
661		* @throws B2Exception If the B2 server replies with an error.
662		*
663		* @return File
664		*/
665		protected function finishLargeFile($fileId, array $sha1s)
666		{
667		$response = $this->sendAuthorizedRequest('POST', 'b2_finish_large_file', [
668		'fileId' => $fileId,
669		'partSha1Array' => $sha1s,
670		]);
671
672		return new File(
673		$response['fileId'],
674		$response['fileName'],
675		$response['contentSha1'],
676		$response['contentLength'],
677		$response['contentType'],
678		$response['fileInfo'],
679		$response['bucketId'],
680		$response['action'],
681		$response['uploadTimestamp']
682		);
683		}
684
685		/**
686		* Sends a authorized request to b2 API.
687		*
688		* @param string $method
689		* @param string $route
690		* @param array $json
691		*
692		* @throws GuzzleException If the request fails.
693		* @throws B2Exception If the B2 server replies with an error.
694		*
695		* @return mixed
696		*/
697	21	protected function sendAuthorizedRequest($method, $route, $json = [])
698		{
699	21	$this->authorizeAccount();
700
701	21	return $this->client->guzzleRequest($method, $this->apiUrl.$route, [
702		'headers' => [
703	21	'Authorization' => $this->authToken,
704		],
705	21	'json' => $json,
706		]);
707		}
708		}
709

gliterd / backblaze-b2

Push — master ( bab9fc...a75c4c )

Client::getFile() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like