misc_pterodactyl-panel/app/Repositories/ServerRepository.php

<?php
/**
 * Pterodactyl - Panel
 * Copyright (c) 2015 - 2017 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\Repositories;

use DB;
use Crypt;
use Validator;
use Pterodactyl\Models\Node;
use Pterodactyl\Models\Pack;
use Pterodactyl\Models\User;
use Pterodactyl\Models\Server;
use Pterodactyl\Models\Service;
use Pterodactyl\Models\Allocation;
use Pterodactyl\Models\ServiceOption;
use Pterodactyl\Services\UuidService;
use Pterodactyl\Models\ServerVariable;
use Pterodactyl\Models\ServiceVariable;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\TransferException;
use Pterodactyl\Services\DeploymentService;
use Pterodactyl\Exceptions\DisplayException;
use Pterodactyl\Exceptions\DisplayValidationException;

class ServerRepository
{
    /**
     * An array of daemon permission to assign to this server.
     *
     * @var array
     */
    protected $daemonPermissions = [
        's:*',
    ];

    /**
     * Generates a SFTP username for a server given a server name.
     * format: mumble_67c7a4b0.
     *
     * @param  string       $name
     * @param  null|string  $identifier
     * @return string
     */
    protected function generateSFTPUsername($name, $identifier = null)
    {
        if (is_null($identifier) || ! ctype_alnum($identifier)) {
            $unique = str_random(8);
        } else {
            if (strlen($identifier) < 8) {
                $unique = $identifier . str_random((8 - strlen($identifier)));
            } else {
                $unique = substr($identifier, 0, 8);
            }
        }

        // Filter the Server Name
        $name = trim(preg_replace('/[^\w]+/', '', $name), '_');
        $name = (strlen($name) < 1) ? str_random(6) : $name;

        return strtolower(substr($name, 0, 6) . '_' . $unique);
    }

    /**
     * Adds a new server to the system.
     *
     * @param   array  $data
     * @return \Pterodactyl\Models\Server
     *
     * @throws \Pterodactyl\Exceptions\DisplayException
     * @throws \Pterodactyl\Exceptions\AutoDeploymentException
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function create(array $data)
    {
        $validator = Validator::make($data, [
            'user_id' => 'required|exists:users,id',
            'name' => 'required|regex:/^([\w .-]{1,200})$/',
            'description' => 'sometimes|nullable|string',
            'memory' => 'required|numeric|min:0',
            'swap' => 'required|numeric|min:-1',
            'io' => 'required|numeric|min:10|max:1000',
            'cpu' => 'required|numeric|min:0',
            'disk' => 'required|numeric|min:0',
            'service_id' => 'required|numeric|min:1|exists:services,id',
            'option_id' => 'required|numeric|min:1|exists:service_options,id',
            'location_id' => 'required|numeric|min:1|exists:locations,id',
            'pack_id' => 'sometimes|nullable|numeric|min:0',
            'custom_container' => 'string',
            'startup' => 'string',
            'auto_deploy' => 'sometimes|required|accepted',
            'custom_id' => 'sometimes|required|numeric|unique:servers,id',
            'skip_scripts' => 'sometimes|required|boolean',
        ]);

        $validator->sometimes('node_id', 'required|numeric|min:1|exists:nodes,id', function ($input) {
            return ! ($input->auto_deploy);
        });

        $validator->sometimes('allocation_id', 'required|numeric|exists:allocations,id', function ($input) {
            return ! ($input->auto_deploy);
        });

        $validator->sometimes('allocation_additional.*', 'sometimes|required|numeric|exists:allocations,id', function ($input) {
            return ! ($input->auto_deploy);
        });

        // Run validator, throw catchable and displayable exception if it fails.
        // Exception includes a JSON result of failed validation rules.
        if ($validator->fails()) {
            throw new DisplayValidationException(json_encode($validator->errors()));
        }

        $user = User::findOrFail($data['user_id']);

        $deployment = false;
        if (isset($data['auto_deploy'])) {
            $deployment = new DeploymentService;

            if (isset($data['location_id'])) {
                $deployment->setLocation($data['location_id']);
            }

            $deployment->setMemory($data['memory'])->setDisk($data['disk'])->select();
        }

        $node = (! $deployment) ? Node::findOrFail($data['node_id']) : $deployment->node();

        // Verify IP & Port are a.) free and b.) assigned to the node.
        // We know the node exists because of 'exists:nodes,id' in the validation
        if (! $deployment) {
            $allocation = Allocation::where('id', $data['allocation_id'])->where('node_id', $data['node_id'])->whereNull('server_id')->first();
        } else {
            $allocation = $deployment->allocation();
        }

        // Something failed in the query, either that combo doesn't exist, or it is in use.
        if (! $allocation) {
            throw new DisplayException('The selected Allocation ID is either already in use, or unavaliable for this node.');
        }

        // Validate those Service Option Variables
        // We know the service and option exists because of the validation.
        // We need to verify that the option exists for the service, and then check for
        // any required variable fields. (fields are labeled env_<env_variable>)
        $option = ServiceOption::where('id', $data['option_id'])->where('service_id', $data['service_id'])->first();
        if (! $option) {
            throw new DisplayException('The requested service option does not exist for the specified service.');
        }

        // Validate the Pack
        if (! isset($data['pack_id']) || (int) $data['pack_id'] < 1) {
            $data['pack_id'] = null;
        } else {
            $pack = Pack::where('id', $data['pack_id'])->where('option_id', $data['option_id'])->first();
            if (! $pack) {
                throw new DisplayException('The requested service pack does not seem to exist for this combination.');
            }
        }

        // Load up the Service Information
        $service = Service::find($option->service_id);

        // Check those Variables
        $variables = ServiceVariable::where('option_id', $data['option_id'])->get();
        $variableList = [];
        if ($variables) {
            foreach ($variables as $variable) {

                // Is the variable required?
                if (! isset($data['env_' . $variable->env_variable])) {
                    if ($variable->required) {
                        throw new DisplayException('A required service option variable field (env_' . $variable->env_variable . ') was missing from the request.');
                    }
                    $variableList[] = [
                        'id' => $variable->id,
                        'env' => $variable->env_variable,
                        'val' => $variable->default_value,
                    ];
                    continue;
                }

                // Check aganist Regex Pattern
                if (! is_null($variable->regex) && ! preg_match($variable->regex, $data['env_' . $variable->env_variable])) {
                    throw new DisplayException('Failed to validate service option variable field (env_' . $variable->env_variable . ') aganist regex (' . $variable->regex . ').');
                }

                $variableList[] = [
                    'id' => $variable->id,
                    'env' => $variable->env_variable,
                    'val' => $data['env_' . $variable->env_variable],
                ];
                continue;
            }
        }

        // Check Overallocation
        if (! $deployment) {
            if (is_numeric($node->memory_overallocate) || is_numeric($node->disk_overallocate)) {
                $totals = Server::select(DB::raw('SUM(memory) as memory, SUM(disk) as disk'))->where('node_id', $node->id)->first();

                // Check memory limits
                if (is_numeric($node->memory_overallocate)) {
                    $newMemory = $totals->memory + $data['memory'];
                    $memoryLimit = ($node->memory * (1 + ($node->memory_overallocate / 100)));
                    if ($newMemory > $memoryLimit) {
                        throw new DisplayException('The amount of memory allocated to this server would put the node over its allocation limits. This node is allowed ' . ($node->memory_overallocate + 100) . '% of its assigned ' . $node->memory . 'Mb of memory (' . $memoryLimit . 'Mb) of which ' . (($totals->memory / $node->memory) * 100) . '% (' . $totals->memory . 'Mb) is in use already. By allocating this server the node would be at ' . (($newMemory / $node->memory) * 100) . '% (' . $newMemory . 'Mb) usage.');
                    }
                }

                // Check Disk Limits
                if (is_numeric($node->disk_overallocate)) {
                    $newDisk = $totals->disk + $data['disk'];
                    $diskLimit = ($node->disk * (1 + ($node->disk_overallocate / 100)));
                    if ($newDisk > $diskLimit) {
                        throw new DisplayException('The amount of disk allocated to this server would put the node over its allocation limits. This node is allowed ' . ($node->disk_overallocate + 100) . '% of its assigned ' . $node->disk . 'Mb of disk (' . $diskLimit . 'Mb) of which ' . (($totals->disk / $node->disk) * 100) . '% (' . $totals->disk . 'Mb) is in use already. By allocating this server the node would be at ' . (($newDisk / $node->disk) * 100) . '% (' . $newDisk . 'Mb) usage.');
                    }
                }
            }
        }

        DB::beginTransaction();

        try {
            $uuid = new UuidService;

            // Add Server to the Database
            $server = new Server;
            $genUuid = $uuid->generate('servers', 'uuid');
            $genShortUuid = $uuid->generateShort('servers', 'uuidShort', $genUuid);

            if (isset($data['custom_id'])) {
                $server->id = $data['custom_id'];
            }

            $server->fill([
                'uuid' => $genUuid,
                'uuidShort' => $genShortUuid,
                'node_id' => $node->id,
                'name' => $data['name'],
                'description' => $data['description'],
                'skip_scripts' => isset($data['skip_scripts']),
                'suspended' => false,
                'owner_id' => $user->id,
                'memory' => $data['memory'],
                'swap' => $data['swap'],
                'disk' => $data['disk'],
                'io' => $data['io'],
                'cpu' => $data['cpu'],
                'oom_disabled' => isset($data['oom_disabled']),
                'allocation_id' => $allocation->id,
                'service_id' => $data['service_id'],
                'option_id' => $data['option_id'],
                'pack_id' => $data['pack_id'],
                'startup' => $data['startup'],
                'daemonSecret' => $uuid->generate('servers', 'daemonSecret'),
                'image' => (isset($data['custom_container']) && ! empty($data['custom_container'])) ? $data['custom_container'] : $option->docker_image,
                'username' => $this->generateSFTPUsername($data['name'], $genShortUuid),
                'sftp_password' => Crypt::encrypt('not set'),
            ]);
            $server->save();

            // Mark Allocation in Use
            $allocation->server_id = $server->id;
            $allocation->save();

            // Add Additional Allocations
            if (isset($data['allocation_additional']) && is_array($data['allocation_additional'])) {
                foreach ($data['allocation_additional'] as $allocation) {
                    $model = Allocation::where('id', $allocation)->where('node_id', $data['node_id'])->whereNull('server_id')->first();
                    if (! $model) {
                        continue;
                    }

                    $model->server_id = $server->id;
                    $model->save();
                }
            }

            foreach ($variableList as $item) {
                ServerVariable::create([
                    'server_id' => $server->id,
                    'variable_id' => $item['id'],
                    'variable_value' => $item['val'],
                ]);
            }

            $environment = $this->parseVariables($server);
            $server->load('allocation', 'allocations');

            $node->guzzleClient(['X-Access-Token' => $node->daemonSecret])->request('POST', '/servers', [
                'json' => [
                    'uuid' => (string) $server->uuid,
                    'user' => $server->username,
                    'build' => [
                        'default' => [
                            'ip' => $server->allocation->ip,
                            'port' => $server->allocation->port,
                        ],
                        'ports' => $server->allocations->groupBy('ip')->map(function ($item) {
                            return $item->pluck('port');
                        })->toArray(),
                        'env' => $environment->pluck('value', 'variable')->toArray(),
                        'memory' => (int) $server->memory,
                        'swap' => (int) $server->swap,
                        'io' => (int) $server->io,
                        'cpu' => (int) $server->cpu,
                        'disk' => (int) $server->disk,
                        'image' => $server->image,
                    ],
                    'service' => [
                        'type' => $service->folder,
                        'option' => $option->tag,
                        'pack' => (isset($pack)) ? $pack->uuid : null,
                        'skip_scripts' => $server->skip_scripts,
                    ],
                    'keys' => [
                        (string) $server->daemonSecret => $this->daemonPermissions,
                    ],
                    'rebuild' => false,
                    'start_on_completion' => isset($data['start_on_completion']),
                ],
            ]);

            DB::commit();

            return $server;
        } catch (\Exception $ex) {
            DB::rollBack();
            throw $ex;
        }
    }

    /**
     * Update the details for a server.
     *
     * @param  int    $id
     * @param  array  $data
     * @return \Pterodactyl\Models\Server
     *
     * @throws \Pterodactyl\Exceptions\DisplayException
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function updateDetails($id, array $data)
    {
        $uuid = new UuidService;
        $resetDaemonKey = false;

        // Validate Fields
        $validator = Validator::make($data, [
            'owner_id' => 'sometimes|required|integer|exists:users,id',
            'name' => 'sometimes|required|regex:([\w .-]{1,200})',
            'description' => 'sometimes|nullable|string',
            'reset_token' => 'sometimes|required|accepted',
        ]);

        // Run validator, throw catchable and displayable exception if it fails.
        // Exception includes a JSON result of failed validation rules.
        if ($validator->fails()) {
            throw new DisplayValidationException(json_encode($validator->errors()));
        }

        DB::beginTransaction();

        try {
            $server = Server::with('user')->findOrFail($id);

            // Update daemon secret if it was passed.
            if (isset($data['reset_token']) || (isset($data['owner_id']) && (int) $data['owner_id'] !== $server->user->id)) {
                $oldDaemonKey = $server->daemonSecret;
                $server->daemonSecret = $uuid->generate('servers', 'daemonSecret');
                $resetDaemonKey = true;
            }

            // Save our changes
            $server->fill($data)->save();

            // Do we need to update? If not, return successful.
            if (! $resetDaemonKey) {
                return DB::commit();
            }

            $res = $server->node->guzzleClient([
                'X-Access-Server' => $server->uuid,
                'X-Access-Token' => $server->node->daemonSecret,
            ])->request('PATCH', '/server', [
                'exceptions' => false,
                'json' => [
                    'keys' => [
                        (string) $oldDaemonKey => [],
                        (string) $server->daemonSecret => $this->daemonPermissions,
                    ],
                ],
            ]);

            if ($res->getStatusCode() === 204) {
                DB::commit();

                return $server;
            } else {
                throw new DisplayException('Daemon returned a a non HTTP/204 error code. HTTP/' + $res->getStatusCode());
            }
        } catch (\Exception $ex) {
            DB::rollBack();
            throw $ex;
        }
    }

    /**
     * Update the container for a server.
     *
     * @param  int    $id
     * @param  array  $data
     * @return \Pterodactyl\Models\Server
     *
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function updateContainer($id, array $data)
    {
        $validator = Validator::make($data, [
            'docker_image' => 'required|string',
        ]);

        // Run validator, throw catchable and displayable exception if it fails.
        // Exception includes a JSON result of failed validation rules.
        if ($validator->fails()) {
            throw new DisplayValidationException(json_encode($validator->errors()));
        }

        DB::beginTransaction();
        try {
            $server = Server::findOrFail($id);

            $server->image = $data['docker_image'];
            $server->save();

            $server->node->guzzleClient([
                'X-Access-Server' => $server->uuid,
                'X-Access-Token' => $server->node->daemonSecret,
            ])->request('PATCH', '/server', [
                'json' => [
                    'build' => [
                        'image' => $server->image,
                    ],
                ],
            ]);

            DB::commit();

            return $server;
        } catch (\Exception $ex) {
            DB::rollBack();
            throw $ex;
        }
    }

    /**
     * Update the build details for a server.
     *
     * @param  int    $id
     * @param  array  $data
     * @return \Pterodactyl\Models\Server
     *
     * @throws \Pterodactyl\Exceptions\DisplayException
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function changeBuild($id, array $data)
    {
        $validator = Validator::make($data, [
            'allocation_id' => 'sometimes|required|exists:allocations,id',
            'add_allocations' => 'sometimes|required|array',
            'remove_allocations' => 'sometimes|required|array',
            'memory' => 'sometimes|required|integer|min:0',
            'swap' => 'sometimes|required|integer|min:-1',
            'io' => 'sometimes|required|integer|min:10|max:1000',
            'cpu' => 'sometimes|required|integer|min:0',
            'disk' => 'sometimes|required|integer|min:0',
        ]);

        // Run validator, throw catchable and displayable exception if it fails.
        // Exception includes a JSON result of failed validation rules.
        if ($validator->fails()) {
            throw new DisplayValidationException(json_encode($validator->errors()));
        }

        DB::beginTransaction();

        try {
            $server = Server::with('allocation', 'allocations')->findOrFail($id);
            $newBuild = [];
            $newAllocations = [];

            if (isset($data['allocation_id'])) {
                if ((int) $data['allocation_id'] !== $server->allocation_id) {
                    $selection = $server->allocations->where('id', $data['allocation_id'])->first();
                    if (! $selection) {
                        throw new DisplayException('The requested default connection is not allocated to this server.');
                    }

                    $server->allocation_id = $selection->id;
                    $newBuild['default'] = ['ip' => $selection->ip, 'port' => $selection->port];

                    $server->load('allocation');
                }
            }

            $newPorts = false;
            $firstNewAllocation = null;
            // Add Assignments
            if (isset($data['add_allocations'])) {
                foreach ($data['add_allocations'] as $allocation) {
                    $model = Allocation::where('id', $allocation)->whereNull('server_id')->first();
                    if (! $model) {
                        continue;
                    }

                    $newPorts = true;
                    $firstNewAllocation = $firstNewAllocation ?? $model;
                    $model->update([
                        'server_id' => $server->id,
                    ]);
                }

                $server->load('allocations');
            }

            // Remove Assignments
            if (isset($data['remove_allocations'])) {
                foreach ($data['remove_allocations'] as $allocation) {
                    // Can't remove the assigned IP/Port combo
                    if ((int) $allocation === $server->allocation_id) {
                        // No New Allocation
                        if (is_null($firstNewAllocation)) {
                            continue;
                        }

                        // New Allocation, set as the default.
                        $server->allocation_id = $firstNewAllocation->id;
                        $newBuild['default'] = ['ip' => $firstNewAllocation->ip, 'port' => $firstNewAllocation->port];
                    }

                    $newPorts = true;
                    Allocation::where('id', $allocation)->where('server_id', $server->id)->update([
                        'server_id' => null,
                    ]);
                }

                $server->load('allocations');
            }

            if ($newPorts) {
                $newBuild['ports|overwrite'] = $server->allocations->groupBy('ip')->map(function ($item) {
                    return $item->pluck('port');
                })->toArray();

                $newBuild['env|overwrite'] = $this->parseVariables($server)->pluck('value', 'variable')->toArray();
            }

            // @TODO: verify that server can be set to this much memory without
            // going over node limits.
            if (isset($data['memory']) && $server->memory !== (int) $data['memory']) {
                $server->memory = $data['memory'];
                $newBuild['memory'] = (int) $server->memory;
            }

            if (isset($data['swap']) && $server->swap !== (int) $data['swap']) {
                $server->swap = $data['swap'];
                $newBuild['swap'] = (int) $server->swap;
            }

            // @TODO: verify that server can be set to this much disk without
            // going over node limits.
            if (isset($data['disk']) && $server->disk !== (int) $data['disk']) {
                $server->disk = $data['disk'];
                $newBuild['disk'] = (int) $server->disk;
            }

            if (isset($data['cpu']) && $server->cpu !== (int) $data['cpu']) {
                $server->cpu = $data['cpu'];
                $newBuild['cpu'] = (int) $server->cpu;
            }

            if (isset($data['io']) && $server->io !== (int) $data['io']) {
                $server->io = $data['io'];
                $newBuild['io'] = (int) $server->io;
            }

            // Try save() here so if it fails we haven't contacted the daemon
            // This won't be committed unless the HTTP request succeedes anyways
            $server->save();

            if (! empty($newBuild)) {
                $server->node->guzzleClient([
                    'X-Access-Server' => $server->uuid,
                    'X-Access-Token' => $server->node->daemonSecret,
                ])->request('PATCH', '/server', [
                    'json' => [
                        'build' => $newBuild,
                    ],
                ]);
            }

            DB::commit();

            return $server;
        } catch (\Exception $ex) {
            DB::rollBack();
            throw $ex;
        }
    }

    /**
     * Process the variables for a server, and save to the database.
     *
     * @param  \Pterodactyl\Models\Server  $server
     * @param  array                       $data
     * @param  bool                        $admin
     * @return \Illuminate\Support\Collection
     *
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    protected function processVariables(Server $server, $data, $admin = false)
    {
        $server->load('option.variables');

        if ($admin) {
            $server->startup = $data['startup'];
            $server->save();
        }

        if ($server->option->variables) {
            foreach ($server->option->variables as &$variable) {
                $set = isset($data['env_' . $variable->id]);

                // If user is not an admin and are trying to edit a non-editable field
                // or an invisible field just silently skip the variable.
                if (! $admin && (! $variable->user_editable || ! $variable->user_viewable)) {
                    continue;
                }

                // Perform Field Validation
                $validator = Validator::make([
                    'variable_value' => ($set) ? $data['env_' . $variable->id] : null,
                ], [
                    'variable_value' => $variable->rules,
                ]);

                if ($validator->fails()) {
                    throw new DisplayValidationException(json_encode(
                        collect([
                            'notice' => ['There was a validation error with the `' . $variable->name . '` variable.'],
                        ])->merge($validator->errors()->toArray())
                    ));
                }

                $svar = ServerVariable::firstOrNew([
                    'server_id' => $server->id,
                    'variable_id' => $variable->id,
                ]);

                // Set the value; if one was not passed set it to the default value
                if ($set) {
                    $svar->variable_value = $data['env_' . $variable->id];

                // Not passed, check if this record exists if so keep value, otherwise set default
                } else {
                    $svar->variable_value = ($svar->exists) ? $svar->variable_value : $variable->default_value;
                }

                $svar->save();
            }
        }

        return $this->parseVariables($server);
    }

    /**
     * Parse the variables and return in a standardized format.
     *
     * @param  \Pterodactyl\Models\Server  $server
     * @return \Illuminate\Support\Collection
     */
    protected function parseVariables(Server $server)
    {
        // Reload Variables
        $server->load('variables');

        $parsed = $server->option->variables->map(function ($item, $key) use ($server) {
            $display = $server->variables->where('variable_id', $item->id)->pluck('variable_value')->first();

            return [
                'variable' => $item->env_variable,
                'value' => (! is_null($display)) ? $display : $item->default_value,
            ];
        });

        $merge = [[
            'variable' => 'STARTUP',
            'value' => $server->startup,
        ], [
            'variable' => 'P_VARIABLE__LOCATION',
            'value' => $server->location->short,
        ]];

        $allocations = $server->allocations->where('id', '!=', $server->allocation_id);
        $i = 0;

        foreach ($allocations as $allocation) {
            $merge[] = [
                'variable' => 'ALLOC_' . $i . '__PORT',
                'value' => $allocation->port,
            ];

            $i++;
        }

        if ($parsed->count() === 0) {
            return collect($merge);
        }

        return $parsed->merge($merge);
    }

    /**
     * Update the startup details for a server.
     *
     * @param  int    $id
     * @param  array  $data
     * @param  bool   $admin
     * @return bool
     *
     * @throws \GuzzleHttp\Exception\RequestException
     * @throws \Pterodactyl\Exceptions\DisplayException
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function updateStartup($id, array $data, $admin = false)
    {
        $server = Server::with('variables', 'option.variables')->findOrFail($id);
        $hasServiceChanges = false;

        if ($admin) {
            // User is an admin, lots of things to do here.
            $validator = Validator::make($data, [
                'startup' => 'required|string',
                'skip_scripts' => 'sometimes|required|boolean',
                'service_id' => 'required|numeric|min:1|exists:services,id',
                'option_id' => 'required|numeric|min:1|exists:service_options,id',
                'pack_id' => 'sometimes|nullable|numeric|min:0',
            ]);

            if ((int) $data['pack_id'] < 1) {
                $data['pack_id'] = null;
            }

            if ($validator->fails()) {
                throw new DisplayValidationException(json_encode($validator->errors()));
            }

            if (
                $server->service_id != $data['service_id'] ||
                $server->option_id != $data['option_id'] ||
                $server->pack_id != $data['pack_id']
            ) {
                $hasServiceChanges = true;
            }
        }

        // If user isn't an administrator, this function is being access from the front-end
        // Just try to update specific variables.
        if (! $admin || ! $hasServiceChanges) {
            return DB::transaction(function () use ($admin, $data, $server) {
                $environment = $this->processVariables($server, $data, $admin);

                $server->node->guzzleClient([
                    'X-Access-Server' => $server->uuid,
                    'X-Access-Token' => $server->node->daemonSecret,
                ])->request('PATCH', '/server', [
                    'json' => [
                        'build' => [
                            'env|overwrite' => $environment->pluck('value', 'variable')->toArray(),
                        ],
                    ],
                ]);

                return false;
            });
        }

        // Validate those Service Option Variables
        // We know the service and option exists because of the validation.
        // We need to verify that the option exists for the service, and then check for
        // any required variable fields. (fields are labeled env_<env_variable>)
        $option = ServiceOption::where('id', $data['option_id'])->where('service_id', $data['service_id'])->first();
        if (! $option) {
            throw new DisplayException('The requested service option does not exist for the specified service.');
        }

        // Validate the Pack
        if (! isset($data['pack_id']) || (int) $data['pack_id'] < 1) {
            $data['pack_id'] = null;
        } else {
            $pack = Pack::where('id', $data['pack_id'])->where('option_id', $data['option_id'])->first();
            if (! $pack) {
                throw new DisplayException('The requested service pack does not seem to exist for this combination.');
            }
        }

        return DB::transaction(function () use ($admin, $data, $server) {
            $server->installed = 0;
            $server->service_id = $data['service_id'];
            $server->option_id = $data['option_id'];
            $server->pack_id = $data['pack_id'];
            $server->skip_scripts = isset($data['skip_scripts']);
            $server->save();

            $server->variables->each->delete();

            $server->load('service', 'pack');

            // Send New Environment
            $environment = $this->processVariables($server, $data, $admin);

            $server->node->guzzleClient([
                'X-Access-Server' => $server->uuid,
                'X-Access-Token' => $server->node->daemonSecret,
            ])->request('POST', '/server/reinstall', [
                'json' => [
                    'build' => [
                        'env|overwrite' => $environment->pluck('value', 'variable')->toArray(),
                    ],
                    'service' => [
                        'type' => $server->option->service->folder,
                        'option' => $server->option->tag,
                        'pack' => (! is_null($server->pack_id)) ? $server->pack->uuid : null,
                        'skip_scripts' => $server->skip_scripts,
                    ],
                ],
            ]);

            return true;
        });
    }

    /**
     * Delete a server from the system permanetly.
     *
     * @param  int   $id
     * @param  bool  $force
     * @return void
     *
     * @throws \Pterodactyl\Exceptions\DisplayException
     */
    public function delete($id, $force = false)
    {
        $server = Server::with('node', 'allocations', 'variables')->findOrFail($id);

        // Due to MySQL lockouts if the daemon response fails, we need to
        // delete the server from the daemon first. If it succeedes and then
        // MySQL fails, users just need to force delete the server.
        //
        // If this is a force delete, continue anyways.
        try {
            $server->node->guzzleClient([
                'X-Access-Token' => $server->node->daemonSecret,
                'X-Access-Server' => $server->uuid,
            ])->request('DELETE', '/servers');
        } catch (ClientException $ex) {
            // Exception is thrown on 4XX HTTP errors, so catch and determine
            // if we should continue, or if there is a permissions error.
            //
            // Daemon throws a 404 if the server doesn't exist, if that is returned
            // continue with deletion, even if not a force deletion.
            $response = $ex->getResponse();
            if ($ex->getResponse()->getStatusCode() !== 404 && ! $force) {
                throw new DisplayException($ex->getMessage());
            }
        } catch (TransferException $ex) {
            if (! $force) {
                throw new DisplayException($ex->getMessage());
            }
        } catch (\Exception $ex) {
            throw $ex;
        }

        DB::transaction(function () use ($server) {
            $server->allocations->each(function ($item) {
                $item->server_id = null;
                $item->save();
            });

            $server->variables->each->delete();

            $server->load('subusers.permissions');
            $server->subusers->each(function ($subuser) {
                $subuser->permissions->each->delete();
                $subuser->delete();
            });

            $server->tasks->each->delete();

            // Delete Databases
            // This is the one un-recoverable point where
            // transactions will not save us.
            $repository = new DatabaseRepository;
            $server->databases->each(function ($item) use ($repository) {
                $repository->drop($item->id);
            });

            // Fully delete the server.
            $server->delete();
        });
    }

    /**
     * Toggle the install status of a serve.
     *
     * @param  int    $id
     * @return bool
     *
     * @throws \Pterodactyl\Exceptions\DisplayException
     */
    public function toggleInstall($id)
    {
        $server = Server::findOrFail($id);
        if ($server->installed > 1) {
            throw new DisplayException('This server was marked as having a failed install or being deleted, you cannot override this.');
        }
        $server->installed = ! $server->installed;

        return $server->save();
    }

    /**
     * Suspends or unsuspends a server.
     *
     * @param  int   $id
     * @param  bool  $unsuspend
     * @return void
     */
    public function toggleAccess($id, $unsuspend = true)
    {
        $server = Server::with('node')->findOrFail($id);

        DB::transaction(function () use ($server, $unsuspend) {
            if (
                (! $unsuspend && $server->suspended) ||
                ($unsuspend && ! $server->suspended)
            ) {
                return true;
            }

            $server->suspended = ! $unsuspend;
            $server->save();

            $server->node->guzzleClient([
                'X-Access-Token' => $server->node->daemonSecret,
                'X-Access-Server' => $server->uuid,
            ])->request('POST', ($unsuspend) ? '/server/unsuspend' : '/server/suspend');
        });
    }

    /**
     * Updates the SFTP password for a server.
     *
     * @param  int     $id
     * @param  string  $password
     * @return void
     *
     * @throws \Pterodactyl\Exceptions\DisplayValidationException
     */
    public function updateSFTPPassword($id, $password)
    {
        $server = Server::with('node')->findOrFail($id);

        $validator = Validator::make(['password' => $password], [
            'password' => 'required|regex:/^((?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,})$/',
        ]);

        if ($validator->fails()) {
            throw new DisplayValidationException(json_encode($validator->errors()));
        }

        DB::transaction(function () use ($password, $server) {
            $server->sftp_password = Crypt::encrypt($password);
            $server->save();

            $server->node->guzzleClient([
                'X-Access-Token' => $server->node->daemonSecret,
                'X-Access-Server' => $server->uuid,
            ])->request('POST', '/server/password', [
                'json' => ['password' => $password],
            ]);
        });
    }

    /**
     * Marks a server for reinstallation on the node.
     *
     * @param  int     $id
     * @return void
     */
    public function reinstall($id)
    {
        $server = Server::with('node')->findOrFail($id);

        DB::transaction(function () use ($server) {
            $server->installed = 0;
            $server->save();

            $server->node->guzzleClient([
                'X-Access-Token' => $server->node->daemonSecret,
                'X-Access-Server' => $server->uuid,
            ])->request('POST', '/server/reinstall');
        });
    }
}