whmcsProxmoxAddon/app/Services/Cloud/ResourceManager.php

<?php


namespace ModulesGarden\ProxmoxAddon\App\Services\Cloud;


use ModulesGarden\ProxmoxAddon\App\Models\VirtualNetwork;
use ModulesGarden\ProxmoxAddon\App\Models\VmIpAddress;
use ModulesGarden\ProxmoxAddon\App\Models\VmModel;
use ModulesGarden\ProxmoxAddon\App\Services\Utility;
use ModulesGarden\ProxmoxAddon\Core\UI\Traits\WhmcsParams;
use ModulesGarden\ProxmoxAddon\App\Enum\Cloud\ConfigurableOption;

class ResourceManager
{
    use WhmcsParams;
    use ProductService;

    protected $notVmIds = [];

    /**
     * @var Resource[]
     */
    protected $items = [];


    public function notVmIds(array $ids)
    {
        $this->notVmIds = $ids;
        return $this;
    }

    /**
     * @return Resource
     */
    public function sockets()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit('int');
        if ($this->isWhmcsConfigOption(ConfigurableOption::SOCKETS))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::SOCKETS));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getSockets());
        }
        $resurce->setMin($this->configuration()->serverSockets->min);
        $resurce->setMax($this->configuration()->serverSockets->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function cores()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit('int');
        if ($this->isWhmcsConfigOption(ConfigurableOption::CORES))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::CORES));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getCores());
        }
        $resurce->setMin($this->configuration()->serverCores->min);
        $resurce->setMax($this->configuration()->serverCores->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function vcpus()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit('int');
        if ($this->isWhmcsConfigOption(ConfigurableOption::VCPUS))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::VCPUS));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getVcpus());
        }
        $resurce->setMin($this->configuration()->serverVcpus->min);
        $resurce->setMax($this->configuration()->serverVcpus->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function cpulimit()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit('int');
        if ($this->isWhmcsConfigOption(ConfigurableOption::CPU_LIMIT))
        {
            $resurce->setTotal(round($this->getWhmcsConfigOption(ConfigurableOption::CPU_LIMIT),2));
        }
        else
        {
            $resurce->setTotal(round($this->configuration()->getCpulimit(),2));
        }
        $resurce->setMin($this->configuration()->serverCpulimit->min);
        $resurce->setMax($this->configuration()->serverCpulimit->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function virtualNetworks()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit('int');
        if ($this->isWhmcsConfigOption(ConfigurableOption::VIRTUAL_NETWORKS))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::VIRTUAL_NETWORKS));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getVirtualNetworks());
        }
        $resurce->setMin(0);
        $resurce->setMax($resurce->getTotal());
        $query = VirtualNetwork::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        $resurce->setUsed($query->count());


        return $this->items[__FUNCTION__] = $resurce;
    }


    /**
     * @return Resource|Resource
     * @todo  singel query
     */
    public function disk()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("gb");
        if ($this->isWhmcsConfigOption(ConfigurableOption::STORAGE))
        {
            $resurce->setUnit($this->configuration()->getStorageUnit());
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::STORAGE));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getStorageSize());
        }
        $resurce->setMin((int)$this->configuration()->serverDiskSize->min);
        $resurce->setMax((int)$this->configuration()->serverDiskSize->max);
        $query  = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        $query2 = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
            $query2->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum('disk') + $query2->sum('disks'));
        return $this->items[__FUNCTION__] = $resurce;
    }

    /**
     * @return Resource|Resource
     */
    public function memory()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("mb");
        if ($this->isWhmcsConfigOption(ConfigurableOption::MEMORY))
        {
            $resurce->setUnit($this->configuration()->getMemoryUnit());
            $total = (int)$this->getWhmcsConfigOption(ConfigurableOption::MEMORY);
            Utility::unitFormat($total,$this->configuration()->getMemoryUnit(),"mb");
            $resurce->setTotal($total);
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getMemory());
        }
        $resurce->setMin($this->configuration()->serverMemory->min);
        $resurce->setMax($this->configuration()->serverMemory->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    /**
     * @return Resource|Resource
     */
    public function swap()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("mb");
        if ($this->isWhmcsConfigOption(ConfigurableOption::SWAP))
        {
            $resurce->setUnit($this->configuration()->getSwapUnit());
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::SWAP));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getSwap());
        }
        $resurce->setMin($this->configuration()->serverSwap->min);
        $resurce->setMax($this->configuration()->serverSwap->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function cpuunits()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("int");
        if ($this->isWhmcsConfigOption(ConfigurableOption::CPU_UNITS))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::CPU_UNITS));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getCpuunits());
        }
        $resurce->setMin($this->configuration()->serverCpuunit->min);
        $resurce->setMax($this->configuration()->serverCpuunit->max);
        $query = VmModel::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->sum(__FUNCTION__));
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function ipv4()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("int");
        if ($this->isWhmcsConfigOption(ConfigurableOption::IPV4))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::IPV4));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getIpv4());
        }
        $resurce->setMin($this->configuration()->serverIpv4->min);
        $resurce->setMax($this->configuration()->serverIpv4->max);
        $query = VmIpAddress::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        $query->ofIp4();
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->count());
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function ipv6()
    {
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("int");
        if ($this->isWhmcsConfigOption(ConfigurableOption::IPV6))
        {
            $resurce->setTotal((int)$this->getWhmcsConfigOption(ConfigurableOption::IPV6));
        }
        else
        {
            $resurce->setTotal((int)$this->configuration()->getIpv6());
        }
        $resurce->setMin($this->configuration()->serverIpv6->min);
        $resurce->setMax($this->configuration()->serverIpv6->max);
        $query = VmIpAddress::ofHostingId($this->getWhmcsParamByKey('serviceid'));
        $query->ofIp6();
        if ($this->notVmIds)
        {
            $query->notIdIn($this->notVmIds);
        }
        $resurce->setUsed($query->count());
        return $this->items[__FUNCTION__] = $resurce;
    }

    public function cpuPriority(){
        //cache
        if ($this->items[__FUNCTION__])
        {
            return $this->items[__FUNCTION__];
        }
        $resurce = new Resource(__FUNCTION__);
        $resurce->setUnit("int");
        $resurce->setMin(1);
        $resurce->setMax(5);
        $resurce->setTotal(5);

        for($i=1; $i<=5; $i++){
            $cpuunits = $this->configuration()->get('cpuunitsPriority'.$i);
            $cpulimit = round( $this->configuration()->get('cpulimitPriority'.$i),2);
            if($this->cpulimit()->freeTotal() < $cpulimit){
                $resurce->setUsed($i);
            }
            if($this->cpuunits()->freeTotal() < $cpuunits){
                $resurce->setUsed($i);
            }
        }
        return $this->items[__FUNCTION__] = $resurce;
    }

}