blue-twilight/app/Services/BackblazeB2Service.php

<?php

namespace App\Services;

class BackblazeB2Service
{
    /**
     * The individual URL for the account to use to access the API
     * @var string
     */
    private $accountApiUrl;

    /**
     * ID of the account in Backblaze B2.
     * @var string
     */
    private $accountID;

    /**
     * The base URL for public access to the account's files.
     * @var string
     */
    private $downloadUrl;

    /**
     * Authorisation header for authenticating to the API.
     * @var string
     */
    private $authHeader;

    /**
     * Authorisation token for accessing the API post-authentication.
     * @var string
     */
    private $authToken;

    /**
     * ID of the bucket.
     * @var string
     */
    private $bucketId;

    /**
     * Type of the bucket.
     * @var integer
     */
    private $bucketType;

    /**
     * Configuration related to the Backblaze B2 service.
     * @var \Illuminate\Config\Repository|mixed
     */
    private $config;

    public function __construct()
    {
        $this->config = config('services.backblaze_b2');
    }

    public function authorizeAccount($force = false)
    {
        if (empty($this->authToken) || $force)
        {
            $result = $this->sendRequest($this->config['auth_url']);

            if (!isset($result->authorizationToken))
            {
                throw new \Exception('Authorisation to Backblaze failed. Is the API key correct?');
            }

            $this->authToken = $result->authorizationToken;
            $this->accountApiUrl = $result->apiUrl;
            $this->accountID = $result->accountId;
            $this->downloadUrl = $result->downloadUrl;
        }
    }

    public function getBucketType()
    {
        return $this->bucketType;
    }

    public function getDownloadAuthToken()
    {
        $result = $this->sendRequest(
            sprintf('%s/b2api/v2/b2_get_download_authorization', $this->accountApiUrl),
            'POST',
            [
                'bucketId' => $this->bucketId,
                'validDurationInSeconds' => intval($this->config['download_token_lifetime']),
                'fileNamePrefix' => ''
            ]
        );

        return $result->authorizationToken;
    }

    public function getDownloadUrl()
    {
        return $this->downloadUrl;
    }

    public function setBucketName($bucketName)
    {
        $bucketDetails = $this->getBucketDetailsFromName($bucketName);

        $this->bucketId = $bucketDetails->bucketId;
        $this->bucketType = $bucketDetails->bucketType;
    }

    public function setCredentials($applicationKeyID, $applicationKey)
    {
        $this->authHeader = sprintf('%s:%s', $applicationKeyID, $applicationKey);
    }

    public function uploadFile($pathToFileToUpload, $pathToStorage)
    {
        // Get a URL to upload our file to
        list($uploadUrl, $authorizationToken) = $this->getUploadUrl();

        if (empty($uploadUrl) || empty($authorizationToken))
        {
            throw new \Exception('No upload URL/authorization token returned from Backblaze B2.');
        }

        $fileSize = filesize($pathToFileToUpload);
        $handle = fopen($pathToFileToUpload, 'r');
        $fileContents = fread($handle, $fileSize);
        fclose($handle);
        $fileContentsSha1 = sha1_file($pathToFileToUpload);

        $ch = $this->getBasicHttpClient($uploadUrl, 'POST', [
            sprintf('Authorization: %s', $authorizationToken),
            'Content-Type: b2/x-auto',
            sprintf('X-Bz-Content-Sha1: %s', $fileContentsSha1),
            sprintf('X-Bz-File-Name: %s', urlencode($pathToStorage))
        ]);

        curl_setopt($ch, CURLOPT_POSTFIELDS, $fileContents);

        $result = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($httpCode != 200 && $httpCode != 304)
        {
            throw new \Exception(sprintf('Exception from Backblaze B2: %s', $result));
        }

        curl_close($ch);
    }

    private function getBucketDetailsFromName($bucketName)
    {
        $result = $this->sendRequest(
            sprintf('%s/b2api/v2/b2_list_buckets', $this->accountApiUrl),
            'POST',
            [
                'accountId' => $this->accountID,
                'bucketName' => $bucketName
            ]
        );

        if (isset($result->buckets) && is_array($result->buckets) && count($result->buckets) >= 1)
        {
            return $result->buckets[0];
        }

        throw new \Exception(sprintf('The bucket \'%s\' was not found or your API key does not have access.', $bucketName));
    }

    private function getUploadUrl()
    {
        $result = $this->sendRequest(
            sprintf('%s/b2api/v2/b2_get_upload_url', $this->accountApiUrl),
            'POST',
            ['bucketId' => $this->bucketId]
        );

        return [$result->uploadUrl, $result->authorizationToken];
    }

    private function getBasicHttpClient($url, $method = 'GET', array $httpHeaders = [])
    {
        $httpHeaders = array_merge(
            [
                'Accept: application/json'
            ],
            $httpHeaders
        );

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $httpHeaders);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        switch (strtoupper($method))
        {
            case 'GET':
                curl_setopt($ch, CURLOPT_HTTPGET, true);
                break;

            case 'POST':
                curl_setopt($ch, CURLOPT_POST, true);
                break;
        }

        return $ch;
    }

    private function sendRequest($url, $method = 'GET', $postData = null)
    {
        $httpHeaders = [];

        if (is_null($this->authToken))
        {
            // No auth token yet, use username/password
            $httpHeaders[] = sprintf('Authorization: Basic %s', base64_encode($this->authHeader));
        }
        else
        {
            // Use the auth token we have
            $httpHeaders[] = sprintf('Authorization: %s', $this->authToken);
        }

        $ch = $this->getBasicHttpClient($url, $method, $httpHeaders);

        if (!is_null($postData))
        {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($postData));
        }

        $result = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($httpCode != 200 && $httpCode != 304)
        {
            throw new \Exception(sprintf('Exception from Backblaze B2: %s', $result));
        }

        curl_close($ch);

        return json_decode($result);
    }
}