storage_bucket.php

См. документацию.

<?php
IncludeModuleLangFile(__FILE__);

class CCloudStorageBucket
{
    protected/*.int.*/$_ID = 0;
    protected/*.array[string]string.*/$arBucket;
    protected $enabledFailover = true;
    protected/*.CCloudStorageBucket.*/$failoverBucket;
    protected $queueFlag = true;
    protected/*.CCloudStorageService.*/ $service;
    protected static/*.array[int][string]string.*/$arBuckets;

    public function __construct($ID, $enabledFailover = true)
    {
        $this->_ID = intval($ID);
        if (!$enabledFailover)
        {
            $this->disableFailOver();
        }
    }
 
    public function disableFailOver()
    {
        $this->enabledFailover = false;
    }

    public function isFailoverEnabled()
    {
        return $this->enabledFailover;
    }

    public function setQueueFlag($queueFlag = true)
    {
        $this->queueFlag = (bool)$queueFlag;
    }

    public function getQueueFlag()
    {
        return $this->queueFlag;
    }
 
    protected function GetActualBucketId()
    {
        if (
            $this->isFailoverEnabled() && CCloudFailover::IsEnabled()
            && $this->FAILOVER_ACTIVE === 'Y'
            && $this->FAILOVER_BUCKET_ID > 0
        )
        {
            return $this->FAILOVER_BUCKET_ID;
        }
        else
        {
            return $this->ID;
        }
    }

    public function getBucketArray()
    {
        if (!isset($this->arBucket))
        {
            self::_init();
            $this->arBucket = self::$arBuckets[$this->_ID];
            if (
                $this->isFailoverEnabled() && CCloudFailover::IsEnabled()
                && $this->arBucket['FAILOVER_ACTIVE'] === 'Y'
                && $this->arBucket['FAILOVER_BUCKET_ID'] > 0
            )
            {
                $this->failoverBucket = new CCloudStorageBucket($this->FAILOVER_BUCKET_ID, false);
                if ($this->failoverBucket->Init())
                {
                    $this->arBucket['SERVICE_ID'] = $this->failoverBucket->SERVICE_ID;
                    $this->arBucket['BUCKET'] = $this->failoverBucket->BUCKET;
                    $this->arBucket['LOCATION'] = $this->failoverBucket->LOCATION;
                    $this->arBucket['CNAME'] = $this->failoverBucket->CNAME;
                    $this->arBucket['PREFIX'] = $this->failoverBucket->PREFIX;
                    $this->arBucket['SETTINGS'] = $this->failoverBucket->SETTINGS;
                }
                else
                {
                    $this->failoverBucket = null;
                }
            }
        }
 
        return $this->arBucket;
    }

    public function getService()
    {
        return $this->service;
    }

    private static function CompileModuleRule($str)
    {
        $res = [];
        $ar = explode(',', $str);
        foreach ($ar as $s)
        {
            $s = trim($s);
            if ($s !== '')
            {
                $res[$s] = preg_quote($s, '/');
            }
        }
        if (!empty($res))
        {
            return '/^(' . implode('|', $res) . ')$/';
        }
        else
        {
            return '';
        }
    }

    private static function CompileExtentionRule($str)
    {
        $res = [];
        $ar = explode(',', $str);
        foreach ($ar as $s)
        {
            $s = trim($s);
            if ($s !== '')
            {
                $res[$s] = preg_quote('.' . $s, '/');
            }
        }
        if (!empty($res))
        {
            return '/(' . implode('|', $res) . ')$/i';
        }
        else
        {
            return '';
        }
    }

    private static function ParseSize($str)
    {
        static $scale = [
            '' => 1.0,
            'K' => 1024.0,
            'M' => 1048576.0,
            'G' => 1073741824.0,
        ];
        $str = mb_strtoupper(trim($str));
        if ($str !== '' && preg_match('/([0-9.]+)(|K|M|G)$/', $str, $match) > 0)
        {
            return doubleval($match[1]) * $scale[$match[2]];
        }
        else
        {
            return 0.0;
        }
    }

    private static function CompileSizeRule($str)
    {
        $res = /*.(array[int][int]double).*/[];
        $ar = explode(',', $str);
        foreach ($ar as $s)
        {
            $s = trim($s);
            if ($s !== '')
            {
                $arSize = explode('-', $s);
                if (count($arSize) == 1)
                {
                    $res[] = [self::ParseSize($arSize[0]), self::ParseSize($arSize[0])];
                }
                else
                {
                    $res[] = [self::ParseSize($arSize[0]), self::ParseSize($arSize[1])];
                }
            }
        }
        return $res;
    }

