archiver.php

<?php
namespace Bitrix\Translate\IO;
 
use Bitrix\Main;
use Bitrix\Translate;
use Bitrix\Main\Errorable;
 
require_once $_SERVER['DOCUMENT_ROOT']. '/bitrix/modules/main/classes/general/tar_gz.php';
 
class Archiver
    extends Main\IO\File
    implements Translate\IErrorable
{
    // trait implements interface Translate\IErrorable
    use Translate\Error;
 
    private $archive;
 
    private $canUseCompression = false;
 
    private $seekPath;
 
    private $processedFileCount = 0;
 
    public function __construct($path, $siteId = null)
    {
        parent::__construct($path, $siteId);
 
        $this->canUseCompression = self::libAvailable();
 
        $this->archive = new \CArchiver($this->getPhysicalPath(), $this->canUseCompression);
        $this->archive->_strSeparator = '|';
    }
 
    public static function libAvailable()
    {
        return (\extension_loaded('zlib') || \function_exists('gzcompress'));
    }
 
    public function setOptions($options)
    {
        $this->archive->setOptions($options);
    }
 
    public function setSeekPosition($seekPath)
    {
        $this->seekPath = $seekPath;
    }
 
    public function getSeekPosition()
    {
        return $this->seekPath;
    }
 
    public function getProcessedFileCount()
    {
        return $this->processedFileCount;
    }
 
 
    public function pack(Translate\IO\Directory $directory, $seekPath = '')
    {
        $this->setOptions(array(
            'ADD_PATH' => $directory->getName(),
            'REMOVE_PATH' => $directory->getPhysicalPath(),
        ));
 
        if (empty($seekPath) && !empty($this->seekPath))
        {
            $seekPath = $this->seekPath;
        }
 
        $counter = \Closure::bind(
            function()
            {
                if ($this instanceof \CArchiver)
                {
                    return \count($this->lastFile) + ($this->tempres == "continue" ? 1 : 0);
                }
                return -1;
            },
            $this->archive,
            '\CArchiver'
        );
 
        $res = $this->archive->pack([$directory->getPhysicalPath()], $seekPath);
 
        switch ($res)
        {
            case \IBXArchive::StatusContinue:
                $this->setSeekPosition($this->archive->getStartFile());
                $this->processedFileCount = $counter();
                break;
 
            case \IBXArchive::StatusSuccess:
                $this->processedFileCount = $counter();
                break;
 
            case \IBXArchive::StatusError:
                $errors = $this->archive->getErrors();
                if (count($errors) > 0)
                {
                    foreach ($errors as $errorMessage)
                    {
                        $this->addError(new Main\Error($errorMessage[1], $errorMessage[0]));
                    }
                }
                break;
        }
 
        return $res;//($this->hasErrors() !== true);
    }
 
    public function extract(Translate\IO\Directory $target)
    {
        $unpack = \Closure::bind(
            function($path)
            {
                if ($this instanceof \CArchiver)
                {
                    $this->_arErrors = array();
 
                    $listDetail = array();
 
                    if ($result = $this->_openRead())
                    {
                        $result = $this->_extractList($path, $listDetail, 'complete', array(), '');
                        $this->_close();
                    }
                    if ($result)
                    {
                        return \count($listDetail);
                    }
                }
                return -1;
            },
            $this->archive,
            '\CArchiver'
        );
 
        //$res = $this->archive->extractFiles($target->getPhysicalPath());
        $res = $unpack($target->getPhysicalPath());
 
        if ($res < 0)
        {
            $errors = $this->archive->getErrors();
            if (\count($errors) > 0)
            {
                foreach ($errors as $errorMessage)
                {
                    $this->addError(new Main\Error($errorMessage[1], $errorMessage[0]));
                }
            }
        }
        else
        {
            $this->processedFileCount = $res;
        }
 
        return ($this->hasErrors() !== true);
    }
}