ResourcePackManager.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */
 
declare(strict_types=1);
 
namespace pocketmine\resourcepacks;
 
use pocketmine\utils\Config;
use pocketmine\utils\Filesystem;
use pocketmine\utils\Utils;
use Ramsey\Uuid\UuidInterface;
use Symfony\Component\Filesystem\Path;
use function array_map;
use function copy;
use function count;
use function file_exists;
use function gettype;
use function is_array;
use function is_dir;
use function is_float;
use function is_int;
use function is_string;
use function mkdir;
use function rtrim;
use function strlen;
use function strtolower;
use const DIRECTORY_SEPARATOR;
 
class ResourcePackManager{
    private string $path;
    private bool $serverForceResources = false;
 
    private array $resourcePacks = [];
 
    private array $uuidList = [];
 
    private array $encryptionKeys = [];
 
    public function __construct(string $path, \Logger $logger){
        $this->path = $path;
 
        if(!file_exists($this->path)){
            $logger->debug("Resource packs path $path does not exist, creating directory");
            mkdir($this->path);
        }elseif(!is_dir($this->path)){
            throw new \InvalidArgumentException("Resource packs path $path exists and is not a directory");
        }
 
        $resourcePacksYml = Path::join($this->path, "resource_packs.yml");
        if(!file_exists($resourcePacksYml)){
            copy(Path::join(\pocketmine\RESOURCE_PATH, "resource_packs.yml"), $resourcePacksYml);
        }
 
        $resourcePacksConfig = new Config($resourcePacksYml, Config::YAML, []);
 
        $this->serverForceResources = (bool) $resourcePacksConfig->get("force_resources", false);
 
        $logger->info("Loading resource packs...");
 
        $resourceStack = $resourcePacksConfig->get("resource_stack", []);
        if(!is_array($resourceStack)){
            throw new \InvalidArgumentException("\"resource_stack\" key should contain a list of pack names");
        }
 
        foreach(Utils::promoteKeys($resourceStack) as $pos => $pack){
            if(!is_string($pack) && !is_int($pack) && !is_float($pack)){
                $logger->critical("Found invalid entry in resource pack list at offset $pos of type " . gettype($pack));
                continue;
            }
            $pack = (string) $pack;
            try{
                $newPack = $this->loadPackFromPath(Path::join($this->path, $pack));
 
                $printableId = $newPack->getPackId()->toString();
                $this->uuidList[$printableId] = $newPack;
                $this->resourcePacks[] = $newPack;
 
                $keyPath = Path::join($this->path, $pack . ".key");
                if(file_exists($keyPath)){
                    try{
                        $key = Filesystem::fileGetContents($keyPath);
                    }catch(\RuntimeException $e){
                        throw new ResourcePackException("Could not read encryption key file: " . $e->getMessage(), 0, $e);
                    }
                    $key = rtrim($key, "\r\n");
                    if(strlen($key) !== 32){
                        throw new ResourcePackException("Invalid encryption key length, must be exactly 32 bytes");
                    }
                    $this->encryptionKeys[$printableId] = $key;
                }
            }catch(ResourcePackException $e){
                $logger->critical("Could not load resource pack \"$pack\": " . $e->getMessage());
            }
        }
 
        $logger->debug("Successfully loaded " . count($this->resourcePacks) . " resource packs");
    }
 
    private function loadPackFromPath(string $packPath) : ResourcePack{
        if(!file_exists($packPath)){
            throw new ResourcePackException("File or directory not found");
        }
        if(is_dir($packPath)){
            throw new ResourcePackException("Directory resource packs are unsupported");
        }
 
        //Detect the type of resource pack.
        $info = new \SplFileInfo($packPath);
        switch($info->getExtension()){
            case "zip":
            case "mcpack":
                return new ZippedResourcePack($packPath);
        }
 
        throw new ResourcePackException("Format not recognized");
    }
 
    public function getPath() : string{
        return $this->path . DIRECTORY_SEPARATOR;
    }
 
    public function resourcePacksRequired() : bool{
        return $this->serverForceResources;
    }
 
    public function setResourcePacksRequired(bool $value) : void{
        $this->serverForceResources = $value;
    }
 
    public function getResourceStack() : array{
        return $this->resourcePacks;
    }
 
    public function setResourceStack(array $resourceStack) : void{
        $uuidList = [];
        $resourcePacks = [];
        foreach($resourceStack as $pack){
            $printableId = $pack->getPackId()->toString();
            if(isset($uuidList[$printableId])){
                throw new \InvalidArgumentException("Cannot load two resource pack with the same UUID ($printableId)");
            }
            $uuidList[$printableId] = $pack;
            $resourcePacks[] = $pack;
        }
        $this->resourcePacks = $resourcePacks;
        $this->uuidList = $uuidList;
    }
 
    public function getPackById(UuidInterface|string $id) : ?ResourcePack{
        return $this->uuidList[$id instanceof UuidInterface ? $id->toString() : strtolower($id)] ?? null;
    }
 
    public function getPackIdList() : array{
        return array_map(fn(ResourcePack $p) => $p->getPackId(), $this->uuidList);
    }
 
    public function getPackEncryptionKey(UuidInterface $id) : ?string{
        return $this->encryptionKeys[$id->toString()] ?? null;
    }
 
    public function setPackEncryptionKey(UuidInterface $id, ?string $key) : void{
        $printableId = $id->toString();
        if($key === null){
            //allow deprovisioning keys for resource packs that have been removed
            unset($this->encryptionKeys[$printableId]);
        }elseif(isset($this->uuidList[$printableId])){
            if(strlen($key) !== 32){
                throw new \InvalidArgumentException("Encryption key must be exactly 32 bytes long");
            }
            $this->encryptionKeys[$printableId] = $key;
        }else{
            throw new \InvalidArgumentException("Unknown pack ID $printableId");
        }
    }
}