    private static function CompileRules($arRules)
    {
        $arCompiled = /*.(array[int][string]string).*/[];
        if (is_array($arRules))
        {
            foreach ($arRules as $rule)
            {
                if (is_array($rule))
                {
                    $arCompiled[] = [
                        'MODULE_MASK' => isset($rule['MODULE']) ? self::CompileModuleRule($rule['MODULE']) : '',
                        'EXTENTION_MASK' => isset($rule['EXTENSION']) ? self::CompileExtentionRule($rule['EXTENSION']) : '',
                        'SIZE_ARRAY' => isset($rule['SIZE']) ? self::CompileSizeRule($rule['SIZE']) : '',
                    ];
                }
            }
        }
        return $arCompiled;
    }

    private static function _init()
    {
        global $DB, $CACHE_MANAGER;
 
        if (isset(self::$arBuckets))
        {
            return;
        }
 
        $cache_id = 'cloud_buckets_v2';
        if (
            CACHED_b_clouds_file_bucket !== false
            && $CACHE_MANAGER->Read(CACHED_b_clouds_file_bucket, $cache_id, 'b_clouds_file_bucket')
        )
        {
            self::$arBuckets = $CACHE_MANAGER->Get($cache_id);
        }
        else
        {
            self::$arBuckets = /*.(array[int]CCloudStorageBucket).*/[];
 
            $rs = $DB->Query('
                SELECT *
                FROM b_clouds_file_bucket
                ORDER BY SORT DESC, ID ASC
            ');
            while (is_array($ar = $rs->Fetch()))
            {
                if ($ar['FILE_RULES'] != '')
                {
                    $arRules = unserialize($ar['FILE_RULES'], ['allowed_classes' => false]);
                }
                else
                {
                    $arRules = [];
                }
 
                $ar['FILE_RULES_COMPILED'] = self::CompileRules($arRules);
 
                if ($ar['SETTINGS'] != '')
                {
                    $arSettings = unserialize($ar['SETTINGS'], ['allowed_classes' => false]);
                }
                else
                {
                    $arSettings = [];
                }
 
                if (is_array($arSettings))
                {
                    $ar['SETTINGS'] = $arSettings;
                }
                else
                {
                    $ar['SETTINGS'] = [];
                }
 
                self::$arBuckets[intval($ar['ID'])] = $ar;
            }
 
            if (CACHED_b_clouds_file_bucket !== false)
            {
                $CACHE_MANAGER->Set($cache_id, self::$arBuckets);
            }
        }
    }

    public function __get($name)
    {
        $arBucket = $this->getBucketArray();
        if ($arBucket && array_key_exists($name, $arBucket))
        {
            return $arBucket[$name];
        }
        else
        {
            return null;
        }
    }

    public function Init()
    {
        if (is_object($this->service))
        {
            return true;
        }
        else
        {
            if ($this->SERVICE_ID)
            {
                $this->service = CCloudStorage::GetServiceByID($this->SERVICE_ID);
            }
            return is_object($this->service);
        }
    }

    public function RenewToken()
    {
        if ($this->service->tokenHasExpired)
        {
            $arBucket = $this->failoverBucket ? $this->failoverBucket->arBucket : $this->arBucket;
            $newSettings = false;
            foreach (GetModuleEvents('clouds', 'OnExpiredToken', true) as $arEvent)
            {
                $newSettings = ExecuteModuleEventEx($arEvent, [$arBucket]);
                if ($newSettings)
                {
                    break;
                }
            }
 
            if ($newSettings)
            {
                if ($this->failoverBucket)
                {
                    $updateResult = $this->failoverBucket->Update(['SETTINGS' => $newSettings]);
                    $this->arBucket = null;
                }
                else
                {
                    $updateResult = $this->Update(['SETTINGS' => $newSettings]);
                }
 
                if ($updateResult)
                {
                    $this->service->tokenHasExpired = false;
                    return true;
                }
            }
        }
 
        return false;
    }

    public function CheckSettings(&$arSettings)
    {
        return $this->service->CheckSettings($this->arBucket, $arSettings);
    }

    public function CreateBucket()
    {
        return $this->service->CreateBucket($this->arBucket);
    }

    public function GetFileSRC($arFile, $encoded = true)
    {
        if (is_array($arFile) && isset($arFile['URN']))
        {
            return $this->service->GetFileSRC($this->arBucket, $arFile['URN'], $encoded);
        }
        else
        {
            return preg_replace("'(?<!:)/+'s", '/', $this->service->GetFileSRC($this->arBucket, $arFile, $encoded));
        }
    }

    public function FileExists($filePath)
    {
        $result = $this->service->FileExists($this->arBucket, $filePath);
        if (!$result && $this->RenewToken())
        {
            $result = $this->service->FileExists($this->getBucketArray(), $filePath);
        }
        return $result;
    }

    public function DownloadToFile($arFile, $filePath)
    {
        $result = $this->service->DownloadToFile($this->arBucket, $arFile, $filePath);
        return $result;
    }

    public function SaveFile($filePath, $arFile)
    {
        $result = $this->service->SaveFile($this->arBucket, $filePath, $arFile);
        if (!$result && $this->RenewToken())
        {
            $result = $this->service->SaveFile($this->getBucketArray(), $filePath, $arFile);
        }
 
        if ($result)
        {
            if ($this->queueFlag)
            {
                CCloudFailover::queueCopy($this, $filePath);
            }
 
            foreach (GetModuleEvents('clouds', 'OnAfterSaveFile', true) as $arEvent)
            {
                ExecuteModuleEventEx($arEvent, [$this, $arFile, $filePath]);
            }
        }
        return $result;
    }

    public function DeleteFile($filePath, $fileSize = null)
    {
        $result = $this->service->DeleteFile($this->arBucket, $filePath);
        if (!$result && $this->RenewToken())
        {
            $result = $this->service->DeleteFile($this->getBucketArray(), $filePath);
        }
 
        if ($result)
        {
            if ($this->queueFlag)
            {
                CCloudFailover::queueDelete($this, $filePath);
            }
 
            $eventData = [
                'del' => 'Y',
                'size' => $fileSize,
            ];
            foreach (GetModuleEvents('clouds', 'OnAfterDeleteFile', true) as $arEvent)
            {
                ExecuteModuleEventEx($arEvent, [$this, $eventData, $filePath]);
            }
        }
        return $result;
    }

    public function FileCopy($arFile, $filePath)
    {
        $result = $this->service->FileCopy($this->arBucket, $arFile, $filePath);
        if (!$result && $this->RenewToken())
        {
            $result = $this->service->FileCopy($this->getBucketArray(), $arFile, $filePath);
        }
 
        if ($result)
        {
            if ($this->queueFlag)
            {
                CCloudFailover::queueCopy($this, $filePath);
            }
 
            foreach (GetModuleEvents('clouds', 'OnAfterCopyFile', true) as $arEvent)
            {
                ExecuteModuleEventEx($arEvent, [$this, $arFile, $filePath]);
            }
        }
        return $result;
    }

    public function FileRename($sourcePath, $targetPath, $overwrite = true)
    {
        $result = $this->service->FileRename($this->arBucket, $sourcePath, $targetPath, $overwrite);
        if ($result)
        {
            if ($this->queueFlag)
            {
                CCloudFailover::queueRename($this, $sourcePath, $targetPath);
            }
 
            foreach (GetModuleEvents('clouds', 'OnAfterRenameFile', true) as $arEvent)
            {
                ExecuteModuleEventEx($arEvent, [$this, $sourcePath, $targetPath]);
            }
        }
        return $result;
    }

    public function ListFiles($filePath = '/', $bRecursive = false, $pageSize = 0, $pageMarker = '')
    {
        $result = $this->service->ListFiles($this->arBucket, $filePath, $bRecursive, $pageSize, $pageMarker);
        if (!$result && $this->RenewToken())
        {
            $result = $this->service->ListFiles($this->getBucketArray(), $filePath, $bRecursive, $pageSize, $pageMarker);
        }
        return $result;
    }

    public function GetFileInfo($filePath)
    {
        $DIR_NAME = mb_substr($filePath, 0, mb_strrpos($filePath, '/') + 1);
        $FILE_NAME = mb_substr($filePath, mb_strlen($DIR_NAME));
 
        $arFileInfo = $this->service->GetFileInfo($this->arBucket, $filePath);
        if ($arFileInfo === false && $this->RenewToken())
        {
            $arFileInfo = $this->service->GetFileInfo($this->getBucketArray(), $filePath);
        }
 
        if ($arFileInfo === null)
        {
            $arListing = $this->service->ListFiles($this->arBucket, $DIR_NAME, false);
            if (is_array($arListing))
            {
                foreach ($arListing['file'] as $i => $name)
                {
                    if ($name === $FILE_NAME)
                    {
                        return [
                            'name' => $name,
                            'size' => $arListing['file_size'][$i],
                            'mtime' => $arListing['file_mtime'][$i],
                            'hash' => $arListing['file_hash'][$i],
                        ];
                    }
                }
            }
        }
        elseif ($arFileInfo)
        {
            $arFileInfo['name'] = $FILE_NAME;
            return $arFileInfo;
        }
        return false;
    }

    public function GetFileSize($filePath)
    {
        $fileInfo = $this->GetFileInfo($filePath);
        if ($fileInfo)
        {
            return doubleval($fileInfo['size']);
        }
        else
        {
            return 0.0;
        }
    }

    public static function GetAllBuckets()
    {
        self::_init();
        return self::$arBuckets;
    }

    public function CheckFields(&$arFields, $ID)
    {
        global $APPLICATION;
        $aMsg = [];
 
        if (array_key_exists('ACTIVE', $arFields))
        {
            $arFields['ACTIVE'] = $arFields['ACTIVE'] === 'N' ? 'N' : 'Y';
        }
 
        if (array_key_exists('READ_ONLY', $arFields))
        {
            $arFields['READ_ONLY'] = $arFields['READ_ONLY'] === 'Y' ? 'Y' : 'N';
        }
 
        $arServices = CCloudStorage::GetServiceList();
        if (isset($arFields['SERVICE_ID']))
        {
            if (!array_key_exists($arFields['SERVICE_ID'], $arServices))
            {
                $aMsg[] = ['id' => 'SERVICE_ID', 'text' => GetMessage('CLO_STORAGE_WRONG_SERVICE')];
            }
        }
 
        if (isset($arFields['BUCKET']))
        {
            $arFields['BUCKET'] = trim($arFields['BUCKET']);
 
            $bBadLength = false;
            if (mb_strpos($arFields['BUCKET'], '.') !== false)
            {
                $arName = explode('.', $arFields['BUCKET']);
                $bBadLength = false;
                foreach ($arName as $str)
                {
                    if (mb_strlen($str) < 2 || mb_strlen($str) > 63)
                    {
                        $bBadLength = true;
                    }
                }
            }
 
            if ($arFields['BUCKET'] == '')
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_EMPTY_BUCKET')];
            }
            if (preg_match('/[^a-z0-9._-]/', $arFields['BUCKET']) > 0)
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_BAD_BUCKET_NAME')];
            }
            if (mb_strlen($arFields['BUCKET']) < 2 || mb_strlen($arFields['BUCKET']) > 63)
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_WRONG_BUCKET_NAME_LENGTH')];
            }
            if ($bBadLength)
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_WRONG_BUCKET_NAME_LENGTH2')];
            }
            if (!preg_match('/^[a-z0-9].*[a-z0-9]$/', $arFields['BUCKET']))
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_BAD_BUCKET_NAME2')];
            }
            if (preg_match('/(-\\.|\\.-)/', $arFields['BUCKET']) > 0)
            {
                $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_BAD_BUCKET_NAME3')];
            }
 
            if ($arFields['BUCKET'] <> '')
            {
                $rsBucket = self::GetList([], [
                    '=SERVICE_ID' => $arFields['SERVICE_ID'],
                    '=BUCKET' => $arFields['BUCKET'],
                ]);
                $arBucket = $rsBucket->Fetch();
                if (is_array($arBucket) && $arBucket['ID'] != $ID)
                {
                    $aMsg[] = ['id' => 'BUCKET', 'text' => GetMessage('CLO_STORAGE_BUCKET_ALREADY_EXISTS')];
                }
            }
        }
 
        if (array_key_exists('FAILOVER_ACTIVE', $arFields))
        {
            $arFields['FAILOVER_ACTIVE'] = $arFields['FAILOVER_ACTIVE'] === 'Y' ? 'Y' : 'N';
        }
 
        if (isset($arFields['FAILOVER_BUCKET_ID']) && $arFields['FAILOVER_BUCKET_ID'] == $ID)
        {
            unset($arFields['FAILOVER_BUCKET_ID']);
        }
 
        if (array_key_exists('FAILOVER_COPY', $arFields))
        {
            $arFields['FAILOVER_COPY'] = $arFields['FAILOVER_COPY'] === 'Y' ? 'Y' : 'N';
        }
 
        if (array_key_exists('FAILOVER_DELETE', $arFields))
        {
            $arFields['FAILOVER_DELETE'] = $arFields['FAILOVER_DELETE'] === 'Y' ? 'Y' : 'N';
        }
 
        if (array_key_exists('FAILOVER_DELETE_DELAY', $arFields))
        {
            $arFields['FAILOVER_DELETE_DELAY'] = (int)$arFields['FAILOVER_DELETE_DELAY'];
        }
 
        if (array_key_exists('CNAME', $arFields))
        {
            $arFields['CNAME'] = preg_replace('#^https?://#i', '', $arFields['CNAME']);
        }
 
        if (!empty($aMsg))
        {
            $e = new CAdminException($aMsg);
            $APPLICATION->ThrowException($e);
            return false;
        }
        return true;
    }

    public static function GetList($arOrder=[], $arFilter=[], $arSelect=[])
    {
        global $DB;
 
        if (!is_array($arSelect))
        {
            $arSelect = /*.(array[string]string).*/[];
        }
        if (count($arSelect) < 1)
        {
            $arSelect = [
                'ID',
                'ACTIVE',
                'READ_ONLY',
                'SORT',
                'SERVICE_ID',
                'LOCATION',
                'BUCKET',
                'SETTINGS',
                'CNAME',
                'PREFIX',
                'FILE_COUNT',
                'FILE_SIZE',
                'LAST_FILE_ID',
                'FILE_RULES',
                'FAILOVER_ACTIVE',
                'FAILOVER_BUCKET_ID',
                'FAILOVER_COPY',
                'FAILOVER_DELETE',
                'FAILOVER_DELETE_DELAY',
            ];
        }
 
        if (!is_array($arOrder))
        {
            $arOrder = /*.(array[string]string).*/[];
        }
 
        $arQueryOrder = [];
        foreach ($arOrder as $strColumn => $strDirection)
        {
            $strColumn = mb_strtoupper($strColumn);
            $strDirection = mb_strtoupper($strDirection) === 'ASC' ? 'ASC' : 'DESC';
            switch ($strColumn)
            {
                case 'ID':
                case 'SORT':
                    $arSelect[] = $strColumn;
                    $arQueryOrder[$strColumn] = $strColumn . ' ' . $strDirection;
                    break;
                default:
                    break;
            }
        }
 
        $arQuerySelect = [];
        foreach ($arSelect as $strColumn)
        {
            $strColumn = mb_strtoupper($strColumn);
            switch ($strColumn)
            {
                case 'ID':
                case 'ACTIVE':
                case 'READ_ONLY':
                case 'SORT':
                case 'SERVICE_ID':
                case 'LOCATION':
                case 'BUCKET':
                case 'SETTINGS':
                case 'CNAME':
                case 'PREFIX':
                case 'FILE_COUNT':
                case 'FILE_SIZE':
                case 'LAST_FILE_ID':
                case 'FILE_RULES':
                case 'FAILOVER_ACTIVE':
                case 'FAILOVER_BUCKET_ID':
                case 'FAILOVER_COPY':
                case 'FAILOVER_DELETE':
                case 'FAILOVER_DELETE_DELAY':
                    $arQuerySelect[$strColumn] = 's.' . $strColumn;
                    break;
            }
        }
        if (count($arQuerySelect) < 1)
        {
            $arQuerySelect = ['ID' => 's.ID'];
        }
 
        $obQueryWhere = new CSQLWhere;
        $arFields = [
            'ID' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.ID',
                'FIELD_TYPE' => 'int',
            ],
            'ACTIVE' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.ACTIVE',
                'FIELD_TYPE' => 'string',
            ],
            'READ_ONLY' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.READ_ONLY',
                'FIELD_TYPE' => 'string',
            ],
            'SERVICE_ID' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.SERVICE_ID',
                'FIELD_TYPE' => 'string',
            ],
            'BUCKET' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.BUCKET',
                'FIELD_TYPE' => 'string',
            ],
            'FAILOVER_ACTIVE' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.FAILOVER_ACTIVE',
                'FIELD_TYPE' => 'string',
            ],
            'FAILOVER_BUCKET_ID' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.FAILOVER_BUCKET_ID',
                'FIELD_TYPE' => 'int',
            ],
            'FAILOVER_COPY' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.FAILOVER_COPY',
                'FIELD_TYPE' => 'string',
            ],
            'FAILOVER_DELETE' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.FAILOVER_DELETE',
                'FIELD_TYPE' => 'string',
            ],
            'FAILOVER_DELETE_DELAY' => [
                'TABLE_ALIAS' => 's',
                'FIELD_NAME' => 's.FAILOVER_DELETE_DELAY',
                'FIELD_TYPE' => 'int',
            ],
        ];
        $obQueryWhere->SetFields($arFields);
 
        if (!is_array($arFilter))
        {
            $arFilter = /*.(array[string]string).*/[];
        }
        $strQueryWhere = $obQueryWhere->GetQuery($arFilter);
 
        $bDistinct = $obQueryWhere->bDistinctReqired;
 
        $strSql = '
            SELECT ' . ($bDistinct ? 'DISTINCT' : '') . '
            ' . implode(', ', $arQuerySelect) . '
            FROM
                b_clouds_file_bucket s
            ' . $obQueryWhere->GetJoins() . '
        ';
 
        if ($strQueryWhere !== '')
        {
            $strSql .= '
                WHERE
                ' . $strQueryWhere . '
            ';
        }
 
        if (count($arQueryOrder) > 0)
        {
            $strSql .= '
                ORDER BY
                ' . implode(', ', $arQueryOrder) . '
            ';
        }
 
        return $DB->Query($strSql);
    }

    public function Add($arFields, $createBucket = true)
    {
        global $DB, $APPLICATION, $CACHE_MANAGER;
        $strError = '';
        $this->_ID = 0;
 
        if (!$this->CheckFields($arFields, 0))
        {
            return false;
        }
 
        $arFields['FILE_COUNT'] = 0;
        if (is_array($arFields['FILE_RULES']))
        {
            $arFields['FILE_RULES'] = serialize($arFields['FILE_RULES']);
        }
        else
        {
            $arFields['FILE_RULES'] = false;
        }
 
        $this->arBucket = $arFields;
        if ($this->Init())
        {
            if (!$this->CheckSettings($arFields['SETTINGS']))
            {
                return false;
            }
            $this->arBucket['SETTINGS'] = $arFields['SETTINGS'];
 
            if ($createBucket)
            {
                $creationResult = $this->CreateBucket();
            }
            else
            {
                $creationResult = true;
            }
 
            if ($creationResult)
            {
                $arFields['SETTINGS'] = serialize($arFields['SETTINGS']);
                $this->_ID = $DB->Add('b_clouds_file_bucket', $arFields);
                self::$arBuckets = null;
                $this->arBucket = null;
                if (CACHED_b_clouds_file_bucket !== false)
                {
                    $CACHE_MANAGER->CleanDir('b_clouds_file_bucket');
                }
                return $this->_ID;
            }
            else
            {
                $e = $APPLICATION->GetException();
                if (is_object($e))
                {
                    $strError = GetMessage('CLO_STORAGE_CLOUD_ADD_ERROR', ['#error_msg#' => $e->GetString()]);
                }
                else
                {
                    $strError = GetMessage('CLO_STORAGE_CLOUD_ADD_ERROR', ['#error_msg#' => 'CSB42343']);
                }
            }
        }
        else
        {
            $strError = GetMessage('CLO_STORAGE_CLOUD_ADD_ERROR', ['#error_msg#' => GetMessage('CLO_STORAGE_UNKNOWN_SERVICE')]);
        }
 
        $APPLICATION->ResetException();
        $e = new CApplicationException($strError);
        $APPLICATION->ThrowException($e);
        return false;
    }

    public function Delete()
    {
        global $DB, $APPLICATION, $CACHE_MANAGER;
        $strError = '';
 
        if ($this->Init())
        {
            $isEmptyBucket = $this->service->IsEmptyBucket($this->arBucket);
            $forceDeleteTry = false;
            if (!$isEmptyBucket && is_object($APPLICATION->GetException()))
            {
                // The bucket was created within wrong s3 region
                if (
                    $this->service->GetLastRequestStatus() == 301
                    && $this->service->GetLastRequestHeader('x-amz-bucket-region') !== ''
                )
                {
                    $forceDeleteTry = true;
                }
            }
 
            if ($isEmptyBucket || $forceDeleteTry)
            {
                $isDeleted = $this->service->DeleteBucket($this->arBucket);
                $forceDelete = false;
                if (!$isDeleted && is_object($APPLICATION->GetException()))
                {
                    // The bucket was created within wrong s3 region
                    if (
                        $this->service->GetLastRequestStatus() == 301
                        && $this->service->GetLastRequestHeader('x-amz-bucket-region') !== ''
                    )
                    {
                        $forceDelete = true;
                    }
                }
 
                if ($isDeleted || $forceDelete)
                {
                    $res = $DB->Query('DELETE FROM b_clouds_file_bucket WHERE ID = ' . $this->_ID);
                    if (CACHED_b_clouds_file_bucket !== false)
                    {
                        $CACHE_MANAGER->CleanDir('b_clouds_file_bucket');
                    }
                    if (is_object($res))
                    {
                        $this->arBucket = null;
                        $this->_ID = 0;
                        return true;
                    }
                    else
                    {
                        $strError = GetMessage('CLO_STORAGE_DB_DELETE_ERROR');
                    }
                }
                else
                {
                    $e = $APPLICATION->GetException();
                    $strError = GetMessage('CLO_STORAGE_CLOUD_DELETE_ERROR', ['#error_msg#' => is_object($e) ? $e->GetString() : '']);
                }
            }
            else
            {
                $e = $APPLICATION->GetException();
                if (is_object($e))
                {
                    $strError = GetMessage('CLO_STORAGE_CLOUD_DELETE_ERROR', ['#error_msg#' => $e->GetString()]);
                }
                else
                {
                    $strError = GetMessage('CLO_STORAGE_CLOUD_BUCKET_NOT_EMPTY');
                }
            }
        }
        else
        {
            $strError = GetMessage('CLO_STORAGE_CLOUD_DELETE_ERROR', ['#error_msg#' => GetMessage('CLO_STORAGE_UNKNOWN_SERVICE')]);
        }
 
        $APPLICATION->ResetException();
        $e = new CApplicationException($strError);
        $APPLICATION->ThrowException($e);
        return false;
    }

    public function Update($arFields)
    {
        global $DB, $CACHE_MANAGER;
 
        if ($this->_ID <= 0)
        {
            return false;
        }
 
        unset($arFields['FILE_COUNT']);
        unset($arFields['SERVICE_ID']);
        unset($arFields['LOCATION']);
        unset($arFields['BUCKET']);
 
        if (
            array_key_exists('SETTINGS', $arFields)
            && is_array($arFields['SETTINGS'])
            && isset($arFields['SETTINGS']['MIGRATE_TO'])
            && $arFields['SETTINGS']['MIGRATE_TO']
        )
        {
            $this->SERVICE_ID = $arFields['SERVICE_ID'] = $arFields['SETTINGS']['MIGRATE_TO'];
        }
 
        $this->service = CCloudStorage::GetServiceByID($this->SERVICE_ID);
        if (!is_object($this->service))
        {
            return false;
        }
 
        if (!$this->CheckFields($arFields, $this->_ID))
        {
            return false;
        }
 
        if (array_key_exists('FILE_RULES', $arFields))
        {
            if (is_array($arFields['FILE_RULES']))
            {
                $arFields['FILE_RULES'] = serialize($arFields['FILE_RULES']);
            }
            else
            {
                $arFields['FILE_RULES'] = false;
            }
        }
 
        if (array_key_exists('SETTINGS', $arFields))
        {
            if (!$this->CheckSettings($arFields['SETTINGS']))
            {
                return false;
            }
            $arFields['SETTINGS'] = serialize($arFields['SETTINGS']);
        }
 
        $strUpdate = $DB->PrepareUpdate('b_clouds_file_bucket', $arFields);
        if ($strUpdate <> '')
        {
            $strSql = '
                UPDATE b_clouds_file_bucket SET
                ' . $strUpdate . '
                WHERE ID = ' . $this->_ID . '
            ';
            if (!is_object($DB->Query($strSql)))
            {
                return false;
            }
        }
 
        self::$arBuckets = null;
        $this->arBucket = null;
        if (CACHED_b_clouds_file_bucket !== false)
        {
            $CACHE_MANAGER->CleanDir('b_clouds_file_bucket');
        }
 
        return $this->_ID;
    }

    public static function ConvertPOST($arPOST)
    {
        $arRules = /*.(array[int][string]string).*/[];
 
        if (isset($arPOST['MODULE']) && is_array($arPOST['MODULE']))
        {
            foreach ($arPOST['MODULE'] as $i => $MODULE)
            {
                if (!isset($arRules[intval($i)]))
                {
                    $arRules[intval($i)] = ['MODULE' => '', 'EXTENSION' => '', 'SIZE' => ''];
                }
                $arRules[intval($i)]['MODULE'] = $MODULE;
            }
        }
 
        if (isset($arPOST['EXTENSION']) && is_array($arPOST['EXTENSION']))
        {
            foreach ($arPOST['EXTENSION'] as $i => $EXTENSION)
            {
                if (!isset($arRules[intval($i)]))
                {
                    $arRules[intval($i)] = ['MODULE' => '', 'EXTENSION' => '', 'SIZE' => ''];
                }
                $arRules[intval($i)]['EXTENSION'] = $EXTENSION;
            }
        }
 
        if (isset($arPOST['SIZE']) && is_array($arPOST['SIZE']))
        {
            foreach ($arPOST['SIZE'] as $i => $SIZE)
            {
                if (!isset($arRules[intval($i)]))
                {
                    $arRules[intval($i)] = ['MODULE' => '', 'EXTENSION' => '', 'SIZE' => ''];
                }
                $arRules[intval($i)]['SIZE'] = $SIZE;
            }
        }
 
        return $arRules;
    }

    public function setHeader($name, $value)
    {
        $this->service->SetHeader($name, $value);
    }

    public function SetFileCounter($file_size, $file_count)
    {
        global $DB, $CACHE_MANAGER;
        $res = $DB->Query('
            UPDATE b_clouds_file_bucket
            SET FILE_COUNT = ' . intval($file_count) . '
            ,FILE_SIZE = ' . roundDB($file_size) . '
            WHERE ID = ' . $this->GetActualBucketId() . '
        ');
 
        if (CACHED_b_clouds_file_bucket !== false)
        {
            $CACHE_MANAGER->CleanDir('b_clouds_file_bucket');
        }
        return $res;
    }
 
    protected static $applyFileCounterJobAdded = false;

    public function IncFileCounter($file_size = 0.0)
    {
        global $DB;
 
        $res = $DB->Query('
            INSERT INTO b_clouds_size_queue (BUCKET_ID, FILE_COUNT, FILE_SIZE)
            VALUES (' . $this->GetActualBucketId() . ', 1, ' . roundDB($file_size) . ')
        ');
 
        if (defined('BX_CLOUDS_COUNTERS_DEBUG'))
        {
            \CCloudsDebug::getInstance()->endAction();
        }
 
        if (!static::$applyFileCounterJobAdded)
        {
            static::$applyFileCounterJobAdded = true;
            \Bitrix\Main\Application::getInstance()->addBackgroundJob([__CLASS__, 'ApplyFileCounter'], [], \Bitrix\Main\Application::JOB_PRIORITY_NORMAL);
        }
 
        return $res;
    }

    public function DecFileCounter($file_size = 0.0)
    {
        global $DB;
 
        $res = $DB->Query('
            INSERT INTO b_clouds_size_queue (BUCKET_ID, FILE_COUNT, FILE_SIZE)
            VALUES (' . $this->GetActualBucketId() . ', -1, ' . roundDB($file_size) . ')
        ');
 
        if (defined('BX_CLOUDS_COUNTERS_DEBUG'))
        {
            \CCloudsDebug::getInstance()->endAction();
        }
 
        if (!static::$applyFileCounterJobAdded)
        {
            static::$applyFileCounterJobAdded = true;
            \Bitrix\Main\Application::getInstance()->addBackgroundJob([__CLASS__, 'ApplyFileCounter'], [], \Bitrix\Main\Application::JOB_PRIORITY_NORMAL);
        }
 
        return $res;
    }

    public static function ApplyFileCounter()
    {
        global $DB, $CACHE_MANAGER;
 
        $connection = \Bitrix\Main\Application::getConnection();
        if ($connection->lock('CCloudStorageBucket::ApplyFileCounter'))
        {
            $res = $DB->Query('SELECT * FROM b_clouds_size_queue ORDER BY ID');
            $c = 0;
            while ($job = $res->Fetch())
            {
                if ($job['FILE_COUNT'] > 0)
                {
                    $DB->Query('
                        UPDATE b_clouds_file_bucket
                        SET FILE_COUNT = FILE_COUNT + 1
                        ,FILE_SIZE = FILE_SIZE + ' . $job['FILE_SIZE'] . '
                        WHERE ID = ' . $job['BUCKET_ID'] . '
                    ');
                    $c++;
 
                    COption::SetOptionString('main_size', '~cloud', intval(COption::GetOptionString('main_size', '~cloud')) + $job['FILE_SIZE']);
                }
                elseif ($job['FILE_COUNT'] < 0)
                {
                    $DB->Query('
                        UPDATE b_clouds_file_bucket
                        SET FILE_COUNT = case when FILE_COUNT - 1 > 0 then FILE_COUNT - 1 else 0 end
                        ,FILE_SIZE = case when FILE_SIZE - ' . $job['FILE_SIZE'] . ' > 0 then FILE_SIZE - ' . $job['FILE_SIZE'] . ' else 0 end
                        WHERE ID = ' . $job['BUCKET_ID'] . '
                    ');
                    $c++;
 
                    COption::SetOptionString('main_size', '~cloud', intval(COption::GetOptionString('main_size', '~cloud')) - $job['FILE_SIZE']);
                }
 
                $DB->Query('DELETE FROM b_clouds_size_queue WHERE ID = ' . $job['ID']);
            }
 
            if ($c > 0 && CACHED_b_clouds_file_bucket !== false)
            {
                $CACHE_MANAGER->CleanDir('b_clouds_file_bucket');
            }
 
            $connection->unlock('CCloudStorageBucket::ApplyFileCounter');
        }
    }
}