misc_pterodactyl-panel/app/Services/DeploymentService.php
2016-12-07 22:46:38 +00:00

145 lines
5.1 KiB
PHP

<?php
/**
* Pterodactyl - Panel
* Copyright (c) 2015 - 2016 Dane Everitt <dane@daneeveritt.com>.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
namespace Pterodactyl\Services;
use DB;
use Pterodactyl\Models;
use Pterodactyl\Exceptions\DisplayException;
class DeploymentService
{
public function __constructor()
{
//
}
/**
* Return a random location model. DO NOT USE.
* @return \Pterodactyl\Models\Node
*
* @TODO Actually make this smarter. If we're selecting a random location
* but then it has no nodes we should probably continue attempting all locations
* until we hit one.
*
* Currently you should just pick a location and go from there.
*/
public static function randomLocation()
{
return Models\Location::inRandomOrder()->first();
}
/**
* Return a model instance of a random node.
* @param int $location
* @param array $not
* @return \Pterodactyl\Models\Node
*
* @throws \Pterodactyl\Exceptions\DisplayException
*/
public static function randomNode($location, array $not = [])
{
$useLocation = Models\Location::where('id', $location)->first();
if (! $useLocation) {
throw new DisplayException('The location passed was not valid and could not be found.');
}
$node = Models\Node::where('location', $useLocation->id)->where('public', 1)->whereNotIn('id', $not)->inRandomOrder()->first();
if (! $node) {
throw new DisplayException("Unable to find a node in location {$useLocation->short} (id: {$useLocation->id}) that is available and has space.");
}
return $node;
}
/**
* Selects a random node ensuring it does not put the node
* over allocation limits.
* @param int $memory
* @param int $disk
* @param int $location
* @return \Pterodactyl\Models\Node;
*
* @throws \Pterodactyl\Exceptions\DisplayException
*/
public static function smartRandomNode($memory, $disk, $location = null)
{
$node = self::randomNode($location);
$notIn = [];
do {
$return = self::checkNodeAllocation($node, $memory, $disk);
if (! $return) {
$notIn = array_merge($notIn, [
$node->id,
]);
$node = self::randomNode($location, $notIn);
}
} while (! $return);
return $node;
}
/**
* Returns a random allocation for a node.
* @param int $node
* @return \Models\Pterodactyl\Allocation;
*/
public static function randomAllocation($node)
{
$allocation = Models\Allocation::where('node', $node)->whereNull('assigned_to')->inRandomOrder()->first();
if (! $allocation) {
throw new DisplayException('No available allocation could be found for the assigned node.');
}
return $allocation;
}
/**
* Checks that a node's allocation limits will not be passed with the given information.
* @param \Pterodactyl\Models\Node $node
* @param int $memory
* @param int $disk
* @return bool Returns true if this information would not put the node over it's limit.
*/
protected static function checkNodeAllocation(Models\Node $node, $memory, $disk)
{
if (is_numeric($node->memory_overallocate) || is_numeric($node->disk_overallocate)) {
$totals = Models\Server::select(DB::raw('SUM(memory) as memory, SUM(disk) as disk'))->where('node', $node->id)->first();
// Check memory limits
if (is_numeric($node->memory_overallocate)) {
$limit = ($node->memory * (1 + ($node->memory_overallocate / 100)));
$memoryLimitReached = (($totals->memory + $memory) > $limit);
}
// Check Disk Limits
if (is_numeric($node->disk_overallocate)) {
$limit = ($node->disk * (1 + ($node->disk_overallocate / 100)));
$diskLimitReached = (($totals->disk + $disk) > $limit);
}
return ! $diskLimitReached && ! $memoryLimitReached;
}
}
}