Client::getFile() - Code Metrics - Inspection of "Allow fetching file by bucket id" - gliterd/backblaze-b2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#62)

unknown

created 2021-01-28 06:21 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	5
Bugs	1	Features	0

Metric	Value
eloc	23
c	5
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
{
    private const B2_API_BASE_URL = 'https://api.backblazeb2.com';
    private 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';
        }

        $response = $this->client->guzzleRequest('POST', $uploadEndpoint, [
            'headers' => [
                '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'],
            ],
            '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)
    {
        $requestUrl = null;
        $requestOptions = [
            'headers' => [
                'Authorization' => $this->authToken,
            ],
            '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 {
            if (!isset($options['BucketName']) && isset($options['BucketId'])) {
                $options['BucketName'] = $this->getBucketNameFromId($options['BucketId']);
            }

            $requestUrl = sprintf('%s/file/%s/%s', $this->downloadUrl, $options['BucketName'], $options['FileName']);
        }

        $this->authorizeAccount();

        $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']);

        $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
     *
     * @return array
     */
    protected function uploadParts($filePath, $uploadUrl, $largeFileAuthToken)
    {
        $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);

            $response = $this->client->guzzleRequest('POST', $uploadUrl, [
                'headers' => [
                    'Authorization'                      => $largeFileAuthToken,
                    'Content-Length'                     => $bytes_sent_for_part,
                    'X-Bz-Part-Number'                   => $part_no,
                    'X-Bz-Content-Sha1'                  => $sha1_of_parts[$part_no - 1],
                ],
                '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		private const B2_API_BASE_URL = 'https://api.backblazeb2.com';
15		private 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	28	public function __construct($accountId, $applicationKey, array $options = [])
35		{
36	28	$this->accountId = $accountId;
37	28	$this->applicationKey = $applicationKey;
38
39	28	$this->authTimeoutSeconds = 12 * 60 * 60; // 12 hour default
40	28	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	28	$this->reAuthTime = Carbon::now('UTC')->subSeconds($this->authTimeoutSeconds * 2);
46
47	28	$this->client = new HttpClient(['exceptions' => false]);
48	28	if (isset($options['client'])) {
49	28	$this->client = $options['client'];
50		}
51	28	}
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	$response = $this->client->guzzleRequest('POST', $uploadEndpoint, [
216		'headers' => [
217	3	'Authorization' => $uploadAuthToken,
218	3	'Content-Type' => $options['FileContentType'],
219	3	'Content-Length' => $size,
220	3	'X-Bz-File-Name' => $options['FileName'],
221	3	'X-Bz-Content-Sha1' => $hash,
222	3	'X-Bz-Info-src_last_modified_millis' => $options['FileLastModified'],
223		],
224	3	'body' => $options['Body'],
225		]);
226
227	3	return new File(
228	3	$response['fileId'],
229	3	$response['fileName'],
230	3	$response['contentSha1'],
231	3	$response['contentLength'],
232	3	$response['contentType'],
233	3	$response['fileInfo']
234		);
235		}
236
237		/**
238		* Download a file from a B2 bucket.
239		*
240		* @param array $options
241		*
242		* @return bool
243		*/
244	6	public function download(array $options)
245		{
246	6	$requestUrl = null;
247		$requestOptions = [
248	6	'headers' => [
249	6	'Authorization' => $this->authToken,
250		],
251	6	'sink' => isset($options['SaveAs']) ? $options['SaveAs'] : null,
252		];
253
254	6	if (isset($options['FileId'])) {
255	3	$requestOptions['query'] = ['fileId' => $options['FileId']];
256	3	$requestUrl = $this->downloadUrl.'/b2api/v1/b2_download_file_by_id';
257		} else {
258	3	if (!isset($options['BucketName']) && isset($options['BucketId'])) {
259		$options['BucketName'] = $this->getBucketNameFromId($options['BucketId']);
260		}
261
262	3	$requestUrl = sprintf('%s/file/%s/%s', $this->downloadUrl, $options['BucketName'], $options['FileName']);
263		}
264
265	6	$this->authorizeAccount();
266
267	6	$response = $this->client->guzzleRequest('GET', $requestUrl, $requestOptions, false);
268
269	4	return isset($options['SaveAs']) ? true : $response;
270		}
271
272		/**
273		* Retrieve a collection of File objects representing the files stored inside a bucket.
274		*
275		* @param array $options
276		*
277		* @throws GuzzleException If the request fails.
278		* @throws B2Exception If the B2 server replies with an error.
279		*
280		* @return array
281		*/
282	2	public function listFiles(array $options)
283		{
284		// if FileName is set, we only attempt to retrieve information about that single file.
285	2	$fileName = !empty($options['FileName']) ? $options['FileName'] : null;
286
287	2	$nextFileName = null;
288	2	$maxFileCount = 1000;
289
290	2	$prefix = isset($options['Prefix']) ? $options['Prefix'] : '';
291	2	$delimiter = isset($options['Delimiter']) ? $options['Delimiter'] : null;
292
293	2	$files = [];
294
295	2	if (!isset($options['BucketId']) && isset($options['BucketName'])) {
296		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
297		}
298
299	2	if ($fileName) {
300		$nextFileName = $fileName;
301		$maxFileCount = 1;
302		}
303
304	2	$this->authorizeAccount();
305
306		// B2 returns, at most, 1000 files per "page". Loop through the pages and compile an array of File objects.
307	2	while (true) {
308	2	$response = $this->sendAuthorizedRequest('POST', 'b2_list_file_names', [
309	2	'bucketId' => $options['BucketId'],
310	2	'startFileName' => $nextFileName,
311	2	'maxFileCount' => $maxFileCount,
312	2	'prefix' => $prefix,
313	2	'delimiter' => $delimiter,
314		]);
315
316	2	foreach ($response['files'] as $file) {
317		// if we have a file name set, only retrieve information if the file name matches
318	1	if (!$fileName \|\| ($fileName === $file['fileName'])) {
319	1	$files[] = new File($file['fileId'], $file['fileName'], null, $file['size']);
320		}
321		}
322
323	2	if ($fileName \|\| $response['nextFileName'] === null) {
324		// We've got all the files - break out of loop.
325	2	break;
326		}
327
328	1	$nextFileName = $response['nextFileName'];
329		}
330
331	2	return $files;
332		}
333
334		/**
335		* Test whether a file exists in B2 for the given bucket.
336		*
337		* @param array $options
338		*
339		* @return bool
340		*/
341		public function fileExists(array $options)
342		{
343		$files = $this->listFiles($options);
344
345		return !empty($files);
346		}
347
348		/**
349		* Returns a single File object representing a file stored on B2.
350		*
351		* @param array $options
352		*
353		* @throws GuzzleException
354		* @throws NotFoundException If no file id was provided and BucketName + FileName does not resolve to a file, a NotFoundException is thrown.
355		* @throws GuzzleException If the request fails.
356		* @throws B2Exception If the B2 server replies with an error.
357		*
358		* @return File
359		*/
360	4	public function getFile(array $options)
361		{
362	4	if (!isset($options['FileId']) && isset($options['BucketId']) && isset($options['FileName'])) {
363		$files = $this->listFiles([
364		'BucketId' => $options['BucketId'],
365		'FileName' => $options['FileName'],
366		]);
367
368		if (empty($files)) {
369		throw new NotFoundException();
370		}
371
372		$options['FileId'] = $files[0]->getId();
373	4	} elseif (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
374		$options['FileId'] = $this->getFileIdFromBucketAndFileName($options['BucketName'], $options['FileName']);
375
376		if (!$options['FileId']) {
377		throw new NotFoundException();
378		}
379		}
380
381	4	$response = $this->sendAuthorizedRequest('POST', 'b2_get_file_info', [
382	4	'fileId' => $options['FileId'],
383		]);
384
385	3	return new File(
386	3	$response['fileId'],
387	3	$response['fileName'],
388	3	$response['contentSha1'],
389	3	$response['contentLength'],
390	3	$response['contentType'],
391	3	$response['fileInfo'],
392	3	$response['bucketId'],
393	3	$response['action'],
394	3	$response['uploadTimestamp']
395		);
396		}
397
398		/**
399		* Deletes the file identified by ID from Backblaze B2.
400		*
401		* @param array $options
402		*
403		* @throws GuzzleException
404		* @throws NotFoundException
405		* @throws GuzzleException If the request fails.
406		* @throws B2Exception If the B2 server replies with an error.
407		*
408		* @return bool
409		*/
410	3	public function deleteFile(array $options)
411		{
412	3	if (!isset($options['FileName'])) {
413	2	$file = $this->getFile($options);
414
415	2	$options['FileName'] = $file->getName();
416		}
417
418	3	if (!isset($options['FileId']) && isset($options['BucketName']) && isset($options['FileName'])) {
419		$file = $this->getFile($options);
420
421		$options['FileId'] = $file->getId();
422		}
423
424	3	$this->sendAuthorizedRequest('POST', 'b2_delete_file_version', [
425	3	'fileName' => $options['FileName'],
426	3	'fileId' => $options['FileId'],
427		]);
428
429	2	return true;
430		}
431
432		/**
433		* Authorize the B2 account in order to get an auth token and API/download URLs.
434		*/
435	27	protected function authorizeAccount()
436		{
437	27	if (Carbon::now('UTC')->timestamp < $this->reAuthTime->timestamp) {
438	4	return;
439		}
440
441	27	$response = $this->client->guzzleRequest('GET', self::B2_API_BASE_URL.self::B2_API_V1.'/b2_authorize_account', [
442	27	'auth' => [$this->accountId, $this->applicationKey],
443		]);
444
445	27	$this->authToken = $response['authorizationToken'];
446	27	$this->apiUrl = $response['apiUrl'].self::B2_API_V1;
447	27	$this->downloadUrl = $response['downloadUrl'];
448	27	$this->reAuthTime = Carbon::now('UTC');
449	27	$this->reAuthTime->addSeconds($this->authTimeoutSeconds);
450	27	}
451
452		/**
453		* Maps the provided bucket name to the appropriate bucket ID.
454		*
455		* @param $name
456		*
457		* @return mixed
458		*/
459		protected function getBucketIdFromName($name)
460		{
461		$buckets = $this->listBuckets();
462
463		foreach ($buckets as $bucket) {
464		if ($bucket->getName() === $name) {
465		return $bucket->getId();
466		}
467		}
468		}
469
470		/**
471		* Maps the provided bucket ID to the appropriate bucket name.
472		*
473		* @param $id
474		*
475		* @return mixed
476		*/
477		protected function getBucketNameFromId($id)
478		{
479		$buckets = $this->listBuckets();
480
481		foreach ($buckets as $bucket) {
482		if ($bucket->getId() === $id) {
483		return $bucket->getName();
484		}
485		}
486		}
487
488		/**
489		* @param $bucketName
490		* @param $fileName
491		*
492		* @return mixed
493		*/
494		protected function getFileIdFromBucketAndFileName($bucketName, $fileName)
495		{
496		$files = $this->listFiles([
497		'BucketName' => $bucketName,
498		'FileName' => $fileName,
499		]);
500
501		foreach ($files as $file) {
502		if ($file->getName() === $fileName) {
503		return $file->getId();
504		}
505		}
506		}
507
508		/**
509		* Uploads a large file using b2 large file procedure.
510		*
511		* @param array $options
512		*
513		* @return File
514		*/
515		public function uploadLargeFile(array $options)
516		{
517		if (substr($options['FileName'], 0, 1) === '/') {
518		$options['FileName'] = ltrim($options['FileName'], '/');
519		}
520
521		//if last char of path is not a "/" then add a "/"
522		if (substr($options['FilePath'], -1) != '/') {
523		$options['FilePath'] = $options['FilePath'].'/';
524		}
525
526		if (!isset($options['BucketId']) && isset($options['BucketName'])) {
527		$options['BucketId'] = $this->getBucketIdFromName($options['BucketName']);
528		}
529
530		if (!isset($options['FileContentType'])) {
531		$options['FileContentType'] = 'b2/x-auto';
532		}
533
534		$this->authorizeAccount();
535
536		// 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...
537		$start = $this->startLargeFile($options['FileName'], $options['FileContentType'], $options['BucketId']);
538
539		// 2) b2_get_upload_part_url for each thread uploading (takes fileId)
540		$url = $this->getUploadPartUrl($start['fileId']);
541
542		// 3) b2_upload_part for each part of the file
543		$parts = $this->uploadParts($options['FilePath'].$options['FileName'], $url['uploadUrl'], $url['authorizationToken']);
544
545		$sha1s = [];
546
547		foreach ($parts as $part) {
548		$sha1s[] = $part['contentSha1'];
549		}
550
551		// 4) b2_finish_large_file.
552		return $this->finishLargeFile($start['fileId'], $sha1s);
553		}
554
555		/**
556		* Starts the large file upload process.
557		*
558		* @param $fileName
559		* @param $contentType
560		* @param $bucketId
561		*
562		* @throws GuzzleException If the request fails.
563		* @throws B2Exception If the B2 server replies with an error.
564		*
565		* @return mixed
566		*/
567		protected function startLargeFile($fileName, $contentType, $bucketId)
568		{
569		return $this->sendAuthorizedRequest('POST', 'b2_start_large_file', [
570		'fileName' => $fileName,
571		'contentType' => $contentType,
572		'bucketId' => $bucketId,
573		]);
574		}
575
576		/**
577		* Gets the url for the next large file part upload.
578		*
579		* @param $fileId
580		*
581		* @throws GuzzleException If the request fails.
582		* @throws B2Exception If the B2 server replies with an error.
583		*
584		* @return mixed
585		*/
586		protected function getUploadPartUrl($fileId)
587		{
588		return $this->sendAuthorizedRequest('POST', 'b2_get_upload_part_url', [
589		'fileId' => $fileId,
590		]);
591		}
592
593		/**
594		* Uploads the file as "parts" of 100MB each.
595		*
596		* @param $filePath
597		* @param $uploadUrl
598		* @param $largeFileAuthToken
599		*
600		* @return array
601		*/
602		protected function uploadParts($filePath, $uploadUrl, $largeFileAuthToken)
603		{
604		$return = [];
605
606		$minimum_part_size = 100 * (1000 * 1000);
607
608		$local_file_size = filesize($filePath);
609		$total_bytes_sent = 0;
610		$bytes_sent_for_part = $minimum_part_size;
611		$sha1_of_parts = [];
612		$part_no = 1;
613		$file_handle = fopen($filePath, 'r');
614
615		while ($total_bytes_sent < $local_file_size) {
616
617		// Determine the number of bytes to send based on the minimum part size
618		if (($local_file_size - $total_bytes_sent) < $minimum_part_size) {
619		$bytes_sent_for_part = ($local_file_size - $total_bytes_sent);
620		}
621
622		// Get a sha1 of the part we are going to send
623		fseek($file_handle, $total_bytes_sent);
624		$data_part = fread($file_handle, $bytes_sent_for_part);
625		array_push($sha1_of_parts, sha1($data_part));
626		fseek($file_handle, $total_bytes_sent);
627
628		$response = $this->client->guzzleRequest('POST', $uploadUrl, [
629		'headers' => [
630		'Authorization' => $largeFileAuthToken,
631		'Content-Length' => $bytes_sent_for_part,
632		'X-Bz-Part-Number' => $part_no,
633		'X-Bz-Content-Sha1' => $sha1_of_parts[$part_no - 1],
634		],
635		'body' => $data_part,
636		]);
637
638		$return[] = $response;
639
640		// Prepare for the next iteration of the loop
641		$part_no++;
642		$total_bytes_sent = $bytes_sent_for_part + $total_bytes_sent;
643		}
644
645		fclose($file_handle);
646
647		return $return;
648		}
649
650		/**
651		* Finishes the large file upload procedure.
652		*
653		* @param $fileId
654		* @param array $sha1s
655		*
656		* @throws GuzzleException If the request fails.
657		* @throws B2Exception If the B2 server replies with an error.
658		*
659		* @return File
660		*/
661		protected function finishLargeFile($fileId, array $sha1s)
662		{
663		$response = $this->sendAuthorizedRequest('POST', 'b2_finish_large_file', [
664		'fileId' => $fileId,
665		'partSha1Array' => $sha1s,
666		]);
667
668		return new File(
669		$response['fileId'],
670		$response['fileName'],
671		$response['contentSha1'],
672		$response['contentLength'],
673		$response['contentType'],
674		$response['fileInfo'],
675		$response['bucketId'],
676		$response['action'],
677		$response['uploadTimestamp']
678		);
679		}
680
681		/**
682		* Sends a authorized request to b2 API.
683		*
684		* @param string $method
685		* @param string $route
686		* @param array $json
687		*
688		* @throws GuzzleException If the request fails.
689		* @throws B2Exception If the B2 server replies with an error.
690		*
691		* @return mixed
692		*/
693	21	protected function sendAuthorizedRequest($method, $route, $json = [])
694		{
695	21	$this->authorizeAccount();
696
697	21	return $this->client->guzzleRequest($method, $this->apiUrl.$route, [
698		'headers' => [
699	21	'Authorization' => $this->authToken,
700		],
701	21	'json' => $json,
702		]);
703		}
704		}
705

gliterd / backblaze-b2

Pull Request — master (#62)

Client::getFile() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like