Update CHANGELOG.md

Fixes ghcr build

.github/workflows/build-test.yml

@@ -1,36 +1,28 @@
 name: Run Tests
-
 on:
   push:
     branches:
       - 'develop'
-
   pull_request:
     branches:
       - 'develop'
-
 jobs:
   build:
     strategy:
       fail-fast: false
-
       matrix:
         os: [ ubuntu-20.04 ]
-        go: [ 1.15.6 ]
+        go: [ '^1.15', '^1.16' ]
         goos: [ linux ]
         goarch: [ amd64, arm64 ]
-
     runs-on: ${{ matrix.os }}
-
     steps:
       - name: Code Checkout
         uses: actions/checkout@v2
-
       - name: Setup Go v${{ matrix.go }}
         uses: actions/setup-go@v2
         with:
           go-version: ${{ matrix.go }}
-
       - name: Print Environment
         id: env
         run: |
@@ -44,7 +36,6 @@ jobs:
           echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
           echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
           echo "::set-output name=go_cache::$(go env GOCACHE)"
-
       - name: Build Cache
         uses: actions/cache@v2
         with:
@@ -52,11 +43,9 @@ jobs:
           key: ${{ runner.os }}-${{ matrix.go }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.go }}-go
-
       - name: Get Dependencies
         run: |
           go get -v -t -d ./...
-
       - name: Build
         env:
           GOOS: ${{ matrix.goos }}
@@ -67,13 +56,11 @@ jobs:
           go build -v -trimpath -ldflags="-s -w -X ${SRC_PATH}/system.Version=dev-${GIT_COMMIT:0:7}" -o build/wings_${{ matrix.goos }}_${{ matrix.goarch }} wings.go
           upx build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
           chmod +x build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
-
       - name: Test
         run: go test ./...
-
       - name: Upload Artifact
         uses: actions/upload-artifact@v2
-        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
+        if: ${{ matrix.go == '^1.15' && (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
         with:
           name: wings_${{ matrix.goos }}_${{ matrix.goarch }}
           path: build/wings_${{ matrix.goos }}_${{ matrix.goarch }}

.github/workflows/codeql-analysis.yml

@@ -1,5 +1,4 @@
 name: CodeQL
-
 on:
   push:
     branches:

.github/workflows/docker.yml

@@ -1,5 +1,4 @@
 name: Publish Docker Image
-
 on:
   push:
     branches:
@@ -7,46 +6,37 @@ on:
 
     tags:
       - 'v*'
-
 jobs:
   push:
     name: Push
     runs-on: ubuntu-20.04
-
     # Always run against a tag, even if the commit into the tag has [docker skip] within the commit message.
     if: "!contains(github.ref, 'develop') || (!contains(github.event.head_commit.message, 'skip docker') && !contains(github.event.head_commit.message, 'docker skip'))"
-
     steps:
       - name: Code Checkout
         uses: actions/checkout@v2
-
       - name: Docker Meta
         id: docker_meta
         uses: crazy-max/ghaction-docker-meta@v1
         with:
           images: ghcr.io/pterodactyl/wings
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v1
-
       - name: Install buildx
         uses: docker/setup-buildx-action@v1
         with:
           version: v0.5.1
-
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v1
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.REGISTRY_TOKEN }}
-
       - name: Get Build Information
         id: build_info
         run: |
           echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
           echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
-
       - name: Release Production Build
         uses: docker/build-push-action@v2
         if: "!contains(github.ref, 'develop')"
@@ -56,7 +46,6 @@ jobs:
           labels: ${{ steps.docker_meta.outputs.labels }}
           push: true
           tags: ${{ steps.docker_meta.outputs.tags }}
-
       - name: Release Development Build
         uses: docker/build-push-action@v2
         if: "contains(github.ref, 'develop')"

.github/workflows/release.yml

@@ -1,51 +1,41 @@
 name: Create Release
-
 on:
   push:
     tags:
       - 'v*'
-
 jobs:
   release:
     runs-on: ubuntu-20.04
-
     steps:
       - name: Code Checkout
         uses: actions/checkout@v2
-
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.15.6'
-
+          go-version: '^1.15'
       - name: Build
         env:
           REF: ${{ github.ref }}
         run: |
           CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_amd64 -v wings.go
           CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_arm64 -v wings.go
-
       - name: Test
         run: go test ./...
-
       - name: Compress binary and make it executable
         run: |
           upx build/wings_linux_amd64 && chmod +x build/wings_linux_amd64
           upx build/wings_linux_arm64 && chmod +x build/wings_linux_arm64
-
       - name: Extract changelog
         env:
           REF: ${{ github.ref }}
         run: |
           sed -n "/^## ${REF:10}/,/^## /{/^## /b;p}" CHANGELOG.md > ./RELEASE_CHANGELOG
           echo ::set-output name=version_name::`sed -nr "s/^## (${REF:10} .*)$/\1/p" CHANGELOG.md`
-
       - name: Create checksum and add to changelog
         run: |
           SUM=`cd build && sha256sum wings_linux_amd64`
           SUM2=`cd build && sha256sum wings_linux_arm64`
           echo -e "\n#### SHA256 Checksum\n\`\`\`\n$SUM\n$SUM2\n\`\`\`\n" >> ./RELEASE_CHANGELOG
           echo -e "$SUM\n$SUM2" > checksums.txt
-
       - name: Create release branch
         env:
           REF: ${{ github.ref }}
@@ -59,7 +49,6 @@ jobs:
           git add system/const.go
           git commit -m "bump version for release"
           git push
-
       - name: Create Release
         id: create_release
         uses: actions/create-release@v1
@@ -71,7 +60,6 @@ jobs:
           body_path: ./RELEASE_CHANGELOG
           draft: true
           prerelease: ${{ contains(github.ref, 'beta') || contains(github.ref, 'alpha') }}
-
       - name: Upload amd64 Binary
         uses: actions/upload-release-asset@v1
         env:
@@ -81,7 +69,6 @@ jobs:
           asset_path: build/wings_linux_amd64
           asset_name: wings_linux_amd64
           asset_content_type: application/octet-stream
-
       - name: Upload arm64 Binary
         uses: actions/upload-release-asset@v1
         env:
@@ -91,7 +78,6 @@ jobs:
           asset_path: build/wings_linux_arm64
           asset_name: wings_linux_arm64
           asset_content_type: application/octet-stream
-
       - name: Upload checksum
         uses: actions/upload-release-asset@v1
         env:

.gitignore

@@ -22,6 +22,7 @@
 
 # ignore configuration file
 /config.yml
+/config*.yml
 
 # Ignore Vagrant stuff
 /.vagrant

CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## v1.4.1
+### Fixed
+* Fixes a bug that would cause the file unarchiving process to put all files in the base directory rather than the directory in which the files should be located.
+
+## v1.4.0
+### Fixed
+* **[Breaking]** Fixes `/api/servers` and `/api/servers/:server` not properly returning all of the relevant server information and resource usage.
+* Fixes Wings improperly reading `WINGS_UID` and not `WINGS_GID` when running in containerized environments.
+* Fixes a panic encountered when returning the contents of a file that is actively being written to by another process.
+* Corrected the handling of files that are being decompressed to properly support `.rar` files.
+* Fixes the error message returned when a server has run out of disk space to properly indicate such, rather than indicating that the file is a directory.
+
+### Changed
+* Improved the error handling and output when an error is encountered while pulling an image for a server.
+* Improved robustness of code handling value replacement in configuration files to not potentially panic if a non-string value is encountered as the replacement type.
+* Improves error handling throughout the server filesystem.
+
+### Added
+* Adds the ability to set the internal name of the application in response output from the console using the `app_name` key in the `config.yml` file.
+
+## v1.3.2
+### Fixed
+* Correctly sets the internal state of the server as restoring when a restore is being performed to avoid any accidental booting.
+
+## v1.3.1
+### Fixed
+* Fixes an error being returned to the client when attempting to restart a server when the container no longer exists on the machine.
+
+### Changed
+* Updated server transfer logic to use newer file archiving tools to avoid frequent errors when transferring symlinked files.
+
+## v1.3.0
+### Fixed
+* Fixes improper error handling when attempting to create a new Docker network.
+* Fixes edge-case crash that would occur when a user triggers an install for a server that does not currently have a data directory present on the system.
+* Fixes missing return on error when attempting to get the contents of a file from Wings.
+* Fixes certain stop signals not being properly handled and parsed by Wings.
+* Fixes server build settings not always being updated properly if set to their zero-value.
+* Fixes context leak when waiting on a server instance to be stopped.
+* Fix potential application panic when chowning a file if there is an error getting file details.
+* Fixes `Filesystem.Chown` unintentionally touching all of the files within a given directory tree which could cause some games to trigger a full refresh thinking files had been changed.
+* Fixes `Content-Disposition` header not being properly escaped causing some browsers to not report the correct filename on downloads.
+
+### Added
+* Adds support for restoring server backups (including remote backups) with the ability to reset the current file state for a server.
+* Adds underlying support for allowing Eggs to mark specific files (or patterns) as being inaccessible to users within the file manager.
+
+### Changed
+* Refactored SFTP subsystem to be less of a standalone package and more integrated with the underlying server logic in Wings. This significantly simplified the logic and makes it much easier to reason about.
+* Refactored much of the underlying API logic to be more extensible down the road, support automatic retries, and be more testable.
+* Refactored much of the underlying HTTP middleware logic to be packaged differently and easier to reason about in the codebase.
+* System defined `TZ` variable will be used if present rather than attempting to parse the timezone using `datetimectl`.
+* Improves error handling and reporting for server installation process to improve debugging in the future if things break.
+
 ## v1.2.3
 ### Fixed
 * **[Security]** Fixes a remaining security vulnerability in the code handling remote file downloads for servers relating to redirect validation.

Dockerfile

@@ -1,33 +1,22 @@
 # Stage 1 (Build)
-FROM        golang:1.15-alpine3.12 AS builder
+FROM golang:1.15-alpine3.12 AS builder
 
-ARG         VERSION
-
-RUN         apk add --update --no-cache git=2.26.2-r0 make=4.3-r0 upx=3.96-r0
-
-WORKDIR     /app/
-
-COPY        go.mod go.sum /app/
-RUN         go mod download
-
-COPY        . /app/
-
-RUN         CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-                -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=$VERSION" \
-                -v \
-                -trimpath \
-                -o wings \
-                wings.go
-
-RUN         upx wings
-
-# --------------------------------------- #
+ARG VERSION
+RUN apk add --update --no-cache git make upx
+WORKDIR /app/
+COPY go.mod go.sum /app/
+RUN go mod download
+COPY . /app/
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+    -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=$VERSION" \
+    -v \
+    -trimpath \
+    -o wings \
+    wings.go
+RUN upx wings
 
 # Stage 2 (Final)
-FROM        busybox:1.33.0
-
-RUN         echo "ID=\"busybox\"" > /etc/os-release
-
-COPY        --from=builder /app/wings /usr/bin/
-
-CMD         [ "wings", "--config", "/etc/pterodactyl/config.yml" ]
+FROM busybox:1.33.0
+RUN echo "ID=\"busybox\"" > /etc/os-release
+COPY --from=builder /app/wings /usr/bin/
+CMD [ "wings", "--config", "/etc/pterodactyl/config.yml" ]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Dane Everitt <dane@daneeveritt.com>
+Copyright (c) 2018 - 2021 Dane Everitt <dane@daneeveritt.com> and Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,10 +1,18 @@
+GIT_HEAD = $(shell git rev-parse HEAD | head -c8)
+
 build:
 	GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_amd64 -v wings.go
 	GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_arm64 -v wings.go
 
 debug:
-	go build -race
-	./wings --debug --ignore-certificate-errors --config config.yml
+	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
+	sudo ./wings --debug --ignore-certificate-errors --config config.yml
+
+# Runs a remotly debuggable session for Wings allowing an IDE to connect and target
+# different breakpoints.
+rmdebug:
+	go build -gcflags "all=-N -l" -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
+	sudo dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./wings -- --debug --ignore-certificate-errors --config config.yml
 
 compress:
 	upx --brute build/wings_*

README.md

@@ -19,14 +19,19 @@ I would like to extend my sincere thanks to the following sponsors for helping f
 | Company | About |
 | ------- | ----- |
 | [**WISP**](https://wisp.gg) | Extra features. |
+| [**MixmlHosting**](https://mixmlhosting.com) | MixmlHosting provides high quality Virtual Private Servers along with game servers, all at a affordable price. |
+| [**BisectHosting**](https://www.bisecthosting.com/) | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012. |
 | [**Bloom.host**](https://bloom.host) | Bloom.host offers dedicated core VPS and Minecraft hosting with Ryzen 9 processors. With owned-hardware, we offer truly unbeatable prices on high-performance hosting. |
 | [**MineStrator**](https://minestrator.com/) | Looking for a French highend hosting company for you minecraft server? More than 14,000 members on our discord, trust us. |
 | [**DedicatedMC**](https://dedicatedmc.io/) | DedicatedMC provides Raw Power hosting at affordable pricing, making sure to never compromise on your performance and giving you the best performance money can buy. |
 | [**Skynode**](https://www.skynode.pro/) | Skynode provides blazing fast game servers along with a top-notch user experience. Whatever our clients are looking for, we're able to provide it! |
 | [**XCORE**](https://xcore-server.de/) | XCORE offers High-End Servers for hosting and gaming since 2012. Fast, excellent and well-known for eSports Gaming. |
-| [**RoyaleHosting**](https://royalehosting.net/) |  Build your dreams and deploy them with RoyaleHosting’s reliable servers and network. Easy to use, provisioned in a couple of minutes. |
-| [**Spill Hosting**](https://spillhosting.no/) |  Spill Hosting is a Norwegian hosting service, which aims to cheap services on quality servers. Premium i9-9900K processors will run your game like a dream. |
-| [**DeinServerHost**](https://deinserverhost.de/) |  DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
+| [**RoyaleHosting**](https://royalehosting.net/) | Build your dreams and deploy them with RoyaleHosting’s reliable servers and network. Easy to use, provisioned in a couple of minutes. |
+| [**Spill Hosting**](https://spillhosting.no/) | Spill Hosting is a Norwegian hosting service, which aims for inexpensive services on quality servers. Premium i9-9900K processors will run your game like a dream. |
+| [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
+| [**HostBend**](https://hostbend.com/) | HostBend offers a variety of solutions for developers, students, and others who have a tight budget but don't want to compromise quality and support. |
+| [**Capitol Hosting Solutions**](https://capitolsolutions.cloud/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
+| [**ByteAnia**](https://byteania.com/?utm_source=pterodactyl) | ByteAnia offers the best performing and most affordable **Ryzen 5000 Series hosting** on the market for *unbeatable prices*! |
 
 ## Documentation
 * [Panel Documentation](https://pterodactyl.io/panel/1.0/getting_started.html)

api/api.go

@@ -1,197 +0,0 @@
-package api
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/system"
-)
-
-// Initializes the requester instance.
-func New() *Request {
-	return &Request{}
-}
-
-// A generic type allowing for easy binding use when making requests to API endpoints
-// that only expect a singular argument or something that would not benefit from being
-// a typed struct.
-//
-// Inspired by gin.H, same concept.
-type D map[string]interface{}
-
-// Same concept as D, but a map of strings, used for querying GET requests.
-type Q map[string]string
-
-// A custom API requester struct for Wings.
-type Request struct{}
-
-// A custom response type that allows for commonly used error handling and response
-// parsing from the Panel API. This just embeds the normal HTTP response from Go and
-// we attach a few helper functions to it.
-type Response struct {
-	*http.Response
-}
-
-// A pagination struct matching the expected pagination response from the Panel API.
-type Pagination struct {
-	CurrentPage uint `json:"current_page"`
-	From        uint `json:"from"`
-	LastPage    uint `json:"last_page"`
-	PerPage     uint `json:"per_page"`
-	To          uint `json:"to"`
-	Total       uint `json:"total"`
-}
-
-// Builds the base request instance that can be used with the HTTP client.
-func (r *Request) Client() *http.Client {
-	return &http.Client{Timeout: time.Second * time.Duration(config.Get().RemoteQuery.Timeout)}
-}
-
-// Returns the given endpoint formatted as a URL to the Panel API.
-func (r *Request) Endpoint(endpoint string) string {
-	return fmt.Sprintf(
-		"%s/api/remote/%s",
-		strings.TrimSuffix(config.Get().PanelLocation, "/"),
-		strings.TrimPrefix(strings.TrimPrefix(endpoint, "/"), "api/remote/"),
-	)
-}
-
-// Makes a HTTP request to the given endpoint, attaching the necessary request headers from
-// Wings to ensure that the request is properly handled by the Panel.
-func (r *Request) Make(method, url string, body io.Reader, opts ...func(r *http.Request)) (*Response, error) {
-	req, err := http.NewRequest(method, url, body)
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("User-Agent", fmt.Sprintf("Pterodactyl Wings/v%s (id:%s)", system.Version, config.Get().AuthenticationTokenId))
-	req.Header.Set("Accept", "application/vnd.pterodactyl.v1+json")
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s.%s", config.Get().AuthenticationTokenId, config.Get().AuthenticationToken))
-
-	// Make any options calls that will allow us to make modifications to the request
-	// before it is sent off.
-	for _, cb := range opts {
-		cb(req)
-	}
-
-	r.debug(req)
-
-	res, err := r.Client().Do(req)
-
-	return &Response{Response: res}, err
-}
-
-// Logs the request into the debug log with all of the important request bits.
-// The authorization key will be cleaned up before being output.
-func (r *Request) debug(req *http.Request) {
-	headers := make(map[string][]string)
-	for k, v := range req.Header {
-		if k != "Authorization" || len(v) == 0 {
-			headers[k] = v
-			continue
-		}
-
-		headers[k] = []string{v[0][0:15] + "(redacted)"}
-	}
-
-	log.WithFields(log.Fields{
-		"method":   req.Method,
-		"endpoint": req.URL.String(),
-		"headers":  headers,
-	}).Debug("making request to external HTTP endpoint")
-}
-
-// Makes a GET request to the given Panel API endpoint. If any data is passed as the
-// second argument it will be passed through on the request as URL parameters.
-func (r *Request) Get(url string, data Q) (*Response, error) {
-	return r.Make(http.MethodGet, r.Endpoint(url), nil, func(r *http.Request) {
-		q := r.URL.Query()
-		for k, v := range data {
-			q.Set(k, v)
-		}
-
-		r.URL.RawQuery = q.Encode()
-	})
-}
-
-// Makes a POST request to the given Panel API endpoint.
-func (r *Request) Post(url string, data interface{}) (*Response, error) {
-	b, err := json.Marshal(data)
-	if err != nil {
-		return nil, err
-	}
-
-	return r.Make(http.MethodPost, r.Endpoint(url), bytes.NewBuffer(b))
-}
-
-// Determines if the API call encountered an error. If no request has been made
-// the response will be false. This function will evaluate to true if the response
-// code is anything 300 or higher.
-func (r *Response) HasError() bool {
-	if r.Response == nil {
-		return false
-	}
-
-	return r.StatusCode >= 300 || r.StatusCode < 200
-}
-
-// Reads the body from the response and returns it, then replaces it on the response
-// so that it can be read again later. This does not close the response body, so any
-// functions calling this should be sure to manually defer a Body.Close() call.
-func (r *Response) Read() ([]byte, error) {
-	var b []byte
-	if r.Response == nil {
-		return nil, errors.New("no response exists on interface")
-	}
-
-	if r.Response.Body != nil {
-		b, _ = ioutil.ReadAll(r.Response.Body)
-	}
-
-	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
-
-	return b, nil
-}
-
-// Binds a given interface with the data returned in the response. This is a shortcut
-// for calling Read and then manually calling json.Unmarshal on the raw bytes.
-func (r *Response) Bind(v interface{}) error {
-	b, err := r.Read()
-	if err != nil {
-		return err
-	}
-
-	return json.Unmarshal(b, &v)
-}
-
-// Returns the error message from the API call as a string. The error message will be formatted
-// similar to the below example:
-//
-// HttpNotFoundException: The requested resource does not exist. (HTTP/404)
-func (r *Response) Error() error {
-	if !r.HasError() {
-		return nil
-	}
-
-	var bag RequestErrorBag
-	_ = r.Bind(&bag)
-
-	e := &RequestError{}
-	if len(bag.Errors) > 0 {
-		e = &bag.Errors[0]
-	}
-
-	e.response = r.Response
-
-	return e
-}

api/backup_endpoints.go

@@ -1,49 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"strconv"
-)
-
-type BackupRemoteUploadResponse struct {
-	Parts    []string `json:"parts"`
-	PartSize int64    `json:"part_size"`
-}
-
-func (r *Request) GetBackupRemoteUploadURLs(backup string, size int64) (*BackupRemoteUploadResponse, error) {
-	resp, err := r.Get(fmt.Sprintf("/backups/%s", backup), Q{"size": strconv.FormatInt(size, 10)})
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.HasError() {
-		return nil, resp.Error()
-	}
-
-	var res BackupRemoteUploadResponse
-	if err := resp.Bind(&res); err != nil {
-		return nil, err
-	}
-
-	return &res, nil
-}
-
-type BackupRequest struct {
-	Checksum     string `json:"checksum"`
-	ChecksumType string `json:"checksum_type"`
-	Size         int64  `json:"size"`
-	Successful   bool   `json:"successful"`
-}
-
-// Notifies the panel that a specific backup has been completed and is now
-// available for a user to view and download.
-func (r *Request) SendBackupStatus(backup string, data BackupRequest) error {
-	resp, err := r.Post(fmt.Sprintf("/backups/%s", backup), data)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	return resp.Error()
-}

api/process_configuration.go

@@ -1,69 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"regexp"
-	"strings"
-
-	"github.com/apex/log"
-	"github.com/pterodactyl/wings/parser"
-)
-
-type OutputLineMatcher struct {
-	// The raw string to match against. This may or may not be prefixed with
-	// regex: which indicates we want to match against the regex expression.
-	raw string
-	reg *regexp.Regexp
-}
-
-// Determine if a given string "s" matches the given line.
-func (olm *OutputLineMatcher) Matches(s string) bool {
-	if olm.reg == nil {
-		return strings.Contains(s, olm.raw)
-	}
-
-	return olm.reg.MatchString(s)
-}
-
-// Return the matcher's raw comparison string.
-func (olm *OutputLineMatcher) String() string {
-	return olm.raw
-}
-
-// Unmarshal the startup lines into individual structs for easier matching abilities.
-func (olm *OutputLineMatcher) UnmarshalJSON(data []byte) error {
-	if err := json.Unmarshal(data, &olm.raw); err != nil {
-		return err
-	}
-
-	if strings.HasPrefix(olm.raw, "regex:") && len(olm.raw) > 6 {
-		r, err := regexp.Compile(strings.TrimPrefix(olm.raw, "regex:"))
-		if err != nil {
-			log.WithField("error", err).WithField("raw", olm.raw).Warn("failed to compile output line marked as being regex")
-		}
-
-		olm.reg = r
-	}
-
-	return nil
-}
-
-type ProcessStopConfiguration struct {
-	Type  string `json:"type"`
-	Value string `json:"value"`
-}
-
-// Defines the process configuration for a given server instance. This sets what the
-// daemon is looking for to mark a server as done starting, what to do when stopping,
-// and what changes to make to the configuration file for a server.
-type ProcessConfiguration struct {
-	Startup struct {
-		Done            []*OutputLineMatcher `json:"done"`
-		UserInteraction []string             `json:"user_interaction"`
-		StripAnsi       bool                 `json:"strip_ansi"`
-	} `json:"startup"`
-
-	Stop ProcessStopConfiguration `json:"stop"`
-
-	ConfigurationFiles []parser.ConfigurationFile `json:"configs"`
-}

api/server_endpoints.go

@@ -1,204 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"sync"
-
-	"github.com/apex/log"
-	"github.com/pterodactyl/wings/config"
-	"golang.org/x/sync/errgroup"
-)
-
-const (
-	ProcessStopCommand    = "command"
-	ProcessStopSignal     = "signal"
-	ProcessStopNativeStop = "stop"
-)
-
-// Holds the server configuration data returned from the Panel. When a server process
-// is started, Wings communicates with the Panel to fetch the latest build information
-// as well as get all of the details needed to parse the given Egg.
-//
-// This means we do not need to hit Wings each time part of the server is updated, and
-// the Panel serves as the source of truth at all times. This also means if a configuration
-// is accidentally wiped on Wings we can self-recover without too much hassle, so long
-// as Wings is aware of what servers should exist on it.
-type ServerConfigurationResponse struct {
-	Settings             json.RawMessage       `json:"settings"`
-	ProcessConfiguration *ProcessConfiguration `json:"process_configuration"`
-}
-
-// Defines installation script information for a server process. This is used when
-// a server is installed for the first time, and when a server is marked for re-installation.
-type InstallationScript struct {
-	ContainerImage string `json:"container_image"`
-	Entrypoint     string `json:"entrypoint"`
-	Script         string `json:"script"`
-}
-
-type allServerResponse struct {
-	Data []RawServerData `json:"data"`
-	Meta Pagination      `json:"meta"`
-}
-
-type RawServerData struct {
-	Uuid                 string          `json:"uuid"`
-	Settings             json.RawMessage `json:"settings"`
-	ProcessConfiguration json.RawMessage `json:"process_configuration"`
-}
-
-// Fetches all of the server configurations from the Panel API. This will initially load the
-// first 50 servers, and then check the pagination response to determine if more pages should
-// be loaded. If so, those requests are spun-up in additional routines and the final resulting
-// slice of all servers will be returned.
-func (r *Request) GetServers() ([]RawServerData, error) {
-	resp, err := r.Get("/servers", Q{"per_page": strconv.Itoa(int(config.Get().RemoteQuery.BootServersPerPage))})
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.HasError() {
-		return nil, resp.Error()
-	}
-
-	var res allServerResponse
-	if err := resp.Bind(&res); err != nil {
-		return nil, err
-	}
-
-	var mu sync.Mutex
-	ret := res.Data
-
-	// Check for pagination, and if it exists we'll need to then make a request to the API
-	// for each page that would exist and get all of the resulting servers.
-	if res.Meta.LastPage > 1 {
-		pp := res.Meta.PerPage
-		log.WithField("per_page", pp).
-			WithField("total_pages", res.Meta.LastPage).
-			Debug("detected multiple pages of server configurations, fetching remaining...")
-
-		g, ctx := errgroup.WithContext(context.Background())
-		for i := res.Meta.CurrentPage + 1; i <= res.Meta.LastPage; i++ {
-			page := strconv.Itoa(int(i))
-
-			g.Go(func() error {
-				select {
-				case <-ctx.Done():
-					return ctx.Err()
-				default:
-					{
-						resp, err := r.Get("/servers", Q{"page": page, "per_page": strconv.Itoa(int(pp))})
-						if err != nil {
-							return err
-						}
-						defer resp.Body.Close()
-
-						if resp.Error() != nil {
-							return resp.Error()
-						}
-
-						var servers allServerResponse
-						if err := resp.Bind(&servers); err != nil {
-							return err
-						}
-
-						mu.Lock()
-						defer mu.Unlock()
-						ret = append(ret, servers.Data...)
-
-						return nil
-					}
-				}
-			})
-		}
-
-		if err := g.Wait(); err != nil {
-			return nil, err
-		}
-	}
-
-	return ret, nil
-}
-
-// Fetches the server configuration and returns the struct for it.
-func (r *Request) GetServerConfiguration(uuid string) (ServerConfigurationResponse, error) {
-	var cfg ServerConfigurationResponse
-
-	resp, err := r.Get(fmt.Sprintf("/servers/%s", uuid), nil)
-	if err != nil {
-		return cfg, err
-	}
-	defer resp.Body.Close()
-
-	if resp.HasError() {
-		return cfg, resp.Error()
-	}
-
-	if err := resp.Bind(&cfg); err != nil {
-		return cfg, err
-	}
-
-	return cfg, nil
-}
-
-// Fetches installation information for the server process.
-func (r *Request) GetInstallationScript(uuid string) (InstallationScript, error) {
-	var is InstallationScript
-	resp, err := r.Get(fmt.Sprintf("/servers/%s/install", uuid), nil)
-	if err != nil {
-		return is, err
-	}
-	defer resp.Body.Close()
-
-	if resp.HasError() {
-		return is, resp.Error()
-	}
-
-	if err := resp.Bind(&is); err != nil {
-		return is, err
-	}
-
-	return is, nil
-}
-
-// Marks a server as being installed successfully or unsuccessfully on the panel.
-func (r *Request) SendInstallationStatus(uuid string, successful bool) error {
-	resp, err := r.Post(fmt.Sprintf("/servers/%s/install", uuid), D{"successful": successful})
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.HasError() {
-		return resp.Error()
-	}
-
-	return nil
-}
-
-func (r *Request) SendArchiveStatus(uuid string, successful bool) error {
-	resp, err := r.Post(fmt.Sprintf("/servers/%s/archive", uuid), D{"successful": successful})
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	return resp.Error()
-}
-
-func (r *Request) SendTransferStatus(uuid string, successful bool) error {
-	state := "failure"
-	if successful {
-		state = "success"
-	}
-	resp, err := r.Get(fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	return resp.Error()
-}

api/sftp_endpoints.go

@@ -1,85 +0,0 @@
-package api
-
-import (
-	"regexp"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-)
-
-type SftpAuthRequest struct {
-	User          string `json:"username"`
-	Pass          string `json:"password"`
-	IP            string `json:"ip"`
-	SessionID     []byte `json:"session_id"`
-	ClientVersion []byte `json:"client_version"`
-}
-
-type SftpAuthResponse struct {
-	Server      string   `json:"server"`
-	Token       string   `json:"token"`
-	Permissions []string `json:"permissions"`
-}
-
-type sftpInvalidCredentialsError struct {
-}
-
-func (ice sftpInvalidCredentialsError) Error() string {
-	return "the credentials provided were invalid"
-}
-
-func IsInvalidCredentialsError(err error) bool {
-	_, ok := err.(*sftpInvalidCredentialsError)
-
-	return ok
-}
-
-// Usernames all follow the same format, so don't even bother hitting the API if the username is not
-// at least in the expected format. This is very basic protection against random bots finding the SFTP
-// server and sending a flood of usernames.
-var validUsernameRegexp = regexp.MustCompile(`^(?i)(.+)\.([a-z0-9]{8})$`)
-
-func (r *Request) ValidateSftpCredentials(request SftpAuthRequest) (*SftpAuthResponse, error) {
-	// If the username doesn't meet the expected format that the Panel would even recognize just go ahead
-	// and bail out of the process here to avoid accidentally brute forcing the panel if a bot decides
-	// to connect to spam username attempts.
-	if !validUsernameRegexp.MatchString(request.User) {
-		log.WithFields(log.Fields{
-			"subsystem": "sftp",
-			"username":  request.User,
-			"ip":        request.IP,
-		}).Warn("failed to validate user credentials (invalid format)")
-
-		return nil, new(sftpInvalidCredentialsError)
-	}
-
-	resp, err := r.Post("/sftp/auth", request)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	e := resp.Error()
-	if e != nil {
-		if resp.StatusCode >= 400 && resp.StatusCode < 500 {
-			log.WithFields(log.Fields{
-				"subsystem": "sftp",
-				"username":  request.User,
-				"ip":        request.IP,
-			}).Warn(e.Error())
-
-			return nil, &sftpInvalidCredentialsError{}
-		}
-
-		rerr := errors.New(e.Error())
-
-		return nil, rerr
-	}
-
-	var response SftpAuthResponse
-	if err := resp.Bind(&response); err != nil {
-		return nil, err
-	}
-
-	return &response, nil
-}

cmd/config_finder.go

@@ -1,61 +0,0 @@
-package cmd
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/pterodactyl/wings/config"
-)
-
-// We've gone through a couple of iterations of where the configuration is stored. This
-// helpful little function will look through the three areas it might have ended up, and
-// return it.
-//
-// We only run this if the configuration flag for the instance is not actually passed in
-// via the command line. Once found, the configuration is moved into the expected default
-// location. Only errors are returned from this function, you can safely assume that after
-// running this the configuration can be found in the correct default location.
-func RelocateConfiguration() error {
-	var match string
-	check := []string{
-		config.DefaultLocation,
-		"/var/lib/pterodactyl/config.yml",
-		"/etc/wings/config.yml",
-	}
-
-	// Loop over all of the configuration paths, and return which one we found, if
-	// any.
-	for _, p := range check {
-		if s, err := os.Stat(p); err != nil {
-			if !os.IsNotExist(err) {
-				return err
-			}
-		} else if !s.IsDir() {
-			match = p
-			break
-		}
-	}
-
-	// Just return a generic not exist error at this point if we didn't have a match, this
-	// will allow the caller to handle displaying a more friendly error to the user. If we
-	// did match in the default location, go ahead and return successfully.
-	if match == "" {
-		return os.ErrNotExist
-	} else if match == config.DefaultLocation {
-		return nil
-	}
-
-	// The rest of this function simply creates the new default location and moves the
-	// old configuration file over to the new location, then sets the permissions on the
-	// file correctly so that only the user running this process can read it.
-	p, _ := filepath.Split(config.DefaultLocation)
-	if err := os.MkdirAll(p, 0755); err != nil {
-		return err
-	}
-
-	if err := os.Rename(match, config.DefaultLocation); err != nil {
-		return err
-	}
-
-	return os.Chmod(config.DefaultLocation, 0600)
-}

cmd/configure.go

@@ -147,7 +147,7 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 
 	b, err := ioutil.ReadAll(res.Body)
 
-	cfg, err := config.NewFromPath(configPath)
+	cfg, err := config.NewAtPath(configPath)
 	if err != nil {
 		panic(err)
 	}
@@ -156,7 +156,7 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 		panic(err)
 	}
 
-	if err = cfg.WriteToDisk(); err != nil {
+	if err = config.WriteToDisk(cfg); err != nil {
 		panic(err)
 	}
 

cmd/diagnostics.go

@@ -15,14 +15,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pterodactyl/wings/environment"
-
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
+	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/parsers/kernel"
 	"github.com/docker/docker/pkg/parsers/operatingsystem"
 	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/loggers/cli"
 	"github.com/pterodactyl/wings/system"
 	"github.com/spf13/cobra"
 )
@@ -40,15 +41,21 @@ var (
 	}
 )
 
-var diagnosticsCmd = &cobra.Command{
-	Use:   "diagnostics",
-	Short: "Collect diagnostics information.",
-	Run:   diagnosticsCmdRun,
-}
+func newDiagnosticsCommand() *cobra.Command {
+	command := &cobra.Command{
+		Use:   "diagnostics",
+		Short: "Collect and report information about this Wings instance to assist in debugging.",
+		PreRun: func(cmd *cobra.Command, args []string) {
+			initConfig()
+			log.SetHandler(cli.Default)
+		},
+		Run: diagnosticsCmdRun,
+	}
 
-func init() {
-	diagnosticsCmd.PersistentFlags().StringVar(&diagnosticsArgs.HastebinURL, "hastebin-url", DefaultHastebinUrl, "The url of the hastebin instance to use.")
-	diagnosticsCmd.PersistentFlags().IntVar(&diagnosticsArgs.LogLines, "log-lines", DefaultLogLines, "The number of log lines to include in the report")
+	command.Flags().StringVar(&diagnosticsArgs.HastebinURL, "hastebin-url", DefaultHastebinUrl, "the url of the hastebin instance to use")
+	command.Flags().IntVar(&diagnosticsArgs.LogLines, "log-lines", DefaultLogLines, "the number of log lines to include in the report")
+
+	return command
 }
 
 // diagnosticsCmdRun collects diagnostics about wings, it's configuration and the node.
@@ -85,7 +92,6 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	}
 
 	dockerVersion, dockerInfo, dockerErr := getDockerInfo()
-	_ = dockerInfo
 
 	output := &strings.Builder{}
 	fmt.Fprintln(output, "Pterodactyl Wings - Diagnostics Report")
@@ -102,50 +108,53 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	}
 
 	printHeader(output, "Wings Configuration")
-	cfg, err := config.ReadConfiguration(config.DefaultLocation)
-	if cfg != nil {
-		fmt.Fprintln(output, "    Panel Location:", redact(cfg.PanelLocation))
-		fmt.Fprintln(output, "")
-		fmt.Fprintln(output, " Internal Webserver:", redact(cfg.Api.Host), ":", cfg.Api.Port)
-		fmt.Fprintln(output, "        SSL Enabled:", cfg.Api.Ssl.Enabled)
-		fmt.Fprintln(output, "    SSL Certificate:", redact(cfg.Api.Ssl.CertificateFile))
-		fmt.Fprintln(output, "            SSL Key:", redact(cfg.Api.Ssl.KeyFile))
-		fmt.Fprintln(output, "")
-		fmt.Fprintln(output, "        SFTP Server:", redact(cfg.System.Sftp.Address), ":", cfg.System.Sftp.Port)
-		fmt.Fprintln(output, "     SFTP Read-Only:", cfg.System.Sftp.ReadOnly)
-		fmt.Fprintln(output, "")
-		fmt.Fprintln(output, "     Root Directory:", cfg.System.RootDirectory)
-		fmt.Fprintln(output, "     Logs Directory:", cfg.System.LogDirectory)
-		fmt.Fprintln(output, "     Data Directory:", cfg.System.Data)
-		fmt.Fprintln(output, "  Archive Directory:", cfg.System.ArchiveDirectory)
-		fmt.Fprintln(output, "   Backup Directory:", cfg.System.BackupDirectory)
-		fmt.Fprintln(output, "")
-		fmt.Fprintln(output, "           Username:", cfg.System.Username)
-		fmt.Fprintln(output, "        Server Time:", time.Now().Format(time.RFC1123Z))
-		fmt.Fprintln(output, "         Debug Mode:", cfg.Debug)
-	} else {
-		fmt.Println("Failed to load configuration.", err)
+	if err := config.FromFile(config.DefaultLocation); err != nil {
+
 	}
+	cfg := config.Get()
+	fmt.Fprintln(output, "    Panel Location:", redact(cfg.PanelLocation))
+	fmt.Fprintln(output, "")
+	fmt.Fprintln(output, " Internal Webserver:", redact(cfg.Api.Host), ":", cfg.Api.Port)
+	fmt.Fprintln(output, "        SSL Enabled:", cfg.Api.Ssl.Enabled)
+	fmt.Fprintln(output, "    SSL Certificate:", redact(cfg.Api.Ssl.CertificateFile))
+	fmt.Fprintln(output, "            SSL Key:", redact(cfg.Api.Ssl.KeyFile))
+	fmt.Fprintln(output, "")
+	fmt.Fprintln(output, "        SFTP Server:", redact(cfg.System.Sftp.Address), ":", cfg.System.Sftp.Port)
+	fmt.Fprintln(output, "     SFTP Read-Only:", cfg.System.Sftp.ReadOnly)
+	fmt.Fprintln(output, "")
+	fmt.Fprintln(output, "     Root Directory:", cfg.System.RootDirectory)
+	fmt.Fprintln(output, "     Logs Directory:", cfg.System.LogDirectory)
+	fmt.Fprintln(output, "     Data Directory:", cfg.System.Data)
+	fmt.Fprintln(output, "  Archive Directory:", cfg.System.ArchiveDirectory)
+	fmt.Fprintln(output, "   Backup Directory:", cfg.System.BackupDirectory)
+	fmt.Fprintln(output, "")
+	fmt.Fprintln(output, "           Username:", cfg.System.Username)
+	fmt.Fprintln(output, "        Server Time:", time.Now().Format(time.RFC1123Z))
+	fmt.Fprintln(output, "         Debug Mode:", cfg.Debug)
 
 	printHeader(output, "Docker: Info")
-	fmt.Fprintln(output, "Server Version:", dockerInfo.ServerVersion)
-	fmt.Fprintln(output, "Storage Driver:", dockerInfo.Driver)
-	if dockerInfo.DriverStatus != nil {
-		for _, pair := range dockerInfo.DriverStatus {
-			fmt.Fprintf(output, "  %s: %s\n", pair[0], pair[1])
+	if dockerErr == nil {
+		fmt.Fprintln(output, "Server Version:", dockerInfo.ServerVersion)
+		fmt.Fprintln(output, "Storage Driver:", dockerInfo.Driver)
+		if dockerInfo.DriverStatus != nil {
+			for _, pair := range dockerInfo.DriverStatus {
+				fmt.Fprintf(output, "  %s: %s\n", pair[0], pair[1])
+			}
 		}
-	}
-	if dockerInfo.SystemStatus != nil {
-		for _, pair := range dockerInfo.SystemStatus {
-			fmt.Fprintf(output, " %s: %s\n", pair[0], pair[1])
+		if dockerInfo.SystemStatus != nil {
+			for _, pair := range dockerInfo.SystemStatus {
+				fmt.Fprintf(output, " %s: %s\n", pair[0], pair[1])
+			}
 		}
-	}
-	fmt.Fprintln(output, "LoggingDriver:", dockerInfo.LoggingDriver)
-	fmt.Fprintln(output, " CgroupDriver:", dockerInfo.CgroupDriver)
-	if len(dockerInfo.Warnings) > 0 {
-		for _, w := range dockerInfo.Warnings {
-			fmt.Fprintln(output, w)
+		fmt.Fprintln(output, "LoggingDriver:", dockerInfo.LoggingDriver)
+		fmt.Fprintln(output, " CgroupDriver:", dockerInfo.CgroupDriver)
+		if len(dockerInfo.Warnings) > 0 {
+			for _, w := range dockerInfo.Warnings {
+				fmt.Fprintln(output, w)
+			}
 		}
+	} else {
+		fmt.Fprintln(output, dockerErr.Error())
 	}
 
 	printHeader(output, "Docker: Running Containers")
@@ -180,23 +189,23 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		survey.AskOne(&survey.Confirm{Message: "Upload to " + diagnosticsArgs.HastebinURL + "?", Default: false}, &upload)
 	}
 	if upload {
-		url, err := uploadToHastebin(diagnosticsArgs.HastebinURL, output.String())
+		u, err := uploadToHastebin(diagnosticsArgs.HastebinURL, output.String())
 		if err == nil {
-			fmt.Println("Your report is available here: ", url)
+			fmt.Println("Your report is available here: ", u)
 		}
 	}
 }
 
 func getDockerInfo() (types.Version, types.Info, error) {
-	cli, err := environment.DockerClient()
+	client, err := environment.Docker()
 	if err != nil {
 		return types.Version{}, types.Info{}, err
 	}
-	dockerVersion, err := cli.ServerVersion(context.Background())
+	dockerVersion, err := client.ServerVersion(context.Background())
 	if err != nil {
 		return types.Version{}, types.Info{}, err
 	}
-	dockerInfo, err := cli.Info(context.Background())
+	dockerInfo, err := client.Info(context.Background())
 	if err != nil {
 		return types.Version{}, types.Info{}, err
 	}

cmd/root.go

@@ -2,15 +2,17 @@ package cmd
 
 import (
 	"crypto/tls"
+	"errors"
 	"fmt"
 	log2 "log"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
+	"time"
 
-	"emperror.dev/errors"
 	"github.com/NYTimes/logrotate"
 	"github.com/apex/log"
 	"github.com/apex/log/handlers/multi"
@@ -21,6 +23,7 @@ import (
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/loggers/cli"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/sftp"
@@ -39,6 +42,8 @@ var rootCommand = &cobra.Command{
 	Use:   "wings",
 	Short: "Runs the API server allowing programatic control of game servers for Pterodactyl Panel.",
 	PreRun: func(cmd *cobra.Command, args []string) {
+		initConfig()
+		initLogging()
 		if tls, _ := cmd.Flags().GetBool("auto-tls"); tls {
 			if host, _ := cmd.Flags().GetString("tls-hostname"); host == "" {
 				fmt.Println("A TLS hostname must be provided when running wings with automatic TLS, e.g.:\n\n    ./wings --auto-tls --tls-hostname my.example.com")
@@ -53,7 +58,7 @@ var versionCommand = &cobra.Command{
 	Use:   "version",
 	Short: "Prints the current executable version and exits.",
 	Run: func(cmd *cobra.Command, _ []string) {
-		fmt.Printf("wings v%s\nCopyright © 2018 - 2021 Dane Everitt & Contributors\n", system.Version)
+		fmt.Printf("wings v%s\nCopyright © 2018 - %d Dane Everitt & Contributors\n", system.Version, time.Now().Year())
 	},
 }
 
@@ -75,28 +80,7 @@ func init() {
 
 	rootCommand.AddCommand(versionCommand)
 	rootCommand.AddCommand(configureCmd)
-	rootCommand.AddCommand(diagnosticsCmd)
-}
-
-// Get the configuration path based on the arguments provided.
-func readConfiguration() (*config.Configuration, error) {
-	p := configPath
-	if !strings.HasPrefix(p, "/") {
-		d, err := os.Getwd()
-		if err != nil {
-			return nil, err
-		}
-
-		p = path.Clean(path.Join(d, configPath))
-	}
-
-	if s, err := os.Stat(p); err != nil {
-		return nil, err
-	} else if s.IsDir() {
-		return nil, errors.New("cannot use directory as configuration file path")
-	}
-
-	return config.ReadConfiguration(p)
+	rootCommand.AddCommand(newDiagnosticsCommand())
 }
 
 func rootCmdRun(cmd *cobra.Command, _ []string) {
@@ -119,35 +103,9 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		defer profile.Start(profile.BlockProfile).Stop()
 	}
 
-	// Only attempt configuration file relocation if a custom location has not
-	// been specified in the command startup.
-	if configPath == config.DefaultLocation {
-		if err := RelocateConfiguration(); err != nil {
-			if errors.Is(err, os.ErrNotExist) {
-				exitWithConfigurationNotice()
-			}
-			panic(err)
-		}
-	}
-
-	c, err := readConfiguration()
-	if err != nil {
-		panic(err)
-	}
-
-	if debug {
-		c.Debug = true
-	}
-
 	printLogo()
-	if err := configureLogging(c.System.LogDirectory, c.Debug); err != nil {
-		panic(err)
-	}
-
-	log.WithField("path", c.GetPath()).Info("loading configuration from path")
-	if c.Debug {
-		log.Debug("running in debug mode")
-	}
+	log.Debug("running in debug mode")
+	log.WithField("config_file", configPath).Info("loading configuration from file")
 
 	if ok, _ := cmd.Flags().GetBool("ignore-certificate-errors"); ok {
 		log.Warn("running with --ignore-certificate-errors: TLS certificate host chains and name will not be verified")
@@ -156,73 +114,93 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		}
 	}
 
-	config.Set(c)
-	config.SetDebugViaFlag(debug)
-
-	if err := c.System.ConfigureTimezone(); err != nil {
+	if err := config.ConfigureTimezone(); err != nil {
 		log.WithField("error", err).Fatal("failed to detect system timezone or use supplied configuration value")
-		return
 	}
-
-	log.WithField("timezone", c.System.Timezone).Info("configured wings with system timezone")
-
-	if err := c.System.ConfigureDirectories(); err != nil {
+	log.WithField("timezone", config.Get().System.Timezone).Info("configured wings with system timezone")
+	if err := config.ConfigureDirectories(); err != nil {
 		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
 		return
 	}
-
-	if err := c.System.EnableLogRotation(); err != nil {
+	if err := config.EnableLogRotation(); err != nil {
 		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
 		return
 	}
 
-	log.WithField("username", c.System.Username).Info("checking for pterodactyl system user")
-	if su, err := c.EnsurePterodactylUser(); err != nil {
+	log.WithField("username", config.Get().System.User).Info("checking for pterodactyl system user")
+	if err := config.EnsurePterodactylUser(); err != nil {
 		log.WithField("error", err).Fatal("failed to create pterodactyl system user")
-		return
-	} else {
-		log.WithFields(log.Fields{
-			"username": su.Username,
-			"uid":      su.Uid,
-			"gid":      su.Gid,
-		}).Info("configured system user successfully")
 	}
+	log.WithFields(log.Fields{
+		"username": config.Get().System.Username,
+		"uid":      config.Get().System.User.Uid,
+		"gid":      config.Get().System.User.Gid,
+	}).Info("configured system user successfully")
 
-	if err := server.LoadDirectory(); err != nil {
+	pclient := remote.New(
+		config.Get().PanelLocation,
+		remote.WithCredentials(config.Get().AuthenticationTokenId, config.Get().AuthenticationToken),
+		remote.WithHttpClient(&http.Client{
+			Timeout: time.Second * time.Duration(config.Get().RemoteQuery.Timeout),
+		}),
+	)
+
+	manager, err := server.NewManager(cmd.Context(), pclient)
+	if err != nil {
 		log.WithField("error", err).Fatal("failed to load server configurations")
-		return
 	}
 
-	if err := environment.ConfigureDocker(&c.Docker); err != nil {
+	if err := environment.ConfigureDocker(cmd.Context()); err != nil {
 		log.WithField("error", err).Fatal("failed to configure docker environment")
-		return
 	}
 
-	if err := c.WriteToDisk(); err != nil {
-		log.WithField("error", err).Error("failed to save configuration to disk")
+	if err := config.WriteToDisk(config.Get()); err != nil {
+		log.WithField("error", err).Fatal("failed to write configuration to disk")
 	}
 
 	// Just for some nice log output.
-	for _, s := range server.GetServers().All() {
-		log.WithField("server", s.Id()).Info("loaded configuration for server")
+	for _, s := range manager.All() {
+		log.WithField("server", s.Id()).Info("finished loading configuration for server")
 	}
 
-	states, err := server.CachedServerStates()
+	states, err := manager.ReadStates()
 	if err != nil {
 		log.WithField("error", err).Error("failed to retrieve locally cached server states from disk, assuming all servers in offline state")
 	}
 
+	ticker := time.NewTicker(time.Minute)
+	// Every minute, write the current server states to the disk to allow for a more
+	// seamless hard-reboot process in which wings will re-sync server states based
+	// on it's last tracked state.
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				if err := manager.PersistStates(); err != nil {
+					log.WithField("error", err).Warn("failed to persist server states to disk")
+				}
+			case <-cmd.Context().Done():
+				ticker.Stop()
+				return
+			}
+		}
+	}()
+
 	// Create a new workerpool that limits us to 4 servers being bootstrapped at a time
 	// on Wings. This allows us to ensure the environment exists, write configurations,
 	// and reboot processes without causing a slow-down due to sequential booting.
 	pool := workerpool.New(4)
-
-	for _, serv := range server.GetServers().All() {
+	for _, serv := range manager.All() {
 		s := serv
 
+		// For each server we encounter make sure the root data directory exists.
+		if err := s.EnsureDataDirectoryExists(); err != nil {
+			s.Log().Error("could not create root data directory for server: not loading server...")
+			continue
+		}
+
 		pool.Submit(func() {
 			s.Log().Info("configuring server environment and restoring to previous state")
-
 			var st string
 			if state, exists := states[s.Id()]; exists {
 				st = state
@@ -271,20 +249,39 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	// Wait until all of the servers are ready to go before we fire up the SFTP and HTTP servers.
 	pool.StopWait()
+	defer func() {
+		// Cancel the context on all of the running servers at this point, even though the
+		// program is just shutting down.
+		for _, s := range manager.All() {
+			s.CtxCancel()
+		}
+	}()
 
-	// Initialize the SFTP server.
-	if err := sftp.Initialize(c.System); err != nil {
-		log.WithError(err).Fatal("failed to initialize the sftp server")
-		return
-	}
+	go func() {
+		// Run the SFTP server.
+		if err := sftp.New(manager).Run(); err != nil {
+			log.WithError(err).Fatal("failed to initialize the sftp server")
+			return
+		}
+	}()
 
+	go func() {
+		log.Info("updating server states on Panel: marking installing/restoring servers as normal")
+		// Update all of the servers on the Panel to be in a valid state if they're
+		// currently marked as installing/restoring now that Wings is restarted.
+		if err := pclient.ResetServersState(cmd.Context()); err != nil {
+			log.WithField("error", err).Error("failed to reset server states on Panel: some instances may be stuck in an installing/restoring state unexpectedly")
+		}
+	}()
+
+	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(c.System.ArchiveDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.ArchiveDirectory, 0755); err != nil {
 		log.WithField("error", err).Error("failed to create archive directory")
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(c.System.BackupDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.BackupDirectory, 0755); err != nil {
 		log.WithField("error", err).Error("failed to create backup directory")
 	}
 
@@ -294,47 +291,31 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		autotls = false
 	}
 
+	api := config.Get().Api
 	log.WithFields(log.Fields{
-		"use_ssl":      c.Api.Ssl.Enabled,
+		"use_ssl":      api.Ssl.Enabled,
 		"use_auto_tls": autotls,
-		"host_address": c.Api.Host,
-		"host_port":    c.Api.Port,
+		"host_address": api.Host,
+		"host_port":    api.Port,
 	}).Info("configuring internal webserver")
 
-	// Configure the router.
-	r := router.Configure()
-
+	// Create a new HTTP server instance to handle inbound requests from the Panel
+	// and external clients.
 	s := &http.Server{
-		Addr:    fmt.Sprintf("%s:%d", c.Api.Host, c.Api.Port),
-		Handler: r,
-		TLSConfig: &tls.Config{
-			NextProtos: []string{"h2", "http/1.1"},
-			// @see https://blog.cloudflare.com/exposing-go-on-the-internet
-			CipherSuites: []uint16{
-				tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-				tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-				tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-				tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
-				tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
-			},
-			PreferServerCipherSuites: true,
-			MinVersion:               tls.VersionTLS12,
-			MaxVersion:               tls.VersionTLS13,
-			CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
-		},
+		Addr:      api.Host + ":" + strconv.Itoa(api.Port),
+		Handler:   router.Configure(manager, pclient),
+		TLSConfig: config.DefaultTLSConfig,
 	}
 
 	// Check if the server should run with TLS but using autocert.
 	if autotls {
 		m := autocert.Manager{
 			Prompt:     autocert.AcceptTOS,
-			Cache:      autocert.DirCache(path.Join(c.System.RootDirectory, "/.tls-cache")),
+			Cache:      autocert.DirCache(path.Join(sys.RootDirectory, "/.tls-cache")),
 			HostPolicy: autocert.HostWhitelist(tlshostname),
 		}
 
-		log.WithField("hostname", tlshostname).
-			Info("webserver is now listening with auto-TLS enabled; certificates will be automatically generated by Let's Encrypt")
+		log.WithField("hostname", tlshostname).Info("webserver is now listening with auto-TLS enabled; certificates will be automatically generated by Let's Encrypt")
 
 		// Hook autocert into the main http server.
 		s.TLSConfig.GetCertificate = m.GetCertificate
@@ -346,59 +327,67 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				log.WithError(err).Error("failed to serve autocert http server")
 			}
 		}()
-
 		// Start the main http server with TLS using autocert.
 		if err := s.ListenAndServeTLS("", ""); err != nil {
-			log.WithFields(log.Fields{"auto_tls": true, "tls_hostname": tlshostname, "error": err}).
-				Fatal("failed to configure HTTP server using auto-tls")
+			log.WithFields(log.Fields{"auto_tls": true, "tls_hostname": tlshostname, "error": err}).Fatal("failed to configure HTTP server using auto-tls")
 		}
-
 		return
 	}
 
-	// Check if main http server should run with TLS.
-	if c.Api.Ssl.Enabled {
-		if err := s.ListenAndServeTLS(strings.ToLower(c.Api.Ssl.CertificateFile), strings.ToLower(c.Api.Ssl.KeyFile)); err != nil {
+	// Check if main http server should run with TLS. Otherwise reset the TLS
+	// config on the server and then serve it over normal HTTP.
+	if api.Ssl.Enabled {
+		if err := s.ListenAndServeTLS(strings.ToLower(api.Ssl.CertificateFile), strings.ToLower(api.Ssl.KeyFile)); err != nil {
 			log.WithFields(log.Fields{"auto_tls": false, "error": err}).Fatal("failed to configure HTTPS server")
 		}
 		return
 	}
-
-	// Run the main http server without TLS.
 	s.TLSConfig = nil
 	if err := s.ListenAndServe(); err != nil {
 		log.WithField("error", err).Fatal("failed to configure HTTP server")
 	}
+}
 
-	// Cancel the context on all of the running servers at this point, even though the
-	// program is just shutting down.
-	for _, s := range server.GetServers().All() {
-		s.CtxCancel()
+// Reads the configuration from the disk and then sets up the global singleton
+// with all of the configuration values.
+func initConfig() {
+	if !strings.HasPrefix(configPath, "/") {
+		d, err := os.Getwd()
+		if err != nil {
+			log2.Fatalf("cmd/root: could not determine directory: %s", err)
+		}
+		configPath = path.Clean(path.Join(d, configPath))
+	}
+	err := config.FromFile(configPath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			exitWithConfigurationNotice()
+		}
+		log2.Fatalf("cmd/root: error while reading configuration file: %s", err)
+	}
+	if debug && !config.Get().Debug {
+		config.SetDebugViaFlag(debug)
 	}
 }
 
 // Configures the global logger for Zap so that we can call it from any location
 // in the code without having to pass around a logger instance.
-func configureLogging(logDir string, debug bool) error {
-	if err := os.MkdirAll(path.Join(logDir, "/install"), 0700); err != nil {
-		return err
+func initLogging() {
+	dir := config.Get().System.LogDirectory
+	if err := os.MkdirAll(path.Join(dir, "/install"), 0700); err != nil {
+		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
 	}
-
-	p := filepath.Join(logDir, "/wings.log")
+	p := filepath.Join(dir, "/wings.log")
 	w, err := logrotate.NewFile(p)
 	if err != nil {
-		return err
+		log2.Fatalf("cmd/root: failed to create wings log: %s", err)
 	}
-
 	log.SetLevel(log.InfoLevel)
-	if debug {
+	if config.Get().Debug {
 		log.SetLevel(log.DebugLevel)
 	}
-
 	log.SetHandler(multi.New(cli.Default, cli.New(w.File, false)))
 	log.WithField("path", p).Info("writing log files to disk")
-
-	return nil
 }
 
 // Prints the wings logo, nothing special here!
@@ -411,7 +400,7 @@ __ [blue][bold]Pterodactyl[reset] _____/___/_______ _______ ______
         \___/\___/___/___/___/___    /______/
                             /_______/ [bold]%s[reset]
 
-Copyright © 2018 - 2021 Dane Everitt & Contributors
+Copyright © 2018 - %d Dane Everitt & Contributors
 
 Website:  https://pterodactyl.io
  Source:  https://github.com/pterodactyl/wings
@@ -419,7 +408,7 @@ License:  https://github.com/pterodactyl/wings/blob/develop/LICENSE
 
 This software is made available under the terms of the MIT license.
 The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.%s`), system.Version, "\n\n")
+in all copies or substantial portions of the Software.%s`), system.Version, time.Now().Year(), "\n\n")
 }
 
 func exitWithConfigurationNotice() {
@@ -427,11 +416,8 @@ func exitWithConfigurationNotice() {
 [_red_][white][bold]Error: Configuration File Not Found[reset]
 
 Wings was not able to locate your configuration file, and therefore is not
-able to complete its boot process.
-
-Please ensure you have copied your instance configuration file into
-the default location, or have provided the --config flag to use a
-custom location.
+able to complete its boot process. Please ensure you have copied your instance
+configuration file into the default location below.
 
 Default Location: /etc/pterodactyl/config.yml
 

config/config.go

@@ -1,38 +1,254 @@
 package config
 
 import (
+	"context"
+	"crypto/tls"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/user"
-	"strconv"
+	"path"
+	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
+	"text/template"
+	"time"
 
 	"emperror.dev/errors"
+	"github.com/apex/log"
 	"github.com/cobaugh/osrelease"
 	"github.com/creasty/defaults"
 	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/pterodactyl/wings/system"
 	"gopkg.in/yaml.v2"
 )
 
 const DefaultLocation = "/etc/pterodactyl/config.yml"
 
-type Configuration struct {
-	sync.RWMutex `json:"-" yaml:"-"`
+// DefaultTLSConfig sets sane defaults to use when configuring the internal
+// webserver to listen for public connections.
+//
+// @see https://blog.cloudflare.com/exposing-go-on-the-internet
+var DefaultTLSConfig = &tls.Config{
+	NextProtos: []string{"h2", "http/1.1"},
+	CipherSuites: []uint16{
+		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+		tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+		tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+		tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+		tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+		tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+	},
+	PreferServerCipherSuites: true,
+	MinVersion:               tls.VersionTLS12,
+	MaxVersion:               tls.VersionTLS13,
+	CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
+}
 
+var mu sync.RWMutex
+var _config *Configuration
+var _jwtAlgo *jwt.HMACSHA
+var _debugViaFlag bool
+
+// Locker specific to writing the configuration to the disk, this happens
+// in areas that might already be locked so we don't want to crash the process.
+var _writeLock sync.Mutex
+
+// SftpConfiguration defines the configuration of the internal SFTP server.
+type SftpConfiguration struct {
+	// The bind address of the SFTP server.
+	Address string `default:"0.0.0.0" json:"bind_address" yaml:"bind_address"`
+	// The bind port of the SFTP server.
+	Port int `default:"2022" json:"bind_port" yaml:"bind_port"`
+	// If set to true, no write actions will be allowed on the SFTP server.
+	ReadOnly bool `default:"false" yaml:"read_only"`
+}
+
+// ApiConfiguration defines the configuration for the internal API that is
+// exposed by the Wings webserver.
+type ApiConfiguration struct {
+	// The interface that the internal webserver should bind to.
+	Host string `default:"0.0.0.0" yaml:"host"`
+
+	// The port that the internal webserver should bind to.
+	Port int `default:"8080" yaml:"port"`
+
+	// SSL configuration for the daemon.
+	Ssl struct {
+		Enabled         bool   `json:"enabled" yaml:"enabled"`
+		CertificateFile string `json:"cert" yaml:"cert"`
+		KeyFile         string `json:"key" yaml:"key"`
+	}
+
+	// Determines if functionality for allowing remote download of files into server directories
+	// is enabled on this instance. If set to "true" remote downloads will not be possible for
+	// servers.
+	DisableRemoteDownload bool `json:"disable_remote_download" yaml:"disable_remote_download"`
+
+	// The maximum size for files uploaded through the Panel in bytes.
+	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
+}
+
+// RemoteQueryConfiguration defines the configuration settings for remote requests
+// from Wings to the Panel.
+type RemoteQueryConfiguration struct {
+	// The amount of time in seconds that Wings should allow for a request to the Panel API
+	// to complete. If this time passes the request will be marked as failed. If your requests
+	// are taking longer than 30 seconds to complete it is likely a performance issue that
+	// should be resolved on the Panel, and not something that should be resolved by upping this
+	// number.
+	Timeout int `default:"30" yaml:"timeout"`
+
+	// The number of servers to load in a single request to the Panel API when booting the
+	// Wings instance. A single request is initially made to the Panel to get this number
+	// of servers, and then the pagination status is checked and additional requests are
+	// fired off in parallel to request the remaining pages.
+	//
+	// It is not recommended to change this from the default as you will likely encounter
+	// memory limits on your Panel instance. In the grand scheme of things 4 requests for
+	// 50 servers is likely just as quick as two for 100 or one for 400, and will certainly
+	// be less likely to cause performance issues on the Panel.
+	BootServersPerPage int `default:"50" yaml:"boot_servers_per_page"`
+}
+
+// SystemConfiguration defines basic system configuration settings.
+type SystemConfiguration struct {
+	// The root directory where all of the pterodactyl data is stored at.
+	RootDirectory string `default:"/var/lib/pterodactyl" yaml:"root_directory"`
+
+	// Directory where logs for server installations and other wings events are logged.
+	LogDirectory string `default:"/var/log/pterodactyl" yaml:"log_directory"`
+
+	// Directory where the server data is stored at.
+	Data string `default:"/var/lib/pterodactyl/volumes" yaml:"data"`
+
+	// Directory where server archives for transferring will be stored.
+	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" yaml:"archive_directory"`
+
+	// Directory where local backups will be stored on the machine.
+	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`
+
+	// The user that should own all of the server files, and be used for containers.
+	Username string `default:"pterodactyl" yaml:"username"`
+
+	// The timezone for this Wings instance. This is detected by Wings automatically if possible,
+	// and falls back to UTC if not able to be detected. If you need to set this manually, that
+	// can also be done.
+	//
+	// This timezone value is passed into all containers created by Wings.
+	Timezone string `yaml:"timezone"`
+
+	// Definitions for the user that gets created to ensure that we can quickly access
+	// this information without constantly having to do a system lookup.
+	User struct {
+		Uid int
+		Gid int
+	}
+
+	// The amount of time in seconds that can elapse before a server's disk space calculation is
+	// considered stale and a re-check should occur. DANGER: setting this value too low can seriously
+	// impact system performance and cause massive I/O bottlenecks and high CPU usage for the Wings
+	// process.
+	//
+	// Set to 0 to disable disk checking entirely. This will always return 0 for the disk space used
+	// by a server and should only be set in extreme scenarios where performance is critical and
+	// disk usage is not a concern.
+	DiskCheckInterval int64 `default:"150" yaml:"disk_check_interval"`
+
+	// If set to true, file permissions for a server will be checked when the process is
+	// booted. This can cause boot delays if the server has a large amount of files. In most
+	// cases disabling this should not have any major impact unless external processes are
+	// frequently modifying a servers' files.
+	CheckPermissionsOnBoot bool `default:"true" yaml:"check_permissions_on_boot"`
+
+	// If set to false Wings will not attempt to write a log rotate configuration to the disk
+	// when it boots and one is not detected.
+	EnableLogRotate bool `default:"true" yaml:"enable_log_rotate"`
+
+	// The number of lines to send when a server connects to the websocket.
+	WebsocketLogCount int `default:"150" yaml:"websocket_log_count"`
+
+	Sftp SftpConfiguration `yaml:"sftp"`
+
+	CrashDetection CrashDetection `yaml:"crash_detection"`
+
+	Backups Backups `yaml:"backups"`
+
+	Transfers Transfers `yaml:"transfers"`
+}
+
+type CrashDetection struct {
+	// Determines if Wings should detect a server that stops with a normal exit code of
+	// "0" as being crashed if the process stopped without any Wings interaction. E.g.
+	// the user did not press the stop button, but the process stopped cleanly.
+	DetectCleanExitAsCrash bool `default:"true" yaml:"detect_clean_exit_as_crash"`
+
+	// Timeout specifies the timeout between crashes that will not cause the server
+	// to be automatically restarted, this value is used to prevent servers from
+	// becoming stuck in a boot-loop after multiple consecutive crashes.
+	Timeout int `default:"60" json:"timeout"`
+}
+
+type Backups struct {
+	// WriteLimit imposes a Disk I/O write limit on backups to the disk, this affects all
+	// backup drivers as the archiver must first write the file to the disk in order to
+	// upload it to any external storage provider.
+	//
+	// If the value is less than 1, the write speed is unlimited,
+	// if the value is greater than 0, the write speed is the value in MiB/s.
+	//
+	// Defaults to 0 (unlimited)
+	WriteLimit int `default:"0" yaml:"write_limit"`
+}
+
+type Transfers struct {
+	// DownloadLimit imposes a Network I/O read limit when downloading a transfer archive.
+	//
+	// If the value is less than 1, the write speed is unlimited,
+	// if the value is greater than 0, the write speed is the value in MiB/s.
+	//
+	// Defaults to 0 (unlimited)
+	DownloadLimit int `default:"0" yaml:"download_limit"`
+}
+
+type ConsoleThrottles struct {
+	// Whether or not the throttler is enabled for this instance.
+	Enabled bool `json:"enabled" yaml:"enabled" default:"true"`
+
+	// The total number of lines that can be output in a given LineResetInterval period before
+	// a warning is triggered and counted against the server.
+	Lines uint64 `json:"lines" yaml:"lines" default:"2000"`
+
+	// The total number of throttle activations that can accumulate before a server is considered
+	// to be breaching and will be stopped. This value is decremented by one every DecayInterval.
+	MaximumTriggerCount uint64 `json:"maximum_trigger_count" yaml:"maximum_trigger_count" default:"5"`
+
+	// The amount of time after which the number of lines processed is reset to 0. This runs in
+	// a constant loop and is not affected by the current console output volumes. By default, this
+	// will reset the processed line count back to 0 every 100ms.
+	LineResetInterval uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
+
+	// The amount of time in milliseconds that must pass without an output warning being triggered
+	// before a throttle activation is decremented.
+	DecayInterval uint64 `json:"decay_interval" yaml:"decay_interval" default:"10000"`
+
+	// The amount of time that a server is allowed to be stopping for before it is terminated
+	// forcefully if it triggers output throttles.
+	StopGracePeriod uint `json:"stop_grace_period" yaml:"stop_grace_period" default:"15"`
+}
+
+type Configuration struct {
 	// The location from which this configuration instance was instantiated.
 	path string
 
-	// Locker specific to writing the configuration to the disk, this happens
-	// in areas that might already be locked so we don't want to crash the process.
-	writeLock sync.Mutex
-
 	// Determines if wings should be running in debug mode. This value is ignored
 	// if the debug flag is passed through the command line arguments.
 	Debug bool
 
+	AppName string `default:"Pterodactyl" json:"app_name" yaml:"app_name"`
+
 	// A unique identifier for this node in the Panel.
 	Uuid string
 
@@ -67,293 +283,340 @@ type Configuration struct {
 	AllowedOrigins []string `json:"allowed_origins" yaml:"allowed_origins"`
 }
 
-// Defines the configuration of the internal SFTP server.
-type SftpConfiguration struct {
-	// The bind address of the SFTP server.
-	Address string `default:"0.0.0.0" json:"bind_address" yaml:"bind_address"`
-	// The bind port of the SFTP server.
-	Port int `default:"2022" json:"bind_port" yaml:"bind_port"`
-	// If set to true, no write actions will be allowed on the SFTP server.
-	ReadOnly bool `default:"false" yaml:"read_only"`
-}
-
-// Defines the configuration for the internal API that is exposed by the
-// daemon webserver.
-type ApiConfiguration struct {
-	// The interface that the internal webserver should bind to.
-	Host string `default:"0.0.0.0" yaml:"host"`
-
-	// The port that the internal webserver should bind to.
-	Port int `default:"8080" yaml:"port"`
-
-	// SSL configuration for the daemon.
-	Ssl struct {
-		Enabled         bool   `json:"enabled" yaml:"enabled"`
-		CertificateFile string `json:"cert" yaml:"cert"`
-		KeyFile         string `json:"key" yaml:"key"`
-	}
-
-	// Determines if functionality for allowing remote download of files into server directories
-	// is enabled on this instance. If set to "true" remote downloads will not be possible for
-	// servers.
-	DisableRemoteDownload bool `json:"disable_remote_download" yaml:"disable_remote_download"`
-
-	// The maximum size for files uploaded through the Panel in bytes.
-	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
-}
-
-// Defines the configuration settings for remote requests from Wings to the Panel.
-type RemoteQueryConfiguration struct {
-	// The amount of time in seconds that Wings should allow for a request to the Panel API
-	// to complete. If this time passes the request will be marked as failed. If your requests
-	// are taking longer than 30 seconds to complete it is likely a performance issue that
-	// should be resolved on the Panel, and not something that should be resolved by upping this
-	// number.
-	Timeout uint `default:"30" yaml:"timeout"`
-
-	// The number of servers to load in a single request to the Panel API when booting the
-	// Wings instance. A single request is initially made to the Panel to get this number
-	// of servers, and then the pagination status is checked and additional requests are
-	// fired off in parallel to request the remaining pages.
-	//
-	// It is not recommended to change this from the default as you will likely encounter
-	// memory limits on your Panel instance. In the grand scheme of things 4 requests for
-	// 50 servers is likely just as quick as two for 100 or one for 400, and will certainly
-	// be less likely to cause performance issues on the Panel.
-	BootServersPerPage uint `default:"50" yaml:"boot_servers_per_page"`
-}
-
-// Reads the configuration from the provided file and returns the configuration
-// object that can then be used.
-func ReadConfiguration(path string) (*Configuration, error) {
-	b, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	c := new(Configuration)
+// NewAtPath creates a new struct and set the path where it should be stored.
+// This function does not modify the currently stored global configuration.
+func NewAtPath(path string) (*Configuration, error) {
+	var c Configuration
 	// Configures the default values for many of the configuration options present
 	// in the structs. Values set in the configuration file take priority over the
 	// default values.
-	if err := defaults.Set(c); err != nil {
+	if err := defaults.Set(&c); err != nil {
 		return nil, err
 	}
-
 	// Track the location where we created this configuration.
-	c.unsafeSetPath(path)
-
-	// Replace environment variables within the configuration file with their
-	// values from the host system.
-	b = []byte(os.ExpandEnv(string(b)))
-
-	if err := yaml.Unmarshal(b, c); err != nil {
-		return nil, err
-	}
-
-	return c, nil
+	c.path = path
+	return &c, nil
 }
 
-var mu sync.RWMutex
-
-var _config *Configuration
-var _jwtAlgo *jwt.HMACSHA
-var _debugViaFlag bool
-
 // Set the global configuration instance. This is a blocking operation such that
 // anything trying to set a different configuration value, or read the configuration
 // will be paused until it is complete.
 func Set(c *Configuration) {
 	mu.Lock()
-
 	if _config == nil || _config.AuthenticationToken != c.AuthenticationToken {
 		_jwtAlgo = jwt.NewHS256([]byte(c.AuthenticationToken))
 	}
-
 	_config = c
 	mu.Unlock()
 }
 
+// SetDebugViaFlag tracks if the application is running in debug mode because of
+// a command line flag argument. If so we do not want to store that configuration
+// change to the disk.
 func SetDebugViaFlag(d bool) {
+	mu.Lock()
+	_config.Debug = d
 	_debugViaFlag = d
+	mu.Unlock()
 }
 
-// Get the global configuration instance. This is a read-safe operation that will block
-// if the configuration is presently being modified.
+// Get returns the global configuration instance. This is a thread-safe operation
+// that will block if the configuration is presently being modified.
+//
+// Be aware that you CANNOT make modifications to the currently stored configuration
+// by modifying the struct returned by this function. The only way to make
+// modifications is by using the Update() function and passing data through in
+// the callback.
 func Get() *Configuration {
 	mu.RLock()
-	defer mu.RUnlock()
-
-	return _config
+	// Create a copy of the struct so that all modifications made beyond this
+	// point are immutable.
+	//goland:noinspection GoVetCopyLock
+	c := *_config
+	mu.RUnlock()
+	return &c
 }
 
-// Returns the in-memory JWT algorithm.
+// Update performs an in-situ update of the global configuration object using
+// a thread-safe mutex lock. This is the correct way to make modifications to
+// the global configuration.
+func Update(callback func(c *Configuration)) {
+	mu.Lock()
+	callback(_config)
+	mu.Unlock()
+}
+
+// GetJwtAlgorithm returns the in-memory JWT algorithm.
 func GetJwtAlgorithm() *jwt.HMACSHA {
 	mu.RLock()
 	defer mu.RUnlock()
-
 	return _jwtAlgo
 }
 
-// Create a new struct and set the path where it should be stored.
-func NewFromPath(path string) (*Configuration, error) {
-	c := new(Configuration)
-	if err := defaults.Set(c); err != nil {
-		return c, err
+// WriteToDisk writes the configuration to the disk. This is a thread safe operation
+// and will only allow one write at a time. Additional calls while writing are
+// queued up.
+func WriteToDisk(c *Configuration) error {
+	_writeLock.Lock()
+	defer _writeLock.Unlock()
+
+	//goland:noinspection GoVetCopyLock
+	ccopy := *c
+	// If debugging is set with the flag, don't save that to the configuration file,
+	// otherwise you'll always end up in debug mode.
+	if _debugViaFlag {
+		ccopy.Debug = false
 	}
-
-	c.unsafeSetPath(path)
-
-	return c, nil
+	if c.path == "" {
+		return errors.New("cannot write configuration, no path defined in struct")
+	}
+	b, err := yaml.Marshal(&ccopy)
+	if err != nil {
+		return err
+	}
+	if err := ioutil.WriteFile(c.path, b, 0600); err != nil {
+		return err
+	}
+	return nil
 }
 
-// Sets the path where the configuration file is located on the server. This function should
-// not be called except by processes that are generating the configuration such as the configuration
-// command shipped with this software.
-func (c *Configuration) unsafeSetPath(path string) {
-	c.Lock()
-	c.path = path
-	c.Unlock()
-}
-
-// Returns the path for this configuration file.
-func (c *Configuration) GetPath() string {
-	c.RLock()
-	defer c.RUnlock()
-
-	return c.path
-}
-
-// Ensures that the Pterodactyl core user exists on the system. This user will be the
-// owner of all data in the root data directory and is used as the user within containers.
+// EnsurePterodactylUser ensures that the Pterodactyl core user exists on the
+// system. This user will be the owner of all data in the root data directory
+// and is used as the user within containers. If files are not owned by this
+// user there will be issues with permissions on Docker mount points.
 //
-// If files are not owned by this user there will be issues with permissions on Docker
-// mount points.
-func (c *Configuration) EnsurePterodactylUser() (*user.User, error) {
+// This function IS NOT thread safe and should only be called in the main thread
+// when the application is booting.
+func EnsurePterodactylUser() error {
 	sysName, err := getSystemName()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// Our way of detecting if wings is running inside of Docker.
 	if sysName == "busybox" {
-		uid := os.Getenv("WINGS_UID")
-		if uid == "" {
-			uid = "988"
-		}
-
-		gid := os.Getenv("WINGS_GID")
-		if gid == "" {
-			gid = "988"
-		}
-
-		username := os.Getenv("WINGS_USERNAME")
-		if username == "" {
-			username = "pterodactyl"
-		}
-
-		u := &user.User{
-			Uid:      uid,
-			Gid:      gid,
-			Username: username,
-		}
-		return u, c.setSystemUser(u)
+		_config.System.Username = system.FirstNotEmpty(os.Getenv("WINGS_USERNAME"), "pterodactyl")
+		_config.System.User.Uid = system.MustInt(system.FirstNotEmpty(os.Getenv("WINGS_UID"), "988"))
+		_config.System.User.Gid = system.MustInt(system.FirstNotEmpty(os.Getenv("WINGS_GID"), "988"))
+		return nil
 	}
 
-	u, err := user.Lookup(c.System.Username)
-
+	u, err := user.Lookup(_config.System.Username)
 	// If an error is returned but it isn't the unknown user error just abort
 	// the process entirely. If we did find a user, return it immediately.
-	if err == nil {
-		return u, c.setSystemUser(u)
-	} else if _, ok := err.(user.UnknownUserError); !ok {
-		return nil, err
+	if err != nil {
+		if _, ok := err.(user.UnknownUserError); !ok {
+			return err
+		}
+	} else {
+		_config.System.User.Uid = system.MustInt(u.Uid)
+		_config.System.User.Gid = system.MustInt(u.Gid)
+		return nil
 	}
 
-	command := fmt.Sprintf("useradd --system --no-create-home --shell /usr/sbin/nologin %s", c.System.Username)
-
-	// Alpine Linux is the only OS we currently support that doesn't work with the useradd command, so
-	// in those cases we just modify the command a bit to work as expected.
+	command := fmt.Sprintf("useradd --system --no-create-home --shell /usr/sbin/nologin %s", _config.System.Username)
+	// Alpine Linux is the only OS we currently support that doesn't work with the useradd
+	// command, so in those cases we just modify the command a bit to work as expected.
 	if strings.HasPrefix(sysName, "alpine") {
-		command = fmt.Sprintf("adduser -S -D -H -G %[1]s -s /sbin/nologin %[1]s", c.System.Username)
-
+		command = fmt.Sprintf("adduser -S -D -H -G %[1]s -s /sbin/nologin %[1]s", _config.System.Username)
 		// We have to create the group first on Alpine, so do that here before continuing on
 		// to the user creation process.
-		if _, err := exec.Command("addgroup", "-S", c.System.Username).Output(); err != nil {
-			return nil, err
+		if _, err := exec.Command("addgroup", "-S", _config.System.Username).Output(); err != nil {
+			return err
 		}
 	}
 
 	split := strings.Split(command, " ")
 	if _, err := exec.Command(split[0], split[1:]...).Output(); err != nil {
-		return nil, err
+		return err
 	}
-
-	if u, err := user.Lookup(c.System.Username); err != nil {
-		return nil, err
-	} else {
-		return u, c.setSystemUser(u)
+	u, err = user.Lookup(_config.System.Username)
+	if err != nil {
+		return err
 	}
+	_config.System.User.Uid = system.MustInt(u.Uid)
+	_config.System.User.Gid = system.MustInt(u.Gid)
+	return nil
 }
 
-// Set the system user into the configuration and then write it to the disk so that
-// it is persisted on boot.
-func (c *Configuration) setSystemUser(u *user.User) error {
-	uid, err := strconv.Atoi(u.Uid)
+// FromFile reads the configuration from the provided file and stores it in the
+// global singleton for this instance.
+func FromFile(path string) error {
+	b, err := ioutil.ReadFile(path)
 	if err != nil {
 		return err
 	}
-
-	gid, err := strconv.Atoi(u.Gid)
+	c, err := NewAtPath(path)
 	if err != nil {
 		return err
 	}
-
-	c.Lock()
-	c.System.Username = u.Username
-	c.System.User.Uid = uid
-	c.System.User.Gid = gid
-	c.Unlock()
-
-	return c.WriteToDisk()
+	// Replace environment variables within the configuration file with their
+	// values from the host system.
+	b = []byte(os.ExpandEnv(string(b)))
+	if err := yaml.Unmarshal(b, c); err != nil {
+		return err
+	}
+	// Store this configuration in the global state.
+	Set(c)
+	return nil
 }
 
-// Writes the configuration to the disk as a blocking operation by obtaining an exclusive
-// lock on the file. This prevents something else from writing at the exact same time and
-// leading to bad data conditions.
-func (c *Configuration) WriteToDisk() error {
-	// Obtain an exclusive write against the configuration file.
-	c.writeLock.Lock()
-	defer c.writeLock.Unlock()
-
-	ccopy := *c
-	// If debugging is set with the flag, don't save that to the configuration file, otherwise
-	// you'll always end up in debug mode.
-	if _debugViaFlag {
-		ccopy.Debug = false
-	}
-
-	if c.path == "" {
-		return errors.New("cannot write configuration, no path defined in struct")
-	}
-
-	b, err := yaml.Marshal(&ccopy)
-	if err != nil {
+// ConfigureDirectories ensures that all of the system directories exist on the
+// system. These directories are created so that only the owner can read the data,
+// and no other users.
+//
+// This function IS NOT thread-safe.
+func ConfigureDirectories() error {
+	root := _config.System.RootDirectory
+	log.WithField("path", root).Debug("ensuring root data directory exists")
+	if err := os.MkdirAll(root, 0700); err != nil {
 		return err
 	}
 
-	if err := ioutil.WriteFile(c.GetPath(), b, 0644); err != nil {
+	// There are a non-trivial number of users out there whose data directories are actually a
+	// symlink to another location on the disk. If we do not resolve that final destination at this
+	// point things will appear to work, but endless errors will be encountered when we try to
+	// verify accessed paths since they will all end up resolving outside the expected data directory.
+	//
+	// For the sake of automating away as much of this as possible, see if the data directory is a
+	// symlink, and if so resolve to its final real path, and then update the configuration to use
+	// that.
+	if d, err := filepath.EvalSymlinks(_config.System.Data); err != nil {
+		if !os.IsNotExist(err) {
+			return err
+		}
+	} else if d != _config.System.Data {
+		_config.System.Data = d
+	}
+
+	log.WithField("path", _config.System.Data).Debug("ensuring server data directory exists")
+	if err := os.MkdirAll(_config.System.Data, 0700); err != nil {
+		return err
+	}
+
+	log.WithField("path", _config.System.ArchiveDirectory).Debug("ensuring archive data directory exists")
+	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0700); err != nil {
+		return err
+	}
+
+	log.WithField("path", _config.System.BackupDirectory).Debug("ensuring backup data directory exists")
+	if err := os.MkdirAll(_config.System.BackupDirectory, 0700); err != nil {
 		return err
 	}
 
 	return nil
 }
 
+// EnableLogRotation writes a logrotate file for wings to the system logrotate
+// configuration directory if one exists and a logrotate file is not found. This
+// allows us to basically automate away the log rotation for most installs, but
+// also enable users to make modifications on their own.
+//
+// This function IS NOT thread-safe.
+func EnableLogRotation() error {
+	if !_config.System.EnableLogRotate {
+		log.Info("skipping log rotate configuration, disabled in wings config file")
+		return nil
+	}
+
+	if st, err := os.Stat("/etc/logrotate.d"); err != nil && !os.IsNotExist(err) {
+		return err
+	} else if (err != nil && os.IsNotExist(err)) || !st.IsDir() {
+		return nil
+	}
+	if _, err := os.Stat("/etc/logrotate.d/wings"); err == nil || !os.IsNotExist(err) {
+		return err
+	}
+
+	log.Info("no log rotation configuration found: adding file now")
+	// If we've gotten to this point it means the logrotate directory exists on the system
+	// but there is not a file for wings already. In that case, let us write a new file to
+	// it so files can be rotated easily.
+	f, err := os.Create("/etc/logrotate.d/wings")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	t, err := template.New("logrotate").Parse(`
+{{.LogDirectory}}/wings.log {
+    size 10M
+    compress
+    delaycompress
+    dateext
+    maxage 7
+    missingok
+    notifempty
+    create 0640 {{.User.Uid}} {{.User.Gid}}
+    postrotate
+        killall -SIGHUP wings
+    endscript
+}`)
+	if err != nil {
+		return err
+	}
+
+	return errors.Wrap(t.Execute(f, _config.System), "config: failed to write logrotate to disk")
+}
+
+// GetStatesPath returns the location of the JSON file that tracks server states.
+func (sc *SystemConfiguration) GetStatesPath() string {
+	return path.Join(sc.RootDirectory, "/states.json")
+}
+
+// ConfigureTimezone sets the timezone data for the configuration if it is
+// currently missing. If a value has been set, this functionality will only run
+// to validate that the timezone being used is valid.
+//
+// This function IS NOT thread-safe.
+func ConfigureTimezone() error {
+	tz := os.Getenv("TZ")
+	if _config.System.Timezone == "" && tz != "" {
+		_config.System.Timezone = tz
+	}
+	if _config.System.Timezone == "" {
+		b, err := ioutil.ReadFile("/etc/timezone")
+		if err != nil {
+			if !os.IsNotExist(err) {
+				return errors.WithMessage(err, "config: failed to open timezone file")
+			}
+
+			_config.System.Timezone = "UTC"
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			defer cancel()
+			// Okay, file isn't found on this OS, we will try using timedatectl to handle this. If this
+			// command fails, exit, but if it returns a value use that. If no value is returned we will
+			// fall through to UTC to get Wings booted at least.
+			out, err := exec.CommandContext(ctx, "timedatectl").Output()
+			if err != nil {
+				log.WithField("error", err).Warn("failed to execute \"timedatectl\" to determine system timezone, falling back to UTC")
+				return nil
+			}
+
+			r := regexp.MustCompile(`Time zone: ([\w/]+)`)
+			matches := r.FindSubmatch(out)
+			if len(matches) != 2 || string(matches[1]) == "" {
+				log.Warn("failed to parse timezone from \"timedatectl\" output, falling back to UTC")
+				return nil
+			}
+			_config.System.Timezone = string(matches[1])
+		} else {
+			_config.System.Timezone = string(b)
+		}
+	}
+
+	_config.System.Timezone = regexp.MustCompile(`(?i)[^a-z_/]+`).ReplaceAllString(_config.System.Timezone, "")
+	_, err := time.LoadLocation(_config.System.Timezone)
+
+	return errors.WithMessage(err, fmt.Sprintf("the supplied timezone %s is invalid", _config.System.Timezone))
+}
+
 // Gets the system release name.
 func getSystemName() (string, error) {
 	// use osrelease to get release version and ID
-	if release, err := osrelease.Read(); err != nil {
+	release, err := osrelease.Read()
+	if err != nil {
 		return "", err
-	} else {
-		return release["ID"], nil
 	}
+	return release["ID"], nil
 }

config/config_docker.go

@@ -12,7 +12,6 @@ type dockerNetworkInterfaces struct {
 		Subnet  string `default:"172.18.0.0/16"`
 		Gateway string `default:"172.18.0.1"`
 	}
-
 	V6 struct {
 		Subnet  string `default:"fdba:17c8:6c94::/64"`
 		Gateway string `default:"fdba:17c8:6c94::1011"`
@@ -39,8 +38,8 @@ type DockerNetworkConfiguration struct {
 	Interfaces dockerNetworkInterfaces `yaml:"interfaces"`
 }
 
-// Defines the docker configuration used by the daemon when interacting with
-// containers and networks on the system.
+// DockerConfiguration defines the docker configuration used by the daemon when
+// interacting with containers and networks on the system.
 type DockerConfiguration struct {
 	// Network configuration that should be used when creating a new network
 	// for containers run through the daemon.
@@ -58,23 +57,22 @@ type DockerConfiguration struct {
 	TmpfsSize uint `default:"100" json:"tmpfs_size" yaml:"tmpfs_size"`
 }
 
-// RegistryConfiguration .
+// RegistryConfiguration defines the authentication credentials for a given
+// Docker registry.
 type RegistryConfiguration struct {
 	Username string `yaml:"username"`
 	Password string `yaml:"password"`
 }
 
-// Base64 .
+// Base64 returns the authentication for a given registry as a base64 encoded
+// string value.
 func (c RegistryConfiguration) Base64() (string, error) {
-	authConfig := types.AuthConfig{
+	b, err := json.Marshal(types.AuthConfig{
 		Username: c.Username,
 		Password: c.Password,
-	}
-
-	b, err := json.Marshal(authConfig)
+	})
 	if err != nil {
 		return "", err
 	}
-
 	return base64.URLEncoding.EncodeToString(b), nil
 }

config/config_system.go

@@ -1,268 +0,0 @@
-package config
-
-import (
-	"context"
-	"fmt"
-	"html/template"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"regexp"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-)
-
-// Defines basic system configuration settings.
-type SystemConfiguration struct {
-	// The root directory where all of the pterodactyl data is stored at.
-	RootDirectory string `default:"/var/lib/pterodactyl" yaml:"root_directory"`
-
-	// Directory where logs for server installations and other wings events are logged.
-	LogDirectory string `default:"/var/log/pterodactyl" yaml:"log_directory"`
-
-	// Directory where the server data is stored at.
-	Data string `default:"/var/lib/pterodactyl/volumes" yaml:"data"`
-
-	// Directory where server archives for transferring will be stored.
-	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" yaml:"archive_directory"`
-
-	// Directory where local backups will be stored on the machine.
-	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`
-
-	// The user that should own all of the server files, and be used for containers.
-	Username string `default:"pterodactyl" yaml:"username"`
-
-	// The timezone for this Wings instance. This is detected by Wings automatically if possible,
-	// and falls back to UTC if not able to be detected. If you need to set this manually, that
-	// can also be done.
-	//
-	// This timezone value is passed into all containers created by Wings.
-	Timezone string `yaml:"timezone"`
-
-	// Definitions for the user that gets created to ensure that we can quickly access
-	// this information without constantly having to do a system lookup.
-	User struct {
-		Uid int
-		Gid int
-	}
-
-	// The amount of time in seconds that can elapse before a server's disk space calculation is
-	// considered stale and a re-check should occur. DANGER: setting this value too low can seriously
-	// impact system performance and cause massive I/O bottlenecks and high CPU usage for the Wings
-	// process.
-	//
-	// Set to 0 to disable disk checking entirely. This will always return 0 for the disk space used
-	// by a server and should only be set in extreme scenarios where performance is critical and
-	// disk usage is not a concern.
-	DiskCheckInterval int64 `default:"150" yaml:"disk_check_interval"`
-
-	// If set to true, file permissions for a server will be checked when the process is
-	// booted. This can cause boot delays if the server has a large amount of files. In most
-	// cases disabling this should not have any major impact unless external processes are
-	// frequently modifying a servers' files.
-	CheckPermissionsOnBoot bool `default:"true" yaml:"check_permissions_on_boot"`
-
-	// If set to false Wings will not attempt to write a log rotate configuration to the disk
-	// when it boots and one is not detected.
-	EnableLogRotate bool `default:"true" yaml:"enable_log_rotate"`
-
-	// The number of lines to send when a server connects to the websocket.
-	WebsocketLogCount int `default:"150" yaml:"websocket_log_count"`
-
-	Sftp SftpConfiguration `yaml:"sftp"`
-
-	CrashDetection CrashDetection `yaml:"crash_detection"`
-
-	Backups Backups `yaml:"backups"`
-
-	Transfers Transfers `yaml:"transfers"`
-}
-
-type CrashDetection struct {
-	// Determines if Wings should detect a server that stops with a normal exit code of
-	// "0" as being crashed if the process stopped without any Wings interaction. E.g.
-	// the user did not press the stop button, but the process stopped cleanly.
-	DetectCleanExitAsCrash bool `default:"true" yaml:"detect_clean_exit_as_crash"`
-
-	// Timeout specifies the timeout between crashes that will not cause the server
-	// to be automatically restarted, this value is used to prevent servers from
-	// becoming stuck in a boot-loop after multiple consecutive crashes.
-	Timeout int `default:"60" json:"timeout"`
-}
-
-type Backups struct {
-	// WriteLimit imposes a Disk I/O write limit on backups to the disk, this affects all
-	// backup drivers as the archiver must first write the file to the disk in order to
-	// upload it to any external storage provider.
-	//
-	// If the value is less than 1, the write speed is unlimited,
-	// if the value is greater than 0, the write speed is the value in MiB/s.
-	//
-	// Defaults to 0 (unlimited)
-	WriteLimit int `default:"0" yaml:"write_limit"`
-}
-
-type Transfers struct {
-	// DownloadLimit imposes a Network I/O read limit when downloading a transfer archive.
-	//
-	// If the value is less than 1, the write speed is unlimited,
-	// if the value is greater than 0, the write speed is the value in MiB/s.
-	//
-	// Defaults to 0 (unlimited)
-	DownloadLimit int `default:"0" yaml:"download_limit"`
-}
-
-// Ensures that all of the system directories exist on the system. These directories are
-// created so that only the owner can read the data, and no other users.
-func (sc *SystemConfiguration) ConfigureDirectories() error {
-	log.WithField("path", sc.RootDirectory).Debug("ensuring root data directory exists")
-	if err := os.MkdirAll(sc.RootDirectory, 0700); err != nil {
-		return err
-	}
-
-	// There are a non-trivial number of users out there whose data directories are actually a
-	// symlink to another location on the disk. If we do not resolve that final destination at this
-	// point things will appear to work, but endless errors will be encountered when we try to
-	// verify accessed paths since they will all end up resolving outside the expected data directory.
-	//
-	// For the sake of automating away as much of this as possible, see if the data directory is a
-	// symlink, and if so resolve to its final real path, and then update the configuration to use
-	// that.
-	if d, err := filepath.EvalSymlinks(sc.Data); err != nil {
-		if !os.IsNotExist(err) {
-			return err
-		}
-	} else if d != sc.Data {
-		sc.Data = d
-	}
-
-	log.WithField("path", sc.Data).Debug("ensuring server data directory exists")
-	if err := os.MkdirAll(sc.Data, 0700); err != nil {
-		return err
-	}
-
-	log.WithField("path", sc.ArchiveDirectory).Debug("ensuring archive data directory exists")
-	if err := os.MkdirAll(sc.ArchiveDirectory, 0700); err != nil {
-		return err
-	}
-
-	log.WithField("path", sc.BackupDirectory).Debug("ensuring backup data directory exists")
-	if err := os.MkdirAll(sc.BackupDirectory, 0700); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Writes a logrotate file for wings to the system logrotate configuration directory if one
-// exists and a logrotate file is not found. This allows us to basically automate away the log
-// rotation for most installs, but also enable users to make modifications on their own.
-func (sc *SystemConfiguration) EnableLogRotation() error {
-	// Do nothing if not enabled.
-	if sc.EnableLogRotate == false {
-		log.Info("skipping log rotate configuration, disabled in wings config file")
-
-		return nil
-	}
-
-	if st, err := os.Stat("/etc/logrotate.d"); err != nil && !os.IsNotExist(err) {
-		return err
-	} else if (err != nil && os.IsNotExist(err)) || !st.IsDir() {
-		return nil
-	}
-
-	if _, err := os.Stat("/etc/logrotate.d/wings"); err != nil && !os.IsNotExist(err) {
-		return err
-	} else if err == nil {
-		return nil
-	}
-
-	log.Info("no log rotation configuration found, system is configured to support it, adding file now")
-	// If we've gotten to this point it means the logrotate directory exists on the system
-	// but there is not a file for wings already. In that case, let us write a new file to
-	// it so files can be rotated easily.
-	f, err := os.Create("/etc/logrotate.d/wings")
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	t, err := template.New("logrotate").Parse(`
-{{.LogDirectory}}/wings.log {
-    size 10M
-    compress
-    delaycompress
-    dateext
-    maxage 7
-    missingok
-    notifempty
-    create 0640 {{.User.Uid}} {{.User.Gid}}
-    postrotate
-        killall -SIGHUP wings
-    endscript
-}`)
-
-	if err != nil {
-		return err
-	}
-
-	return errors.WithMessage(t.Execute(f, sc), "failed to write logrotate file to disk")
-}
-
-// Returns the location of the JSON file that tracks server states.
-func (sc *SystemConfiguration) GetStatesPath() string {
-	return path.Join(sc.RootDirectory, "states.json")
-}
-
-// Returns the location of the JSON file that tracks server states.
-func (sc *SystemConfiguration) GetInstallLogPath() string {
-	return path.Join(sc.LogDirectory, "install/")
-}
-
-// Configures the timezone data for the configuration if it is currently missing. If
-// a value has been set, this functionality will only run to validate that the timezone
-// being used is valid.
-func (sc *SystemConfiguration) ConfigureTimezone() error {
-	if sc.Timezone == "" {
-		if b, err := ioutil.ReadFile("/etc/timezone"); err != nil {
-			if !os.IsNotExist(err) {
-				return errors.WithMessage(err, "failed to open /etc/timezone for automatic server timezone calibration")
-			}
-
-			ctx, _ := context.WithTimeout(context.Background(), time.Second*5)
-			// Okay, file isn't found on this OS, we will try using timedatectl to handle this. If this
-			// command fails, exit, but if it returns a value use that. If no value is returned we will
-			// fall through to UTC to get Wings booted at least.
-			out, err := exec.CommandContext(ctx, "timedatectl").Output()
-			if err != nil {
-				log.WithField("error", err).Warn("failed to execute \"timedatectl\" to determine system timezone, falling back to UTC")
-
-				sc.Timezone = "UTC"
-				return nil
-			}
-
-			r := regexp.MustCompile(`Time zone: ([\w/]+)`)
-			matches := r.FindSubmatch(out)
-			if len(matches) != 2 || string(matches[1]) == "" {
-				log.Warn("failed to parse timezone from \"timedatectl\" output, falling back to UTC")
-
-				sc.Timezone = "UTC"
-				return nil
-			}
-
-			sc.Timezone = string(matches[1])
-		} else {
-			sc.Timezone = string(b)
-		}
-	}
-
-	sc.Timezone = regexp.MustCompile(`(?i)[^a-z_/]+`).ReplaceAllString(sc.Timezone, "")
-
-	_, err := time.LoadLocation(sc.Timezone)
-
-	return errors.WithMessage(err, fmt.Sprintf("the supplied timezone %s is invalid", sc.Timezone))
-}

config/config_throttles.go

@@ -1,27 +0,0 @@
-package config
-
-type ConsoleThrottles struct {
-	// Whether or not the throttler is enabled for this instance.
-	Enabled bool `json:"enabled" yaml:"enabled" default:"true"`
-
-	// The total number of lines that can be output in a given LineResetInterval period before
-	// a warning is triggered and counted against the server.
-	Lines uint64 `json:"lines" yaml:"lines" default:"2000"`
-
-	// The total number of throttle activations that can accumulate before a server is considered
-	// to be breaching and will be stopped. This value is decremented by one every DecayInterval.
-	MaximumTriggerCount uint64 `json:"maximum_trigger_count" yaml:"maximum_trigger_count" default:"5"`
-
-	// The amount of time after which the number of lines processed is reset to 0. This runs in
-	// a constant loop and is not affected by the current console output volumes. By default, this
-	// will reset the processed line count back to 0 every 100ms.
-	LineResetInterval uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
-
-	// The amount of time in milliseconds that must pass without an output warning being triggered
-	// before a throttle activation is decremented.
-	DecayInterval uint64 `json:"decay_interval" yaml:"decay_interval" default:"10000"`
-
-	// The amount of time that a server is allowed to be stopping for before it is terminated
-	// forcefully if it triggers output throttles.
-	StopGracePeriod uint `json:"stop_grace_period" yaml:"stop_grace_period" default:"15"`
-}

docker-compose.example.yml

@@ -22,6 +22,7 @@ services:
       - "/var/lib/pterodactyl/:/var/lib/pterodactyl/"
       - "/var/log/pterodactyl/:/var/log/pterodactyl/"
       - "/tmp/pterodactyl/:/tmp/pterodactyl/"
+      - "/etc/ssl/certs:/etc/ssl/certs:ro"
       # you may need /srv/daemon-data if you are upgrading from an old daemon
       #- "/srv/daemon-data/:/srv/daemon-data/"
       # Required for ssl if you use let's encrypt. uncomment to use.

environment/docker.go

@@ -5,113 +5,100 @@ import (
 	"strconv"
 	"sync"
 
+	"emperror.dev/errors"
 	"github.com/apex/log"
-
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
 	"github.com/pterodactyl/wings/config"
 )
 
-var _cmu sync.Mutex
+var _conce sync.Once
 var _client *client.Client
 
-// Return a Docker client to be used throughout the codebase. Once a client has been created it
-// will be returned for all subsequent calls to this function.
-func DockerClient() (*client.Client, error) {
-	_cmu.Lock()
-	defer _cmu.Unlock()
-
-	if _client != nil {
-		return _client, nil
-	}
-
-	_client, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-
-	return _client, err
+// Docker returns a docker client to be used throughout the codebase. Once a
+// client has been created it will be returned for all subsequent calls to this
+// function.
+func Docker() (*client.Client, error) {
+	var err error
+	_conce.Do(func() {
+		_client, err = client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	})
+	return _client, errors.Wrap(err, "environment/docker: could not create client")
 }
 
-// Configures the required network for the docker environment.
-func ConfigureDocker(c *config.DockerConfiguration) error {
+// ConfigureDocker configures the required network for the docker environment.
+func ConfigureDocker(ctx context.Context) error {
 	// Ensure the required docker network exists on the system.
-	cli, err := DockerClient()
+	cli, err := Docker()
 	if err != nil {
 		return err
 	}
 
-	resource, err := cli.NetworkInspect(context.Background(), c.Network.Name, types.NetworkInspectOptions{})
-	if err != nil && client.IsErrNotFound(err) {
-		log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
-		return createDockerNetwork(cli, c)
-	} else if err != nil {
-		log.WithField("error", err).Fatal("failed to create required docker network for containers")
-	}
-
-	switch resource.Driver {
-	case "host":
-		c.Network.Interface = "127.0.0.1"
-		c.Network.ISPN = false
-		return nil
-	case "overlay":
-	case "weavemesh":
-		c.Network.Interface = ""
-		c.Network.ISPN = true
-		return nil
-	default:
-		c.Network.ISPN = false
+	nw := config.Get().Docker.Network
+	resource, err := cli.NetworkInspect(ctx, nw.Name, types.NetworkInspectOptions{})
+	if err != nil {
+		if client.IsErrNotFound(err) {
+			log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
+			if err := createDockerNetwork(ctx, cli); err != nil {
+				return err
+			}
+		} else {
+			return err
+		}
 	}
 
+	config.Update(func(c *config.Configuration) {
+		c.Docker.Network.Driver = resource.Driver
+		switch c.Docker.Network.Driver {
+		case "host":
+			c.Docker.Network.Interface = "127.0.0.1"
+			c.Docker.Network.ISPN = false
+		case "overlay":
+			fallthrough
+		case "weavemesh":
+			c.Docker.Network.Interface = ""
+			c.Docker.Network.ISPN = true
+		default:
+			c.Docker.Network.ISPN = false
+		}
+	})
 	return nil
 }
 
 // Creates a new network on the machine if one does not exist already.
-func createDockerNetwork(cli *client.Client, c *config.DockerConfiguration) error {
-	_, err := cli.NetworkCreate(context.Background(), c.Network.Name, types.NetworkCreate{
-		Driver:     c.Network.Driver,
+func createDockerNetwork(ctx context.Context, cli *client.Client) error {
+	nw := config.Get().Docker.Network
+	_, err := cli.NetworkCreate(ctx, nw.Name, types.NetworkCreate{
+		Driver:     nw.Driver,
 		EnableIPv6: true,
-		Internal:   c.Network.IsInternal,
+		Internal:   nw.IsInternal,
 		IPAM: &network.IPAM{
-			Config: []network.IPAMConfig{
-				{
-					Subnet:  c.Network.Interfaces.V4.Subnet,
-					Gateway: c.Network.Interfaces.V4.Gateway,
-				},
-				{
-					Subnet:  c.Network.Interfaces.V6.Subnet,
-					Gateway: c.Network.Interfaces.V6.Gateway,
-				},
-			},
+			Config: []network.IPAMConfig{{
+				Subnet:  nw.Interfaces.V4.Subnet,
+				Gateway: nw.Interfaces.V4.Gateway,
+			}, {
+				Subnet:  nw.Interfaces.V6.Subnet,
+				Gateway: nw.Interfaces.V6.Gateway,
+			}},
 		},
 		Options: map[string]string{
 			"encryption": "false",
 			"com.docker.network.bridge.default_bridge":       "false",
-			"com.docker.network.bridge.enable_icc":           strconv.FormatBool(c.Network.EnableICC),
+			"com.docker.network.bridge.enable_icc":           strconv.FormatBool(nw.EnableICC),
 			"com.docker.network.bridge.enable_ip_masquerade": "true",
 			"com.docker.network.bridge.host_binding_ipv4":    "0.0.0.0",
 			"com.docker.network.bridge.name":                 "pterodactyl0",
 			"com.docker.network.driver.mtu":                  "1500",
 		},
 	})
-
 	if err != nil {
 		return err
 	}
-
-	switch c.Network.Driver {
-	case "host":
-		c.Network.Interface = "127.0.0.1"
-		c.Network.ISPN = false
-		break
-	case "overlay":
-	case "weavemesh":
-		c.Network.Interface = ""
-		c.Network.ISPN = true
-		break
-	default:
-		c.Network.Interface = c.Network.Interfaces.V4.Gateway
-		c.Network.ISPN = false
-		break
+	if nw.Driver != "host" && nw.Driver != "overlay" && nw.Driver != "weavemesh" {
+		config.Update(func(c *config.Configuration) {
+			c.Docker.Network.Interface = c.Docker.Network.Interfaces.V4.Gateway
+		})
 	}
-
 	return nil
 }

environment/docker/container.go

@@ -3,9 +3,14 @@ package docker
 import (
 	"bufio"
 	"context"
-	"emperror.dev/errors"
 	"encoding/json"
 	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
@@ -15,16 +20,9 @@ import (
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/system"
-	"io"
-	"strconv"
-	"strings"
-	"time"
 )
 
-type imagePullStatus struct {
-	Status   string `json:"status"`
-	Progress string `json:"progress"`
-}
+var ErrNotAttached = errors.Sentinel("not attached to instance")
 
 // A custom console writer that allows us to keep a function blocked until the
 // given stream is properly closed. This does nothing special, only exists to
@@ -38,14 +36,14 @@ func (nw noopWriter) Write(b []byte) (int, error) {
 	return len(b), nil
 }
 
-// Attaches to the docker container itself and ensures that we can pipe data in and out
-// of the process stream. This should not be used for reading console data as you *will*
-// miss important output at the beginning because of the time delay with attaching to the
-// output.
+// Attach attaches to the docker container itself and ensures that we can pipe
+// data in and out of the process stream. This should not be used for reading
+// console data as you *will* miss important output at the beginning because of
+// the time delay with attaching to the output.
 //
-// Calling this function will poll resources for the container in the background until the
-// provided context is canceled by the caller. Failure to cancel said context will cause
-// background memory leaks as the goroutine will not exit.
+// Calling this function will poll resources for the container in the background
+// until the provided context is canceled by the caller. Failure to cancel said
+// context will cause background memory leaks as the goroutine will not exit.
 func (e *Environment) Attach() error {
 	if e.IsAttached() {
 		return nil
@@ -108,27 +106,15 @@ func (e *Environment) Attach() error {
 	return nil
 }
 
-func (e *Environment) resources() container.Resources {
-	l := e.Configuration.Limits()
-
-	return container.Resources{
-		Memory:            l.BoundedMemoryLimit(),
-		MemoryReservation: l.MemoryLimit * 1_000_000,
-		MemorySwap:        l.ConvertedSwap(),
-		CPUQuota:          l.ConvertedCpuLimit(),
-		CPUPeriod:         100_000,
-		CPUShares:         1024,
-		BlkioWeight:       l.IoWeight,
-		OomKillDisable:    &l.OOMDisabled,
-		CpusetCpus:        l.Threads,
-	}
-}
-
-// Performs an in-place update of the Docker container's resource limits without actually
-// making any changes to the operational state of the container. This allows memory, cpu,
-// and IO limitations to be adjusted on the fly for individual instances.
+// InSituUpdate performs an in-place update of the Docker container's resource
+// limits without actually making any changes to the operational state of the
+// container. This allows memory, cpu, and IO limitations to be adjusted on the
+// fly for individual instances.
 func (e *Environment) InSituUpdate() error {
-	if _, err := e.client.ContainerInspect(context.Background(), e.Id); err != nil {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+	defer cancel()
+
+	if _, err := e.client.ContainerInspect(ctx, e.Id); err != nil {
 		// If the container doesn't exist for some reason there really isn't anything
 		// we can do to fix that in this process (it doesn't make sense at least). In those
 		// cases just return without doing anything since we still want to save the configuration
@@ -138,25 +124,24 @@ func (e *Environment) InSituUpdate() error {
 		if client.IsErrNotFound(err) {
 			return nil
 		}
-
-		return err
+		return errors.Wrap(err, "environment/docker: could not inspect container")
 	}
 
-	u := container.UpdateConfig{
+	// CPU pinning cannot be removed once it is applied to a container. The same is true
+	// for removing memory limits, a container must be re-created.
+	//
+	// @see https://github.com/moby/moby/issues/41946
+	if _, err := e.client.ContainerUpdate(ctx, e.Id, container.UpdateConfig{
 		Resources: e.resources(),
+	}); err != nil {
+		return errors.Wrap(err, "environment/docker: could not update container")
 	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
-	defer cancel()
-	if _, err := e.client.ContainerUpdate(ctx, e.Id, u); err != nil {
-		return err
-	}
-
 	return nil
 }
 
-// Creates a new container for the server using all of the data that is currently
-// available for it. If the container already exists it will be returnee.
+// Create creates a new container for the server using all of the data that is
+// currently available for it. If the container already exists it will be
+// returned.
 func (e *Environment) Create() error {
 	// If the container already exists don't hit the user with an error, just return
 	// the current information about it which is what we would do when creating the
@@ -164,12 +149,12 @@ func (e *Environment) Create() error {
 	if _, err := e.client.ContainerInspect(context.Background(), e.Id); err == nil {
 		return nil
 	} else if !client.IsErrNotFound(err) {
-		return err
+		return errors.Wrap(err, "environment/docker: failed to inspect container")
 	}
 
 	// Try to pull the requested image before creating the container.
 	if err := e.ensureImageExists(e.meta.Image); err != nil {
-		return err
+		return errors.WithStackIf(err)
 	}
 
 	a := e.Configuration.Allocations()
@@ -245,29 +230,14 @@ func (e *Environment) Create() error {
 	}
 
 	if _, err := e.client.ContainerCreate(context.Background(), conf, hostConf, nil, nil, e.Id); err != nil {
-		return err
+		return errors.Wrap(err, "environment/docker: failed to create container")
 	}
 
 	return nil
 }
 
-func (e *Environment) convertMounts() []mount.Mount {
-	var out []mount.Mount
-
-	for _, m := range e.Configuration.Mounts() {
-		out = append(out, mount.Mount{
-			Type:     mount.TypeBind,
-			Source:   m.Source,
-			Target:   m.Target,
-			ReadOnly: m.ReadOnly,
-		})
-	}
-
-	return out
-}
-
-// Remove the Docker container from the machine. If the container is currently running
-// it will be forcibly stopped by Docker.
+// Destroy will remove the Docker container from the server. If the container
+// is currently running it will be forcibly stopped by Docker.
 func (e *Environment) Destroy() error {
 	// We set it to stopping than offline to prevent crash detection from being triggered.
 	e.SetState(environment.ProcessStoppingState)
@@ -291,9 +261,55 @@ func (e *Environment) Destroy() error {
 	return err
 }
 
-// Attaches to the log for the container. This avoids us missing crucial output that
-// happens in the split seconds before the code moves from 'Starting' to 'Attaching'
-// on the process.
+// SendCommand sends the specified command to the stdin of the running container
+// instance. There is no confirmation that this data is sent successfully, only
+// that it gets pushed into the stdin.
+func (e *Environment) SendCommand(c string) error {
+	if !e.IsAttached() {
+		return errors.Wrap(ErrNotAttached, "environment/docker: cannot send command to container")
+	}
+
+	e.mu.RLock()
+	defer e.mu.RUnlock()
+
+	// If the command being processed is the same as the process stop command then we
+	// want to mark the server as entering the stopping state otherwise the process will
+	// stop and Wings will think it has crashed and attempt to restart it.
+	if e.meta.Stop.Type == "command" && c == e.meta.Stop.Value {
+		e.SetState(environment.ProcessStoppingState)
+	}
+
+	_, err := e.stream.Conn.Write([]byte(c + "\n"))
+
+	return errors.Wrap(err, "environment/docker: could not write to container stream")
+}
+
+// Readlog reads the log file for the server. This does not care if the server
+// is running or not, it will simply try to read the last X bytes of the file
+// and return them.
+func (e *Environment) Readlog(lines int) ([]string, error) {
+	r, err := e.client.ContainerLogs(context.Background(), e.Id, types.ContainerLogsOptions{
+		ShowStdout: true,
+		ShowStderr: true,
+		Tail:       strconv.Itoa(lines),
+	})
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer r.Close()
+
+	var out []string
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		out = append(out, scanner.Text())
+	}
+
+	return out, nil
+}
+
+// Attaches to the log for the container. This avoids us missing crucial output
+// that happens in the split seconds before the code moves from 'Starting' to
+// 'Attaching' on the process.
 func (e *Environment) followOutput() error {
 	if exists, err := e.Exists(); !exists {
 		if err != nil {
@@ -346,14 +362,19 @@ func (e *Environment) scanOutput(reader io.ReadCloser) {
 	go e.followOutput()
 }
 
-// Pulls the image from Docker. If there is an error while pulling the image from the source
-// but the image already exists locally, we will report that error to the logger but continue
-// with the process.
+type imagePullStatus struct {
+	Status   string `json:"status"`
+	Progress string `json:"progress"`
+}
+
+// Pulls the image from Docker. If there is an error while pulling the image
+// from the source but the image already exists locally, we will report that
+// error to the logger but continue with the process.
 //
-// The reasoning behind this is that Quay has had some serious outages as of late, and we don't
-// need to block all of the servers from booting just because of that. I'd imagine in a lot of
-// cases an outage shouldn't affect users too badly. It'll at least keep existing servers working
-// correctly if anything.
+// The reasoning behind this is that Quay has had some serious outages as of
+// late, and we don't need to block all of the servers from booting just because
+// of that. I'd imagine in a lot of cases an outage shouldn't affect users too
+// badly. It'll at least keep existing servers working correctly if anything.
 func (e *Environment) ensureImageExists(image string) error {
 	e.Events().Publish(environment.DockerImagePullStarted, "")
 	defer e.Events().Publish(environment.DockerImagePullCompleted, "")
@@ -399,7 +420,7 @@ func (e *Environment) ensureImageExists(image string) error {
 		if ierr != nil {
 			// Well damn, something has gone really wrong here, just go ahead and abort there
 			// isn't much anything we can do to try and self-recover from this.
-			return ierr
+			return errors.Wrap(ierr, "environment/docker: failed to list images")
 		}
 
 		for _, img := range images {
@@ -420,7 +441,7 @@ func (e *Environment) ensureImageExists(image string) error {
 			}
 		}
 
-		return err
+		return errors.Wrapf(err, "environment/docker: failed to pull \"%s\" image for server", image)
 	}
 	defer out.Close()
 
@@ -447,3 +468,34 @@ func (e *Environment) ensureImageExists(image string) error {
 
 	return nil
 }
+
+func (e *Environment) convertMounts() []mount.Mount {
+	var out []mount.Mount
+
+	for _, m := range e.Configuration.Mounts() {
+		out = append(out, mount.Mount{
+			Type:     mount.TypeBind,
+			Source:   m.Source,
+			Target:   m.Target,
+			ReadOnly: m.ReadOnly,
+		})
+	}
+
+	return out
+}
+
+func (e *Environment) resources() container.Resources {
+	l := e.Configuration.Limits()
+
+	return container.Resources{
+		Memory:            l.BoundedMemoryLimit(),
+		MemoryReservation: l.MemoryLimit * 1_000_000,
+		MemorySwap:        l.ConvertedSwap(),
+		CPUQuota:          l.ConvertedCpuLimit(),
+		CPUPeriod:         100_000,
+		CPUShares:         1024,
+		BlkioWeight:       l.IoWeight,
+		OomKillDisable:    &l.OOMDisabled,
+		CpusetCpus:        l.Threads,
+	}
+}

environment/docker/environment.go

@@ -2,20 +2,23 @@ package docker
 
 import (
 	"context"
+	"fmt"
+	"io"
+	"sync"
+
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/system"
-	"io"
-	"sync"
 )
 
 type Metadata struct {
 	Image string
-	Stop  api.ProcessStopConfiguration
+	Stop  remote.ProcessStopConfiguration
 }
 
 // Ensure that the Docker environment is always implementing all of the methods
@@ -51,11 +54,12 @@ type Environment struct {
 	st *system.AtomicString
 }
 
-// Creates a new base Docker environment. The ID passed through will be the ID that is used to
-// reference the container from here on out. This should be unique per-server (we use the UUID
-// by default). The container does not need to exist at this point.
+// New creates a new base Docker environment. The ID passed through will be the
+// ID that is used to reference the container from here on out. This should be
+// unique per-server (we use the UUID by default). The container does not need
+// to exist at this point.
 func New(id string, m *Metadata, c *environment.Configuration) (*Environment, error) {
-	cli, err := environment.DockerClient()
+	cli, err := environment.Docker()
 	if err != nil {
 		return nil, err
 	}
@@ -174,7 +178,7 @@ func (e *Environment) Config() *environment.Configuration {
 }
 
 // Sets the stop configuration for the environment.
-func (e *Environment) SetStopConfiguration(c api.ProcessStopConfiguration) {
+func (e *Environment) SetStopConfiguration(c remote.ProcessStopConfiguration) {
 	e.mu.Lock()
 	defer e.mu.Unlock()
 
@@ -187,3 +191,26 @@ func (e *Environment) SetImage(i string) {
 
 	e.meta.Image = i
 }
+
+func (e *Environment) State() string {
+	return e.st.Load()
+}
+
+// SetState sets the state of the environment. This emits an event that server's
+// can hook into to take their own actions and track their own state based on
+// the environment.
+func (e *Environment) SetState(state string) {
+	if state != environment.ProcessOfflineState &&
+		state != environment.ProcessStartingState &&
+		state != environment.ProcessRunningState &&
+		state != environment.ProcessStoppingState {
+		panic(errors.New(fmt.Sprintf("invalid server state received: %s", state)))
+	}
+
+	// Emit the event to any listeners that are currently registered.
+	if e.State() != state {
+		// If the state changed make sure we update the internal tracking to note that.
+		e.st.Store(state)
+		e.Events().Publish(environment.StateChangeEvent, state)
+	}
+}

environment/docker/power.go

@@ -2,16 +2,18 @@ package docker
 
 import (
 	"context"
+	"os"
+	"strings"
+	"syscall"
+	"time"
+
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/environment"
-	"os"
-	"strings"
-	"time"
+	"github.com/pterodactyl/wings/remote"
 )
 
 // Run before the container starts and get the process configuration from the Panel.
@@ -25,7 +27,7 @@ func (e *Environment) OnBeforeStart() error {
 	// Always destroy and re-create the server container to ensure that synced data from the Panel is used.
 	if err := e.client.ContainerRemove(context.Background(), e.Id, types.ContainerRemoveOptions{RemoveVolumes: true}); err != nil {
 		if !client.IsErrNotFound(err) {
-			return errors.WithMessage(err, "failed to remove server docker container during pre-boot")
+			return errors.WrapIf(err, "environment/docker: failed to remove container during pre-boot")
 		}
 	}
 
@@ -69,7 +71,7 @@ func (e *Environment) Start() error {
 		//
 		// @see https://github.com/pterodactyl/panel/issues/2000
 		if !client.IsErrNotFound(err) {
-			return err
+			return errors.WrapIf(err, "environment/docker: failed to inspect container")
 		}
 	} else {
 		// If the server is running update our internal state and continue on with the attach.
@@ -84,7 +86,7 @@ func (e *Environment) Start() error {
 		// to truncate them.
 		if _, err := os.Stat(c.LogPath); err == nil {
 			if err := os.Truncate(c.LogPath, 0); err != nil {
-				return err
+				return errors.Wrap(err, "environment/docker: failed to truncate instance logs")
 			}
 		}
 	}
@@ -99,14 +101,14 @@ func (e *Environment) Start() error {
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
 	if err := e.OnBeforeStart(); err != nil {
-		return err
+		return errors.WithStackIf(err)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
 	if err := e.client.ContainerStart(ctx, e.Id, types.ContainerStartOptions{}); err != nil {
-		return err
+		return errors.WrapIf(err, "environment/docker: failed to start container")
 	}
 
 	// No errors, good to continue through.
@@ -115,23 +117,40 @@ func (e *Environment) Start() error {
 	return e.Attach()
 }
 
-// Stops the container that the server is running in. This will allow up to 30 seconds to pass
-// before the container is forcefully terminated if we are trying to stop it without using a command
-// sent into the instance.
+// Stop stops the container that the server is running in. This will allow up to
+// 30 seconds to pass before the container is forcefully terminated if we are
+// trying to stop it without using a command sent into the instance.
 //
-// You most likely want to be using WaitForStop() rather than this function, since this will return
-// as soon as the command is sent, rather than waiting for the process to be completed stopped.
+// You most likely want to be using WaitForStop() rather than this function,
+// since this will return as soon as the command is sent, rather than waiting
+// for the process to be completed stopped.
+//
+// TODO: pass context through from the server instance.
 func (e *Environment) Stop() error {
 	e.mu.RLock()
 	s := e.meta.Stop
 	e.mu.RUnlock()
 
-	if s.Type == "" || s.Type == api.ProcessStopSignal {
+	// A native "stop" as the Type field value will just skip over all of this
+	// logic and end up only executing the container stop command (which may or
+	// may not work as expected).
+	if s.Type == "" || s.Type == remote.ProcessStopSignal {
 		if s.Type == "" {
 			log.WithField("container_id", e.Id).Warn("no stop configuration detected for environment, using termination procedure")
 		}
 
-		return e.Terminate(os.Kill)
+		signal := os.Kill
+		// Handle a few common cases, otherwise just fall through and just pass along
+		// the os.Kill signal to the process.
+		switch strings.ToUpper(s.Value) {
+		case "SIGABRT":
+			signal = syscall.SIGABRT
+		case "SIGINT":
+			signal = syscall.SIGINT
+		case "SIGTERM":
+			signal = syscall.SIGTERM
+		}
+		return e.Terminate(signal)
 	}
 
 	// If the process is already offline don't switch it back to stopping. Just leave it how
@@ -142,31 +161,29 @@ func (e *Environment) Stop() error {
 
 	// Only attempt to send the stop command to the instance if we are actually attached to
 	// the instance. If we are not for some reason, just send the container stop event.
-	if e.IsAttached() && s.Type == api.ProcessStopCommand {
+	if e.IsAttached() && s.Type == remote.ProcessStopCommand {
 		return e.SendCommand(s.Value)
 	}
 
 	t := time.Second * 30
-
 	if err := e.client.ContainerStop(context.Background(), e.Id, &t); err != nil {
 		// If the container does not exist just mark the process as stopped and return without
 		// an error.
 		if client.IsErrNotFound(err) {
 			e.SetStream(nil)
 			e.SetState(environment.ProcessOfflineState)
-
 			return nil
 		}
-
-		return err
+		return errors.Wrap(err, "environment/docker: cannot stop container")
 	}
 
 	return nil
 }
 
-// Attempts to gracefully stop a server using the defined stop command. If the server
-// does not stop after seconds have passed, an error will be returned, or the instance
-// will be terminated forcefully depending on the value of the second argument.
+// WaitForStop attempts to gracefully stop a server using the defined stop
+// command. If the server does not stop after seconds have passed, an error will
+// be returned, or the instance will be terminated forcefully depending on the
+// value of the second argument.
 func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 	if err := e.Stop(); err != nil {
 		return err
@@ -191,7 +208,9 @@ func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 			return ctxErr
 		}
 	case err := <-errChan:
-		if err != nil {
+		// If the error stems from the container not existing there is no point in wasting
+		// CPU time to then try and terminate it.
+		if err != nil && !client.IsErrNotFound(err) {
 			if terminate {
 				l := log.WithField("container_id", e.Id)
 				if errors.Is(err, context.DeadlineExceeded) {
@@ -202,8 +221,7 @@ func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 
 				return e.Terminate(os.Kill)
 			}
-
-			return err
+			return errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
 		}
 	case <-ok:
 	}
@@ -211,11 +229,16 @@ func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 	return nil
 }
 
-// Forcefully terminates the container using the signal passed through.
+// Terminate forcefully terminates the container using the signal provided.
 func (e *Environment) Terminate(signal os.Signal) error {
 	c, err := e.client.ContainerInspect(context.Background(), e.Id)
 	if err != nil {
-		return err
+		// Treat missing containers as an okay error state, means it is obviously
+		// already terminated at this point.
+		if client.IsErrNotFound(err) {
+			return nil
+		}
+		return errors.WithStack(err)
 	}
 
 	if !c.State.Running {
@@ -232,13 +255,10 @@ func (e *Environment) Terminate(signal os.Signal) error {
 
 	// We set it to stopping than offline to prevent crash detection from being triggered.
 	e.SetState(environment.ProcessStoppingState)
-
 	sig := strings.TrimSuffix(strings.TrimPrefix(signal.String(), "signal "), "ed")
-
 	if err := e.client.ContainerKill(context.Background(), e.Id, sig); err != nil && !client.IsErrNotFound(err) {
-		return err
+		return errors.WithStack(err)
 	}
-
 	e.SetState(environment.ProcessOfflineState)
 
 	return nil

environment/docker/state.go

@@ -1,29 +0,0 @@
-package docker
-
-import (
-	"emperror.dev/errors"
-	"fmt"
-	"github.com/pterodactyl/wings/environment"
-)
-
-func (e *Environment) State() string {
-	return e.st.Load()
-}
-
-// Sets the state of the environment. This emits an event that server's can hook into to
-// take their own actions and track their own state based on the environment.
-func (e *Environment) SetState(state string) {
-	if state != environment.ProcessOfflineState &&
-		state != environment.ProcessStartingState &&
-		state != environment.ProcessRunningState &&
-		state != environment.ProcessStoppingState {
-		panic(errors.New(fmt.Sprintf("invalid server state received: %s", state)))
-	}
-
-	// Emit the event to any listeners that are currently registered.
-	if e.State() != state {
-		// If the state changed make sure we update the internal tracking to note that.
-		e.st.Store(state)
-		e.Events().Publish(environment.StateChangeEvent, state)
-	}
-}

environment/docker/stream.go

@@ -1,100 +0,0 @@
-package docker
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"emperror.dev/errors"
-	"encoding/json"
-	"github.com/docker/docker/api/types"
-	"github.com/pterodactyl/wings/environment"
-	"strconv"
-)
-
-type dockerLogLine struct {
-	Log string `json:"log"`
-}
-
-var ErrNotAttached = errors.New("not attached to instance")
-
-func (e *Environment) setStream(s *types.HijackedResponse) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	e.stream = s
-}
-
-// Sends the specified command to the stdin of the running container instance. There is no
-// confirmation that this data is sent successfully, only that it gets pushed into the stdin.
-func (e *Environment) SendCommand(c string) error {
-	if !e.IsAttached() {
-		return ErrNotAttached
-	}
-
-	e.mu.RLock()
-	defer e.mu.RUnlock()
-
-	// If the command being processed is the same as the process stop command then we want to mark
-	// the server as entering the stopping state otherwise the process will stop and Wings will think
-	// it has crashed and attempt to restart it.
-	if e.meta.Stop.Type == "command" && c == e.meta.Stop.Value {
-		e.SetState(environment.ProcessStoppingState)
-	}
-
-	_, err := e.stream.Conn.Write([]byte(c + "\n"))
-
-	return err
-}
-
-// Reads the log file for the server. This does not care if the server is running or not, it will
-// simply try to read the last X bytes of the file and return them.
-func (e *Environment) Readlog(lines int) ([]string, error) {
-	r, err := e.client.ContainerLogs(context.Background(), e.Id, types.ContainerLogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Tail:       strconv.Itoa(lines),
-	})
-	if err != nil {
-		return nil, err
-	}
-	defer r.Close()
-
-	var out []string
-
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		out = append(out, scanner.Text())
-	}
-
-	return out, nil
-}
-
-// Docker stores the logs for server output in a JSON format. This function will iterate over the JSON
-// that was read from the log file and parse it into a more human readable format.
-func (e *Environment) parseLogToStrings(b []byte) ([]string, error) {
-	hasError := false
-	var out []string
-
-	scanner := bufio.NewScanner(bytes.NewReader(b))
-	for scanner.Scan() {
-		var l dockerLogLine
-
-		// Unmarshal the contents and allow up to a single error before bailing out of the process. We
-		// do this because if you're arbitrarily reading a length of the file you'll likely end up
-		// with the first line in the output being improperly formatted JSON. In those cases we want to
-		// just skip over it. However if we see another error we're going to bail out because that is an
-		// abnormal situation.
-		if err := json.Unmarshal([]byte(scanner.Text()), &l); err != nil {
-			if hasError {
-				return nil, err
-			}
-
-			hasError = true
-			continue
-		}
-
-		out = append(out, l.Log)
-	}
-
-	return out, nil
-}

go.mod

@@ -1,6 +1,6 @@
 module github.com/pterodactyl/wings
 
-go 1.13
+go 1.14
 
 require (
 	emperror.dev/errors v0.8.0
@@ -63,7 +63,7 @@ require (
 	github.com/sabhiram/go-gitignore v0.0.0-20201211210132-54b8a0bf510f
 	github.com/sirupsen/logrus v1.7.0 // indirect
 	github.com/spf13/cobra v1.1.1
-	github.com/spf13/pflag v1.0.5
+	github.com/stretchr/testify v1.6.1
 	github.com/ugorji/go v1.2.2 // indirect
 	github.com/ulikunitz/xz v0.5.9 // indirect
 	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad

go.sum

@@ -17,7 +17,6 @@ github.com/AlecAivazis/survey/v2 v2.2.7 h1:5NbxkF4RSKmpywYdcRgUmos1o+roJY8duCLZX
 github.com/AlecAivazis/survey/v2 v2.2.7/go.mod h1:9DYvHgXtiXm6nCn+jXnOXLKbH+Yo9u8fAS/SduGdoPk=
 github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 h1:w+iIsaOQNcT7OZ575w+acHgRric5iCyQh+xv+KJ4HB8=
 github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/Jeffail/gabs/v2 v2.6.0 h1:WdCnGaDhNa4LSRTMwhLZzJ7SRDXjABNP13SOKvCpL5w=
@@ -42,7 +41,6 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/andybalholm/brotli v1.0.0 h1:7UCwP93aiSfvWpapti8g88vVVGp2qqtGyePsSuDafo4=
 github.com/andybalholm/brotli v1.0.0/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
 github.com/andybalholm/brotli v1.0.1 h1:KqhlKozYbRtJvsPrrEeXcO+N2l6NYT5A2QAFmSULpEc=
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
@@ -63,7 +61,6 @@ github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQ
 github.com/aws/aws-sdk-go v1.20.6/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
 github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
-github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59 h1:WWB576BN5zNSZc/M9d/10pqEx5VHNhaQ/yOVAkmj5Yo=
 github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
 github.com/beevik/etree v1.1.0 h1:T0xke/WvNtMoCqgzPhkX2r4rjY3GDZFi+FjpRZY2Jbs=
 github.com/beevik/etree v1.1.0/go.mod h1:r8Aw8JqVegEf0w2fDnATrX9VpkMcyFeM0FhwO62wh+A=
@@ -146,7 +143,6 @@ github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymF
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
@@ -154,13 +150,11 @@ github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVB
 github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd h1:b/30UOB56Rhfe185ZfgvZT0/HOql0OzxuiNOxRKXRXc=
 github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd/go.mod h1:VzmDKDJVZI3aJmnRI9VjAn9nJ8qPPsN1fqzr9dqInIo=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/gabriel-vasile/mimetype v1.1.2 h1:gaPnPcNor5aZSVCJVSGipcpbgMWiAAj9z182ocSGbHU=
 github.com/gabriel-vasile/mimetype v1.1.2/go.mod h1:6CDPel/o/3/s4+bp6kIbsWATq8pmgOisOPG40CJa6To=
-github.com/gammazero/deque v0.0.0-20200721202602-07291166fe33 h1:UG4wNrJX9xSKnm/Gck5yTbxnOhpNleuE4MQRdmcGySo=
 github.com/gammazero/deque v0.0.0-20200721202602-07291166fe33/go.mod h1:D90+MBHVc9Sk1lJAbEVgws0eYEurY4mv2TDso3Nxh3w=
 github.com/gammazero/deque v0.0.0-20201010052221-3932da5530cc h1:F7BbnLACph7UYiz9ZHi6npcROwKaZUyviDjsNERsoMM=
 github.com/gammazero/deque v0.0.0-20201010052221-3932da5530cc/go.mod h1:IlBLfYXnuw9sspy1XS6ctu5exGb6WHGKQsyo4s7bOEA=
@@ -168,7 +162,6 @@ github.com/gammazero/workerpool v1.1.1 h1:MN29GcZtZZAgzTU+Zk54Y+J9XkE54MoXON/NCZ
 github.com/gammazero/workerpool v1.1.1/go.mod h1:5BN0IJVRjSFAypo9QTJCaWdijjNz9Jjl6VFS1PRjCeg=
 github.com/gbrlsnchs/jwt/v3 v3.0.0 h1:gtPjdT3gAbBLjVckJsgNf+a46sqrCBfRebg2r/NysIo=
 github.com/gbrlsnchs/jwt/v3 v3.0.0/go.mod h1:AncDcjXz18xetI3A6STfXq2w+LuTx8pQ8bGEwRN8zVM=
-github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
@@ -179,7 +172,6 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
@@ -188,7 +180,6 @@ github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8c
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
 github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
@@ -198,7 +189,6 @@ github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5x
 github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
@@ -209,7 +199,6 @@ github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4er
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -220,12 +209,10 @@ github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrU
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.2 h1:aeE13tS0IiQgFjYdoL8qN3K1N2bXXtI6Vi51/y7BpMw=
 github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -233,10 +220,8 @@ github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Z
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
@@ -246,7 +231,6 @@ github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OI
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -310,7 +294,6 @@ github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
 github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
@@ -319,7 +302,6 @@ github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/juju/ratelimit v1.0.1 h1:+7AIFJVQ0EQgq/K9+0Krm7m530Du7tIz0METWzN0RgY=
 github.com/juju/ratelimit v1.0.1/go.mod h1:qapgC/Gy+xNh9UxzV13HGGl/6UXNN+ct+vwSgWNm/qk=
-github.com/julienschmidt/httprouter v1.2.0 h1:TDTW5Yz1mjftljbcKqRcrYhd4XeOoI98t+9HbQbYf7g=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/karrick/godirwalk v1.16.1 h1:DynhcF+bztK8gooS0+NDJFrdNZjJ3gzVzC545UNA9iw=
@@ -330,24 +312,19 @@ github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvW
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
-github.com/klauspost/compress v1.10.10 h1:a/y8CglcM7gLGYmlbP/stPE5sR3hbhFRUjCBfd/0B3I=
 github.com/klauspost/compress v1.10.10/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.4 h1:kz40R/YWls3iqT9zX9AHN3WoVsrAWVyui5sxuLqiXqU=
 github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
-github.com/klauspost/pgzip v1.2.4 h1:TQ7CNpYKovDOmqzRHKxJh0BeaBI7UdQZYc6p7pMQh1A=
 github.com/klauspost/pgzip v1.2.4/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/klauspost/pgzip v1.2.5 h1:qnWYvvKqedOF2ulHpMG72XQol4ILEJ8k2wwRl/Km8oE=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -355,24 +332,20 @@ github.com/kr/pty v1.1.4 h1:5Myjjh3JY/NaAi4IsUbHADytDyl1VE1Y9PXDlL+P/VQ=
 github.com/kr/pty v1.1.4/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
 github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
 github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
 github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
-github.com/magefile/mage v1.9.0 h1:t3AU2wNwehMCW97vuqQLtw6puppWXHO+O2MHo5a50XE=
 github.com/magefile/mage v1.9.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
 github.com/magefile/mage v1.10.0 h1:3HiXzCUY12kh9bIuyXShaVe529fJfyqoVM42o/uom2g=
 github.com/magefile/mage v1.10.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
-github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.4 h1:8KGKTcQQGm0Kv7vEbKFErAoAOFyyacLStRtQSeYtvkY=
 github.com/magiconair/properties v1.8.4/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
@@ -385,7 +358,6 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
 github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQE9x6ikvDFZS2mDVS3drnohI=
 github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
@@ -459,13 +431,10 @@ github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9
 github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pierrec/lz4/v4 v4.0.3 h1:vNQKSVZNYUEAvRY9FaUXAF1XPbSOHJtDTiP41kzDz2E=
 github.com/pierrec/lz4/v4 v4.0.3/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pierrec/lz4/v4 v4.1.2 h1:qvY3YFXRQE/XB8MlLzJH7mSzBs74eA2gg52YTk6jUPM=
 github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -481,16 +450,13 @@ github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP
 github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
 github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.1.0 h1:BQ53HtBmfOitExawJ6LokA4x8ov/z0SYYb0+HxJfRI8=
 github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
 github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
-github.com/prometheus/client_golang v1.7.1 h1:NTGy1Ja9pByO+xAeH/qiWnLrKtr3hJPNjaVUwnjpdpA=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.9.0 h1:Rrch9mh17XcxvEu9D9DEpb4isxjGBtcevQjKvxPRQIU=
 github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -500,7 +466,6 @@ github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7q
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.6.0 h1:kRhiuYSXR3+uv2IbVbZhUxK5zVD/2pp3Gd2PpvPkpEo=
 github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
 github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
@@ -511,10 +476,8 @@ github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.0.3 h1:CTwfnzjQ+8dS6MhHHu4YswVAD99sL2wjPqP+VkURmKE=
 github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
-github.com/prometheus/procfs v0.1.3 h1:F0+tqvhOksq22sc6iCHF5WGlWjdwj92p0udFh1VFBS8=
 github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.2.0 h1:wH4vA7pcjKuZzjF7lM8awk4fnuJO6idemZXoKnULUx4=
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
@@ -531,15 +494,12 @@ github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/sirupsen/logrus v1.7.0 h1:ShrD1U9pZB12TX0cVy0DtePoCH97K8EtX+mg7ZARUtM=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/assertions v1.0.0 h1:UVQPSSmc3qtTi+zPPkCXvZX9VvW/xT/NsRvKfwY81a8=
 github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
@@ -557,7 +517,6 @@ github.com/spf13/cobra v1.1.1 h1:KfztREH0tPxJJ+geloSLaAkaPkr4ki2Er5quFV1TDo4=
 github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -570,34 +529,27 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
-github.com/tj/assert v0.0.0-20171129193455-018094318fb0 h1:Rw8kxzWo1mr6FSaYXjQELRe88y2KdfynXdnK72rdjtA=
 github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
 github.com/tj/assert v0.0.3 h1:Df/BlaZ20mq6kuai7f5z2TvPFiwC3xaWJSDQNiIS3Rk=
 github.com/tj/assert v0.0.3/go.mod h1:Ne6X72Q+TB1AteidzQncjw9PabbMp4PBMZ1k+vd1Pvk=
 github.com/tj/go-buffer v1.1.0/go.mod h1:iyiJpfFcR2B9sXu7KvjbT9fpM4mOelRSDTbntVj52Uc=
 github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
 github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
-github.com/tj/go-spin v1.1.0 h1:lhdWZsvImxvZ3q1C5OIB7d72DuOwP4O2NdBg9PyzNds=
 github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
-github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go v1.2.2 h1:60ZHIOcsJlo3bJm9CbTVu7OSqT2mxaEmyQbK2NwCkn0=
 github.com/ugorji/go v1.2.2/go.mod h1:bitgyERdV7L7Db/Z5gfd5v2NQMNhhiFiZwpgMw2SP7k=
-github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
 github.com/ugorji/go/codec v1.2.2 h1:08Gah8d+dXj4cZNUHhtuD/S4PXD5WpVbj5B8/ClELAQ=
 github.com/ugorji/go/codec v1.2.2/go.mod h1:OM8g7OAy52uYl3Yk+RE/3AS1nXFn1Wh4PPLtupCxbuU=
-github.com/ulikunitz/xz v0.5.6 h1:jGHAfXawEGZQ3blwU5wnWKQJvAraT7Ftq9EXjnXYgt8=
 github.com/ulikunitz/xz v0.5.6/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
-github.com/ulikunitz/xz v0.5.7 h1:YvTNdFzX6+W5m9msiYg/zpkSURPPtOlzbqYjrFn7Yt4=
 github.com/ulikunitz/xz v0.5.7/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.9 h1:RsKRIA2MO8x56wkkcd3LbtcE/uMszhb6DpRf+3uwa3I=
 github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
@@ -615,18 +567,15 @@ go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.uber.org/atomic v1.3.2 h1:2Oa65PReHzfn29GpvgsYwloV9AVFHPDk8tYxt2c2tr4=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
-go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
 go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
@@ -657,7 +606,6 @@ golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
@@ -689,13 +637,11 @@ golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a h1:DcqTD9SDLc+1P/r1EmRBwnVsrOwW+kk2vWf9n+1sGhs=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -732,7 +678,6 @@ golang.org/x/sys v0.0.0-20200120151820-655fe14d7479/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae h1:Ih9Yo4hSPImZOpfGuA4bR/ORKTAbhZo2AbWNRCnevdo=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -741,22 +686,17 @@ golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201223074533-0d417f636930 h1:vRgIt+nup/B/BwIS0g2oC0haq0iqbV3ZA+u6+0TlNCo=
 golang.org/x/sys v0.0.0-20201223074533-0d417f636930/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf h1:MZ2shdL+ZM/XzY3ZGOnh4Nlpnxz5GSOhOmtHo3iPU6M=
 golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4 h1:0YWbFKbhXG/wIiuHDSKpS0Iy7FSA+u45VtBMfQcFTTc=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 h1:Hir2P/De0WpUhtrKGGjvSb2YxUgyZ7EFOSLIcSSpiwE=
@@ -783,14 +723,11 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20190927191325-030b2cf1153e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5 h1:hKsoRgsbwY1NafxrwTs+k64bikrLBkAgPir1TNCj3Zs=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -805,7 +742,6 @@ google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -823,7 +759,6 @@ google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.0 h1:G+97AoqBnmZIT91cLG/EkCoK9NSelj64P8bOHHNmGn0=
 google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
@@ -842,13 +777,11 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi
 google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0 h1:UhZDfRO8JRQru4/+LlLE0BRKGF8L+PICnvYZmx/fEGA=
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
@@ -865,13 +798,10 @@ gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWD
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
@@ -887,7 +817,6 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=

installer/installer.go

@@ -1,13 +1,14 @@
 package installer
 
 import (
+	"context"
 	"encoding/json"
 
 	"emperror.dev/errors"
 	"github.com/asaskevich/govalidator"
 	"github.com/buger/jsonparser"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
 )
 
@@ -15,10 +16,10 @@ type Installer struct {
 	server *server.Server
 }
 
-// Validates the received data to ensure that all of the required fields
+// New validates the received data to ensure that all of the required fields
 // have been passed along in the request. This should be manually run before
 // calling Execute().
-func New(data []byte) (*Installer, error) {
+func New(ctx context.Context, manager *server.Manager, data []byte) (*Installer, error) {
 	if !govalidator.IsUUIDv4(getString(data, "uuid")) {
 		return nil, NewValidationError("uuid provided was not in a valid format")
 	}
@@ -44,50 +45,49 @@ func New(data []byte) (*Installer, error) {
 
 	// Unmarshal the environment variables from the request into the server struct.
 	if b, _, _, err := jsonparser.Get(data, "environment"); err != nil {
-		return nil, err
+		return nil, errors.WithStackIf(err)
 	} else {
 		cfg.EnvVars = make(environment.Variables)
 		if err := json.Unmarshal(b, &cfg.EnvVars); err != nil {
-			return nil, err
+			return nil, errors.WrapIf(err, "installer: could not unmarshal environment variables for server")
 		}
 	}
 
 	// Unmarshal the allocation mappings from the request into the server struct.
 	if b, _, _, err := jsonparser.Get(data, "allocations", "mappings"); err != nil {
-		return nil, err
+		return nil, errors.WithStackIf(err)
 	} else {
 		cfg.Allocations.Mappings = make(map[string][]int)
 		if err := json.Unmarshal(b, &cfg.Allocations.Mappings); err != nil {
-			return nil, err
+			return nil, errors.Wrap(err, "installer: could not unmarshal allocation mappings")
 		}
 	}
 
 	cfg.Container.Image = getString(data, "container", "image")
 
-	c, err := api.New().GetServerConfiguration(cfg.Uuid)
+	c, err := manager.Client().GetServerConfiguration(ctx, cfg.Uuid)
 	if err != nil {
-		if !api.IsRequestError(err) {
-			return nil, err
+		if !remote.IsRequestError(err) {
+			return nil, errors.WithStackIf(err)
 		}
-
-		return nil, errors.New(err.Error())
+		return nil, errors.WrapIf(err, "installer: could not get server configuration from remote API")
 	}
 
 	// Create a new server instance using the configuration we wrote to the disk
 	// so that everything gets instantiated correctly on the struct.
-	s, err := server.FromConfiguration(c)
-
-	return &Installer{
-		server: s,
-	}, err
+	s, err := manager.InitServer(c)
+	if err != nil {
+		return nil, errors.WrapIf(err, "installer: could not init server instance")
+	}
+	return &Installer{server: s}, nil
 }
 
-// Returns the UUID associated with this installer instance.
+// Uuid returns the UUID associated with this installer instance.
 func (i *Installer) Uuid() string {
 	return i.server.Id()
 }
 
-// Return the server instance.
+// Server returns the server instance.
 func (i *Installer) Server() *server.Server {
 	return i.server
 }

parser/parser.go

@@ -30,6 +30,45 @@ const (
 	Xml        = "xml"
 )
 
+type ReplaceValue struct {
+	value     []byte
+	valueType jsonparser.ValueType
+}
+
+// Value returns the underlying value of the replacement. Be aware that this
+// can include escaped UTF-8 sequences that will need to be handled by the caller
+// in order to avoid accidentally injecting invalid sequences into the running
+// process.
+//
+// For example the expected value may be "§Foo" but you'll be working directly
+// with "\u00a7FOo" for this value. This will cause user pain if not solved since
+// that is clearly not the value they were expecting to be using.
+func (cv *ReplaceValue) Value() []byte {
+	return cv.value
+}
+
+// Type returns the underlying data type for the Value field.
+func (cv *ReplaceValue) Type() jsonparser.ValueType {
+	return cv.valueType
+}
+
+// String returns the value as a string representation. This will automatically
+// handle casting the UTF-8 sequence into the expected value, switching something
+// like "\u00a7Foo" into "§Foo".
+func (cv *ReplaceValue) String() string {
+	if cv.Type() != jsonparser.String {
+		if cv.Type() == jsonparser.Null {
+			return "<nil>"
+		}
+		return "<invalid>"
+	}
+	str, err := jsonparser.ParseString(cv.value)
+	if err != nil {
+		panic(errors.Wrap(err, "parser: could not parse value"))
+	}
+	return str
+}
+
 type ConfigurationParser string
 
 func (cp ConfigurationParser) String() string {
@@ -77,15 +116,16 @@ func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Defines a single find/replace instance for a given server configuration file.
+// ConfigurationFileReplacement defines a single find/replace instance for a
+// given server configuration file.
 type ConfigurationFileReplacement struct {
 	Match       string       `json:"match"`
 	IfValue     string       `json:"if_value"`
 	ReplaceWith ReplaceValue `json:"replace_with"`
 }
 
-// Handles unmarshaling the JSON representation into a struct that provides more useful
-// data to this functionality.
+// UnmarshalJSON handles unmarshaling the JSON representation into a struct that
+// provides more useful data to this functionality.
 func (cfr *ConfigurationFileReplacement) UnmarshalJSON(data []byte) error {
 	m, err := jsonparser.GetString(data, "match")
 	if err != nil {
@@ -410,48 +450,66 @@ func (f *ConfigurationFile) parseTextFile(path string) error {
 	return nil
 }
 
-// Parses a properties file and updates the values within it to match those that
-// are passed. Writes the file once completed.
+// parsePropertiesFile parses a properties file and updates the values within it
+// to match those that are passed. Once completed the new file is written to the
+// disk. This will cause comments not present at the head of the file to be
+// removed unfortunately.
+//
+// Any UTF-8 value will be written back to the disk as their escaped value rather
+// than the raw value There is no winning with this logic. This fixes a bug where
+// users with hand rolled UTF-8 escape sequences would have all sorts of pain in
+// their configurations because we were writing the UTF-8 literal characters which
+// their games could not actually handle.
+//
+// However, by adding this fix to only store the escaped UTF-8 sequence we
+// unwittingly introduced a "regression" that causes _other_ games to have issues
+// because they can only handle the unescaped representations. I cannot think of
+// a simple approach to this problem that doesn't just lead to more complicated
+// cases and problems.
+//
+// So, if your game cannot handle parsing UTF-8 sequences that are escaped into
+// the string, well, sucks. There are fewer of those games than there are games
+// that have issues parsing the raw UTF-8 sequence into a string? Also how does
+// one really know what the user intended at this point? We'd need to know if
+// the value was escaped or not to begin with before setting it, which I suppose
+// can work but jesus that is going to be some annoyingly complicated logic?
+//
+// @see https://github.com/pterodactyl/panel/issues/2308 (original)
+// @see https://github.com/pterodactyl/panel/issues/3009 ("bug" introduced as result)
 func (f *ConfigurationFile) parsePropertiesFile(path string) error {
-	// Open the file.
-	f2, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-
 	var s strings.Builder
-
-	// Get any header comments from the file.
-	scanner := bufio.NewScanner(f2)
-	for scanner.Scan() {
-		text := scanner.Text()
-		if len(text) > 0 && text[0] != '#' {
-			break
+	// Open the file and attempt to load any comments that currenty exist at the start
+	// of the file. This is kind of a hack, but should work for a majority of users for
+	// the time being.
+	if fd, err := os.Open(path); err != nil {
+		return errors.Wrap(err, "parser: could not open file for reading")
+	} else {
+		scanner := bufio.NewScanner(fd)
+		// Scan until we hit a line that is not a comment that actually has content
+		// on it. Keep appending the comments until that time.
+		for scanner.Scan() {
+			text := scanner.Text()
+			if len(text) > 0 && text[0] != '#' {
+				break
+			}
+			s.WriteString(text + "\n")
+		}
+		_ = fd.Close()
+		if err := scanner.Err(); err != nil {
+			return errors.WithStackIf(err)
 		}
-
-		s.WriteString(text)
-		s.WriteString("\n")
 	}
 
-	// Close the file.
-	_ = f2.Close()
-
-	// Handle any scanner errors.
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
-	// Decode the properties file.
 	p, err := properties.LoadFile(path, properties.UTF8)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "parser: could not load properties file for configuration update")
 	}
 
 	// Replace any values that need to be replaced.
 	for _, replace := range f.Replace {
 		data, err := f.LookupConfigurationValue(replace)
 		if err != nil {
-			return err
+			return errors.Wrap(err, "parser: failed to lookup configuration value")
 		}
 
 		v, ok := p.Get(replace.Match)
@@ -463,7 +521,7 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 		}
 
 		if _, _, err := p.Set(replace.Match, data); err != nil {
-			return err
+			return errors.Wrap(err, "parser: failed to set replacement value")
 		}
 	}
 
@@ -473,11 +531,11 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 		if !ok {
 			continue
 		}
-
-		s.WriteString(key)
-		s.WriteByte('=')
-		s.WriteString(strings.Trim(strconv.QuoteToASCII(value), `"`))
-		s.WriteString("\n")
+		// This escape is intentional!
+		//
+		// See the docblock for this function for more details, do not change this
+		// or you'll cause a flood of new issue reports no one wants to deal with.
+		s.WriteString(key + "=" + strings.Trim(strconv.QuoteToASCII(value), "\"") + "\n")
 	}
 
 	// Open the file for writing.
@@ -489,7 +547,7 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 
 	// Write the data to the file.
 	if _, err := w.Write([]byte(s.String())); err != nil {
-		return err
+		return errors.Wrap(err, "parser: failed to write properties file to disk")
 	}
 
 	return nil

parser/value.go

@@ -1,24 +0,0 @@
-package parser
-
-import (
-	"github.com/buger/jsonparser"
-)
-
-type ReplaceValue struct {
-	value     []byte
-	valueType jsonparser.ValueType `json:"-"`
-}
-
-func (cv *ReplaceValue) Value() []byte {
-	return cv.value
-}
-
-func (cv *ReplaceValue) String() string {
-	str, _ := jsonparser.ParseString(cv.value)
-
-	return str
-}
-
-func (cv *ReplaceValue) Type() jsonparser.ValueType {
-	return cv.valueType
-}

remote/errors.go

@@ -1,11 +1,11 @@
-package api
+package remote
 
 import (
 	"fmt"
 	"net/http"
 )
 
-type RequestErrorBag struct {
+type RequestErrors struct {
 	Errors []RequestError `json:"errors"`
 }
 
@@ -31,3 +31,10 @@ func (re *RequestError) Error() string {
 
 	return fmt.Sprintf("Error response from Panel: %s: %s (HTTP/%d)", re.Code, re.Detail, c)
 }
+
+type SftpInvalidCredentialsError struct {
+}
+
+func (ice SftpInvalidCredentialsError) Error() string {
+	return "the credentials provided were invalid"
+}

remote/http.go

@@ -0,0 +1,230 @@
+package remote
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/pterodactyl/wings/system"
+)
+
+type Client interface {
+	GetBackupRemoteUploadURLs(ctx context.Context, backup string, size int64) (BackupRemoteUploadResponse, error)
+	GetInstallationScript(ctx context.Context, uuid string) (InstallationScript, error)
+	GetServerConfiguration(ctx context.Context, uuid string) (ServerConfigurationResponse, error)
+	GetServers(context context.Context, perPage int) ([]RawServerData, error)
+	ResetServersState(ctx context.Context) error
+	SetArchiveStatus(ctx context.Context, uuid string, successful bool) error
+	SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error
+	SendRestorationStatus(ctx context.Context, backup string, successful bool) error
+	SetInstallationStatus(ctx context.Context, uuid string, successful bool) error
+	SetTransferStatus(ctx context.Context, uuid string, successful bool) error
+	ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error)
+}
+
+type client struct {
+	httpClient *http.Client
+	baseUrl    string
+	tokenId    string
+	token      string
+	attempts   int
+}
+
+// New returns a new HTTP request client that is used for making authenticated
+// requests to the Panel that this instance is running under.
+func New(base string, opts ...ClientOption) Client {
+	c := client{
+		baseUrl: strings.TrimSuffix(base, "/") + "/api/remote",
+		httpClient: &http.Client{
+			Timeout: time.Second * 15,
+		},
+		attempts: 1,
+	}
+	for _, opt := range opts {
+		opt(&c)
+	}
+	return &c
+}
+
+// WithCredentials sets the credentials to use when making request to the remote
+// API endpoint.
+func WithCredentials(id, token string) ClientOption {
+	return func(c *client) {
+		c.tokenId = id
+		c.token = token
+	}
+}
+
+// WithHttpClient sets the underlying HTTP client instance to use when making
+// requests to the Panel API.
+func WithHttpClient(httpClient *http.Client) ClientOption {
+	return func(c *client) {
+		c.httpClient = httpClient
+	}
+}
+
+// requestOnce creates a http request and executes it once. Prefer request()
+// over this method when possible. It appends the path to the endpoint of the
+// client and adds the authentication token to the request.
+func (c *client) requestOnce(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (*Response, error) {
+	req, err := http.NewRequest(method, c.baseUrl+path, body)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("User-Agent", fmt.Sprintf("Pterodactyl Wings/v%s (id:%s)", system.Version, c.tokenId))
+	req.Header.Set("Accept", "application/vnd.pterodactyl.v1+json")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s.%s", c.tokenId, c.token))
+
+	// Call all opts functions to allow modifying the request
+	for _, o := range opts {
+		o(req)
+	}
+
+	debugLogRequest(req)
+
+	res, err := c.httpClient.Do(req.WithContext(ctx))
+	return &Response{res}, err
+}
+
+// request executes a http request and attempts when errors occur.
+// It appends the path to the endpoint of the client and adds the authentication token to the request.
+func (c *client) request(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (res *Response, err error) {
+	for i := 0; i < c.attempts; i++ {
+		res, err = c.requestOnce(ctx, method, path, body, opts...)
+		if err == nil &&
+			res.StatusCode < http.StatusInternalServerError &&
+			res.StatusCode != http.StatusTooManyRequests {
+			break
+		}
+	}
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	return
+}
+
+// get executes a http get request.
+func (c *client) get(ctx context.Context, path string, query q) (*Response, error) {
+	return c.request(ctx, http.MethodGet, path, nil, func(r *http.Request) {
+		q := r.URL.Query()
+		for k, v := range query {
+			q.Set(k, v)
+		}
+		r.URL.RawQuery = q.Encode()
+	})
+}
+
+// post executes a http post request.
+func (c *client) post(ctx context.Context, path string, data interface{}) (*Response, error) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+	return c.request(ctx, http.MethodPost, path, bytes.NewBuffer(b))
+}
+
+// Response is a custom response type that allows for commonly used error
+// handling and response parsing from the Panel API. This just embeds the normal
+// HTTP response from Go and we attach a few helper functions to it.
+type Response struct {
+	*http.Response
+}
+
+// HasError determines if the API call encountered an error. If no request has
+// been made the response will be false. This function will evaluate to true if
+// the response code is anything 300 or higher.
+func (r *Response) HasError() bool {
+	if r.Response == nil {
+		return false
+	}
+
+	return r.StatusCode >= 300 || r.StatusCode < 200
+}
+
+// Reads the body from the response and returns it, then replaces it on the response
+// so that it can be read again later. This does not close the response body, so any
+// functions calling this should be sure to manually defer a Body.Close() call.
+func (r *Response) Read() ([]byte, error) {
+	var b []byte
+	if r.Response == nil {
+		return nil, errors.New("http: attempting to read missing response")
+	}
+
+	if r.Response.Body != nil {
+		b, _ = ioutil.ReadAll(r.Response.Body)
+	}
+
+	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
+
+	return b, nil
+}
+
+// BindJSON binds a given interface with the data returned in the response. This
+// is a shortcut for calling Read and then manually calling json.Unmarshal on
+// the raw bytes.
+func (r *Response) BindJSON(v interface{}) error {
+	b, err := r.Read()
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(b, &v); err != nil {
+		return errors.Wrap(err, "http: could not unmarshal response")
+	}
+	return nil
+}
+
+// Returns the first error message from the API call as a string. The error
+// message will be formatted similar to the below example:
+//
+// HttpNotFoundException: The requested resource does not exist. (HTTP/404)
+func (r *Response) Error() error {
+	if !r.HasError() {
+		return nil
+	}
+
+	var errs RequestErrors
+	_ = r.BindJSON(&errs)
+
+	e := &RequestError{}
+	if len(errs.Errors) > 0 {
+		e = &errs.Errors[0]
+	}
+
+	e.response = r.Response
+
+	return e
+}
+
+// Logs the request into the debug log with all of the important request bits.
+// The authorization key will be cleaned up before being output.
+func debugLogRequest(req *http.Request) {
+	if l, ok := log.Log.(*log.Logger); ok && l.Level != log.DebugLevel {
+		return
+	}
+	headers := make(map[string][]string)
+	for k, v := range req.Header {
+		if k != "Authorization" || len(v) == 0 || len(v[0]) == 0 {
+			headers[k] = v
+			continue
+		}
+
+		headers[k] = []string{"(redacted)"}
+	}
+
+	log.WithFields(log.Fields{
+		"method":   req.Method,
+		"endpoint": req.URL.String(),
+		"headers":  headers,
+	}).Debug("making request to external HTTP endpoint")
+}

remote/http_test.go

@@ -0,0 +1,93 @@
+package remote
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func createTestClient(h http.HandlerFunc) (*client, *httptest.Server) {
+	s := httptest.NewServer(h)
+	c := &client{
+		httpClient: s.Client(),
+		baseUrl:    s.URL,
+
+		attempts: 1,
+		tokenId:  "testid",
+		token:    "testtoken",
+	}
+	return c, s
+}
+
+func TestRequest(t *testing.T) {
+	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, "application/vnd.pterodactyl.v1+json", r.Header.Get("Accept"))
+		assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
+		assert.Equal(t, "Bearer testid.testtoken", r.Header.Get("Authorization"))
+		assert.Equal(t, "/test", r.URL.Path)
+
+		rw.WriteHeader(http.StatusOK)
+	})
+	r, err := c.requestOnce(context.Background(), "", "/test", nil)
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+}
+
+func TestRequestRetry(t *testing.T) {
+	// Test if the client attempts failed requests
+	i := 0
+	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
+		if i < 1 {
+			rw.WriteHeader(http.StatusInternalServerError)
+		} else {
+			rw.WriteHeader(http.StatusOK)
+		}
+		i++
+	})
+	c.attempts = 2
+	r, err := c.request(context.Background(), "", "", nil)
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+	assert.Equal(t, http.StatusOK, r.StatusCode)
+	assert.Equal(t, 2, i)
+
+	// Test whether the client returns the last request after retry limit is reached
+	i = 0
+	c, _ = createTestClient(func(rw http.ResponseWriter, r *http.Request) {
+		rw.WriteHeader(http.StatusInternalServerError)
+		i++
+	})
+	c.attempts = 2
+	r, err = c.request(context.Background(), "get", "", nil)
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+	assert.Equal(t, http.StatusInternalServerError, r.StatusCode)
+	assert.Equal(t, 2, i)
+}
+
+func TestGet(t *testing.T) {
+	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, http.MethodGet, r.Method)
+		assert.Len(t, r.URL.Query(), 1)
+		assert.Equal(t, "world", r.URL.Query().Get("hello"))
+	})
+	r, err := c.get(context.Background(), "/test", q{"hello": "world"})
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+}
+
+func TestPost(t *testing.T) {
+	test := map[string]string{
+		"hello": "world",
+	}
+	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, http.MethodPost, r.Method)
+
+	})
+	r, err := c.post(context.Background(), "/test", test)
+	assert.NoError(t, err)
+	assert.NotNil(t, r)
+}

remote/servers.go

@@ -0,0 +1,225 @@
+package remote
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"sync"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"golang.org/x/sync/errgroup"
+)
+
+const (
+	ProcessStopCommand    = "command"
+	ProcessStopSignal     = "signal"
+	ProcessStopNativeStop = "stop"
+)
+
+// GetServers returns all of the servers that are present on the Panel making
+// parallel API calls to the endpoint if more than one page of servers is
+// returned.
+func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, error) {
+	servers, meta, err := c.getServersPaged(ctx, 0, limit)
+	if err != nil {
+		return nil, err
+	}
+
+	var mu sync.Mutex
+	if meta.LastPage > 1 {
+		g, ctx := errgroup.WithContext(ctx)
+		for page := meta.CurrentPage + 1; page <= meta.LastPage; page++ {
+			page := page
+			g.Go(func() error {
+				ps, _, err := c.getServersPaged(ctx, int(page), limit)
+				if err != nil {
+					return err
+				}
+				mu.Lock()
+				servers = append(servers, ps...)
+				mu.Unlock()
+				return nil
+			})
+		}
+		if err := g.Wait(); err != nil {
+			return nil, err
+		}
+	}
+
+	return servers, nil
+}
+
+// ResetServersState updates the state of all servers on the node that are
+// currently marked as "installing" or "restoring from backup" to be marked as
+// a normal successful install state.
+//
+// This handles Wings exiting during either of these processes which will leave
+// things in a bad state within the Panel. This API call is executed once Wings
+// has fully booted all of the servers.
+func (c *client) ResetServersState(ctx context.Context) error {
+	res, err := c.post(ctx, "/servers/reset", nil)
+	if err != nil {
+		return errors.WrapIf(err, "remote/servers: failed to reset server state on Panel")
+	}
+	res.Body.Close()
+	return nil
+}
+
+func (c *client) GetServerConfiguration(ctx context.Context, uuid string) (ServerConfigurationResponse, error) {
+	var config ServerConfigurationResponse
+	res, err := c.get(ctx, fmt.Sprintf("/servers/%s", uuid), nil)
+	if err != nil {
+		return config, err
+	}
+	defer res.Body.Close()
+
+	if res.HasError() {
+		return config, res.Error()
+	}
+
+	err = res.BindJSON(&config)
+	return config, err
+}
+
+func (c *client) GetInstallationScript(ctx context.Context, uuid string) (InstallationScript, error) {
+	res, err := c.get(ctx, fmt.Sprintf("/servers/%s/install", uuid), nil)
+	if err != nil {
+		return InstallationScript{}, err
+	}
+	defer res.Body.Close()
+
+	if res.HasError() {
+		return InstallationScript{}, res.Error()
+	}
+
+	var config InstallationScript
+	err = res.BindJSON(&config)
+	return config, err
+}
+
+func (c *client) SetInstallationStatus(ctx context.Context, uuid string, successful bool) error {
+	resp, err := c.post(ctx, fmt.Sprintf("/servers/%s/install", uuid), d{"successful": successful})
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return resp.Error()
+}
+
+func (c *client) SetArchiveStatus(ctx context.Context, uuid string, successful bool) error {
+	resp, err := c.post(ctx, fmt.Sprintf("/servers/%s/archive", uuid), d{"successful": successful})
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return resp.Error()
+}
+
+func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful bool) error {
+	state := "failure"
+	if successful {
+		state = "success"
+	}
+	resp, err := c.get(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return resp.Error()
+}
+
+// ValidateSftpCredentials makes a request to determine if the username and
+// password combination provided is associated with a valid server on the instance
+// using the Panel's authentication control mechanisms. This will get itself
+// throttled if too many requests are made, allowing us to completely offload
+// all of the authorization security logic to the Panel.
+func (c *client) ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error) {
+	var auth SftpAuthResponse
+	res, err := c.post(ctx, "/sftp/auth", request)
+	if err != nil {
+		return auth, err
+	}
+	defer res.Body.Close()
+
+	e := res.Error()
+	if e != nil {
+		if res.StatusCode >= 400 && res.StatusCode < 500 {
+			log.WithFields(log.Fields{
+				"subsystem": "sftp",
+				"username":  request.User,
+				"ip":        request.IP,
+			}).Warn(e.Error())
+
+			return auth, &SftpInvalidCredentialsError{}
+		}
+
+		return auth, errors.New(e.Error())
+	}
+
+	err = res.BindJSON(&auth)
+	return auth, err
+}
+
+func (c *client) GetBackupRemoteUploadURLs(ctx context.Context, backup string, size int64) (BackupRemoteUploadResponse, error) {
+	var data BackupRemoteUploadResponse
+	res, err := c.get(ctx, fmt.Sprintf("/backups/%s", backup), q{"size": strconv.FormatInt(size, 10)})
+	if err != nil {
+		return data, err
+	}
+	defer res.Body.Close()
+
+	if res.HasError() {
+		return data, res.Error()
+	}
+
+	err = res.BindJSON(&data)
+	return data, err
+}
+
+func (c *client) SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error {
+	resp, err := c.post(ctx, fmt.Sprintf("/backups/%s", backup), data)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return resp.Error()
+}
+
+// SendRestorationStatus triggers a request to the Panel to notify it that a
+// restoration has been completed and the server should be marked as being
+// activated again.
+func (c *client) SendRestorationStatus(ctx context.Context, backup string, successful bool) error {
+	resp, err := c.post(ctx, fmt.Sprintf("/backups/%s/restore", backup), d{"successful": successful})
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return resp.Error()
+}
+
+// getServersPaged returns a subset of servers from the Panel API using the
+// pagination query parameters.
+func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawServerData, Pagination, error) {
+	var r struct {
+		Data []RawServerData `json:"data"`
+		Meta Pagination      `json:"meta"`
+	}
+
+	res, err := c.get(ctx, "/servers", q{
+		"page":     strconv.Itoa(page),
+		"per_page": strconv.Itoa(limit),
+	})
+	if err != nil {
+		return nil, r.Meta, err
+	}
+	defer res.Body.Close()
+
+	if res.HasError() {
+		return nil, r.Meta, res.Error()
+	}
+	if err := res.BindJSON(&r); err != nil {
+		return nil, r.Meta, err
+	}
+	return r.Data, r.Meta, nil
+}

remote/types.go

@@ -0,0 +1,154 @@
+package remote
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+
+	"github.com/apex/log"
+	"github.com/pterodactyl/wings/parser"
+)
+
+// A generic type allowing for easy binding use when making requests to API
+// endpoints that only expect a singular argument or something that would not
+// benefit from being a typed struct.
+//
+// Inspired by gin.H, same concept.
+type d map[string]interface{}
+
+// Same concept as d, but a map of strings, used for querying GET requests.
+type q map[string]string
+
+type ClientOption func(c *client)
+
+type Pagination struct {
+	CurrentPage uint `json:"current_page"`
+	From        uint `json:"from"`
+	LastPage    uint `json:"last_page"`
+	PerPage     uint `json:"per_page"`
+	To          uint `json:"to"`
+	Total       uint `json:"total"`
+}
+
+// ServerConfigurationResponse holds the server configuration data returned from
+// the Panel. When a server process is started, Wings communicates with the
+// Panel to fetch the latest build information as well as get all of the details
+// needed to parse the given Egg.
+//
+// This means we do not need to hit Wings each time part of the server is
+// updated, and the Panel serves as the source of truth at all times. This also
+// means if a configuration is accidentally wiped on Wings we can self-recover
+// without too much hassle, so long as Wings is aware of what servers should
+// exist on it.
+type ServerConfigurationResponse struct {
+	Settings             json.RawMessage       `json:"settings"`
+	ProcessConfiguration *ProcessConfiguration `json:"process_configuration"`
+}
+
+// InstallationScript defines installation script information for a server
+// process. This is used when a server is installed for the first time, and when
+// a server is marked for re-installation.
+type InstallationScript struct {
+	ContainerImage string `json:"container_image"`
+	Entrypoint     string `json:"entrypoint"`
+	Script         string `json:"script"`
+}
+
+// RawServerData is a raw response from the API for a server.
+type RawServerData struct {
+	Uuid                 string          `json:"uuid"`
+	Settings             json.RawMessage `json:"settings"`
+	ProcessConfiguration json.RawMessage `json:"process_configuration"`
+}
+
+// SftpAuthRequest defines the request details that are passed along to the Panel
+// when determining if the credentials provided to Wings are valid.
+type SftpAuthRequest struct {
+	User          string `json:"username"`
+	Pass          string `json:"password"`
+	IP            string `json:"ip"`
+	SessionID     []byte `json:"session_id"`
+	ClientVersion []byte `json:"client_version"`
+}
+
+// SftpAuthResponse is returned by the Panel when a pair of SFTP credentials
+// is successfully validated. This will include the specific server that was
+// matched as well as the permissions that are assigned to the authenticated
+// user for the SFTP subsystem.
+type SftpAuthResponse struct {
+	Server      string   `json:"server"`
+	Token       string   `json:"token"`
+	Permissions []string `json:"permissions"`
+}
+
+type OutputLineMatcher struct {
+	// The raw string to match against. This may or may not be prefixed with
+	// regex: which indicates we want to match against the regex expression.
+	raw string
+	reg *regexp.Regexp
+}
+
+// Matches determines if a given string "s" matches the given line.
+func (olm *OutputLineMatcher) Matches(s string) bool {
+	if olm.reg == nil {
+		return strings.Contains(s, olm.raw)
+	}
+
+	return olm.reg.MatchString(s)
+}
+
+// String returns the matcher's raw comparison string.
+func (olm *OutputLineMatcher) String() string {
+	return olm.raw
+}
+
+// UnmarshalJSON unmarshals the startup lines into individual structs for easier
+// matching abilities.
+func (olm *OutputLineMatcher) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &olm.raw); err != nil {
+		return err
+	}
+
+	if strings.HasPrefix(olm.raw, "regex:") && len(olm.raw) > 6 {
+		r, err := regexp.Compile(strings.TrimPrefix(olm.raw, "regex:"))
+		if err != nil {
+			log.WithField("error", err).WithField("raw", olm.raw).Warn("failed to compile output line marked as being regex")
+		}
+
+		olm.reg = r
+	}
+
+	return nil
+}
+
+// ProcessStopConfiguration defines what is used when stopping an instance.
+type ProcessStopConfiguration struct {
+	Type  string `json:"type"`
+	Value string `json:"value"`
+}
+
+// ProcessConfiguration defines the process configuration for a given server
+// instance. This sets what Wings is looking for to mark a server as done starting
+// what to do when stopping, and what changes to make to the configuration file
+// for a server.
+type ProcessConfiguration struct {
+	Startup struct {
+		Done            []*OutputLineMatcher `json:"done"`
+		UserInteraction []string             `json:"user_interaction"`
+		StripAnsi       bool                 `json:"strip_ansi"`
+	} `json:"startup"`
+	Stop               ProcessStopConfiguration   `json:"stop"`
+	ConfigurationFiles []parser.ConfigurationFile `json:"configs"`
+}
+
+type BackupRemoteUploadResponse struct {
+	Parts    []string `json:"parts"`
+	PartSize int64    `json:"part_size"`
+}
+
+type BackupRequest struct {
+	Checksum     string `json:"checksum"`
+	ChecksumType string `json:"checksum_type"`
+	Size         int64  `json:"size"`
+	Successful   bool   `json:"successful"`
+}

router/downloader/downloader.go

@@ -13,6 +13,7 @@ import (
 	"net/url"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -89,7 +90,7 @@ type Download struct {
 	cancelFunc *context.CancelFunc
 }
 
-// Starts a new tracked download which allows for cancelation later on by calling
+// Starts a new tracked download which allows for cancellation later on by calling
 // the Downloader.Cancel function.
 func New(s *server.Server, r DownloadRequest) *Download {
 	dl := Download{
@@ -228,6 +229,13 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	}
 
 	host := dl.req.URL.Host
+
+	// This cluster-fuck of math and integer shit converts an integer IP into a proper IPv4.
+	// For example: 16843009 would become 1.1.1.1
+	if i, err := strconv.ParseInt(host, 10, 64); err == nil {
+		host = strconv.FormatInt((i>>24)&0xFF, 10) + "." + strconv.FormatInt((i>>16)&0xFF, 10) + "." + strconv.FormatInt((i>>8)&0xFF, 10) + "." + strconv.FormatInt(i&0xFF, 10)
+	}
+
 	if !ipMatchRegex.MatchString(host) {
 		if dl.req.URL.Scheme == "https" {
 			host = host + ":443"
@@ -240,7 +248,7 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	c.Close()
+	_ = c.Close()
 
 	ip := net.ParseIP(ipMatchRegex.ReplaceAllString(c.RemoteAddr().String(), ""))
 	if ip == nil {

router/error.go

@@ -77,7 +77,6 @@ func (e *RequestError) AbortWithStatus(status int, c *gin.Context) {
 	// If this error is because the resource does not exist, we likely do not need to log
 	// the error anywhere, just return a 404 and move on with our lives.
 	if errors.Is(e.err, os.ErrNotExist) {
-		e.logger().Debug("encountered os.IsNotExist error while handling request")
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on the system.",
 		})
@@ -122,20 +121,25 @@ func (e *RequestError) Abort(c *gin.Context) {
 // Looks at the given RequestError and determines if it is a specific filesystem error that
 // we can process and return differently for the user.
 func (e *RequestError) getAsFilesystemError() (int, string) {
-	err := errors.Unwrap(e.err)
-	if err == nil {
-		return 0, ""
+	// Some external things end up calling fmt.Errorf() on our filesystem errors
+	// which ends up just unleashing chaos on the system. For the sake of this
+	// fallback to using text checks...
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDenylistFile) || strings.Contains(e.err.Error(), "filesystem: file access prohibited") {
+		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
 	}
-	if errors.Is(err, os.ErrNotExist) || filesystem.IsErrorCode(err, filesystem.ErrCodePathResolution) {
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodePathResolution) || strings.Contains(e.err.Error(), "resolves to a location outside the server root") {
 		return http.StatusNotFound, "The requested resource was not found on the system."
 	}
-	if filesystem.IsErrorCode(err, filesystem.ErrCodeDiskSpace) {
-		return http.StatusConflict, "There is not enough disk space available to perform that action."
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeIsDirectory) || strings.Contains(e.err.Error(), "filesystem: is a directory") {
+		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
 	}
-	if strings.HasSuffix(err.Error(), "file name too long") {
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDiskSpace) || strings.Contains(e.err.Error(), "filesystem: not enough disk space") {
+		return http.StatusBadRequest, "Cannot perform that action: not enough disk space available."
+	}
+	if strings.HasSuffix(e.err.Error(), "file name too long") {
 		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
 	}
-	if e, ok := err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
+	if e, ok := e.err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
 		return http.StatusNotFound, "The requested directory does not exist."
 	}
 	return 0, ""

router/middleware.go

@@ -1,146 +1,16 @@
 package router
 
 import (
-	"io"
-	"net/http"
-	"strings"
-
-	"emperror.dev/errors"
 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 )
 
-type Middleware struct{}
-
-// A custom handler function allowing for errors bubbled up by c.Error() to be returned in a
-// standardized format with tracking UUIDs on them for easier log searching.
-func (m *Middleware) ErrorHandler() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		c.Next()
-		err := c.Errors.Last()
-		if err == nil || err.Err == nil {
-			return
-		}
-		tracked := NewTrackedError(err.Err)
-		// If there is a server in the context for this request pull it out so that we can
-		// track the error specifically for that server.
-		if s, ok := c.Get("server"); ok {
-			tracked = NewServerError(err.Err, s.(*server.Server))
-		}
-		// This error occurs if you submit invalid JSON data to an endpoint.
-		if err.Err.Error() == io.EOF.Error() {
-			c.JSON(c.Writer.Status(), gin.H{"error": "A JSON formatted body is required for this endpoint."})
-			return
-		}
-		tracked.Abort(c)
-		return
-	}
-}
-
-// Set the access request control headers on all of the requests.
-func (m *Middleware) SetAccessControlHeaders() gin.HandlerFunc {
-	origins := config.Get().AllowedOrigins
-	location := config.Get().PanelLocation
-	return func(c *gin.Context) {
-		c.Header("Access-Control-Allow-Credentials", "true")
-		c.Header("Access-Control-Allow-Methods", "GET, POST, PATCH, PUT, DELETE, OPTIONS")
-		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
-
-		o := c.GetHeader("Origin")
-		if o != location {
-			for _, origin := range origins {
-				if origin != "*" && o != origin {
-					continue
-				}
-				c.Header("Access-Control-Allow-Origin", origin)
-				c.Next()
-				return
-			}
-		}
-		c.Header("Access-Control-Allow-Origin", location)
-		c.Next()
-	}
-}
-
-// Authenticates the request token against the given permission string, ensuring that
-// if it is a server permission, the token has control over that server. If it is a global
-// token, this will ensure that the request is using a properly signed global token.
-func (m *Middleware) RequireAuthorization() gin.HandlerFunc {
-	token := config.Get().AuthenticationToken
-	return func(c *gin.Context) {
-		auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
-		if len(auth) != 2 || auth[0] != "Bearer" {
-			c.Header("WWW-Authenticate", "Bearer")
-			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
-				"error": "The required authorization heads were not present in the request.",
-			})
-			return
-		}
-
-		// All requests to Wings must be authorized with the authentication token present in
-		// the Wings configuration file. Remeber, all requests to Wings come from the Panel
-		// backend, or using a signed JWT for temporary authentication.
-		if auth[1] == token {
-			c.Next()
-			return
-		}
-		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
-			"error": "You are not authorized to access this endpoint.",
-		})
-	}
-}
-
-// Helper function to fetch a server out of the servers collection stored in memory.
+// ExtractServer returns the server instance from the gin context. If there is
+// no server set in the context (e.g. calling from a controller not protected
+// by ServerExists) this function will panic.
 //
-// This function should not be used in new controllers, prefer ExtractServer where
-// possible.
-func GetServer(uuid string) *server.Server {
-	return server.GetServers().Find(func(s *server.Server) bool {
-		return uuid == s.Id()
-	})
-}
-
-// Ensure that the requested server exists in this setup. Returns a 404 if we cannot
-// locate it.
-func (m *Middleware) ServerExists() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		u, err := uuid.Parse(c.Param("server"))
-		if err == nil {
-			if s := GetServer(u.String()); s != nil {
-				c.Set("server", s)
-				c.Next()
-				return
-			}
-		}
-		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-			"error": "The resource you requested does not exist.",
-		})
-	}
-}
-
-// Checks if remote file downloading is enabled on this instance before allowing access
-// to the given endpoint.
-func (m *Middleware) CheckRemoteDownloadEnabled() gin.HandlerFunc {
-	disabled := config.Get().Api.DisableRemoteDownload
-	return func(c *gin.Context) {
-		if disabled {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "This functionality is not currently enabled on this instance.",
-			})
-			return
-		}
-		c.Next()
-	}
-}
-
-// Returns the server instance from the gin context. If there is no server set in the
-// context (e.g. calling from a controller not protected by ServerExists) this function
-// will panic.
+// This function is deprecated. Use middleware.ExtractServer.
 func ExtractServer(c *gin.Context) *server.Server {
-	if s, ok := c.Get("server"); ok {
-		return s.(*server.Server)
-	}
-	panic(errors.New("cannot extract server, missing on gin context"))
+	return middleware.ExtractServer(c)
 }

router/middleware/middleware.go

@@ -0,0 +1,354 @@
+package middleware
+
+import (
+	"context"
+	"crypto/subtle"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server/filesystem"
+)
+
+// RequestError is a custom error type returned when something goes wrong with
+// any of the HTTP endpoints.
+type RequestError struct {
+	err    error
+	status int
+	msg    string
+}
+
+// NewError returns a new RequestError for the provided error.
+func NewError(err error) *RequestError {
+	return &RequestError{
+		// Attach a stacktrace to the error if it is missing at this point and mark it
+		// as originating from the location where NewError was called, rather than this
+		// specific point in the code.
+		err: errors.WithStackDepthIf(err, 1),
+	}
+}
+
+// SetMessage allows for a custom error message to be set on an existing
+// RequestError instance.
+func (re *RequestError) SetMessage(m string) {
+	re.msg = m
+}
+
+// SetStatus sets the HTTP status code for the error response. By default this
+// is a HTTP-500 error.
+func (re *RequestError) SetStatus(s int) {
+	re.status = s
+}
+
+// Abort aborts the given HTTP request with the specified status code and then
+// logs the event into the logs. The error that is output will include the unique
+// request ID if it is present.
+func (re *RequestError) Abort(c *gin.Context, status int) {
+	reqId := c.Writer.Header().Get("X-Request-Id")
+
+	// Generate the base logger instance, attaching the unique request ID and
+	// the URL that was requested.
+	event := log.WithField("request_id", reqId).WithField("url", c.Request.URL.String())
+	// If there is a server present in the gin.Context stack go ahead and pull it
+	// and attach that server UUID to the logs as well so that we can see what specific
+	// server triggered this error.
+	if s, ok := c.Get("server"); ok {
+		if s, ok := s.(*server.Server); ok {
+			event = event.WithField("server_id", s.Id())
+		}
+	}
+
+	if c.Writer.Status() == 200 {
+		// Handle context deadlines being exceeded a little differently since we want
+		// to report a more user-friendly error and a proper error code. The "context
+		// canceled" error is generally when a request is terminated before all of the
+		// logic is finished running.
+		if errors.Is(re.err, context.DeadlineExceeded) {
+			re.SetStatus(http.StatusGatewayTimeout)
+			re.SetMessage("The server could not process this request in time, please try again.")
+		} else if strings.Contains(re.Cause().Error(), "context canceled") {
+			re.SetStatus(http.StatusBadRequest)
+			re.SetMessage("Request aborted by client.")
+		}
+	}
+
+	// c.Writer.Status() will be a non-200 value if the headers have already been sent
+	// to the requester but an error is encountered. This can happen if there is an issue
+	// marshaling a struct placed into a c.JSON() call (or c.AbortWithJSON() call).
+	if status >= 500 || c.Writer.Status() != 200 {
+		event.WithField("status", status).WithField("error", re.err).Error("error while handling HTTP request")
+	} else {
+		event.WithField("status", status).WithField("error", re.err).Debug("error handling HTTP request (not a server error)")
+	}
+	if re.msg == "" {
+		re.msg = "An unexpected error was encountered while processing this request"
+	}
+	// Now abort the request with the error message and include the unique request
+	// ID that was present to make things super easy on people who don't know how
+	// or cannot view the response headers (where X-Request-Id would be present).
+	c.AbortWithStatusJSON(status, gin.H{"error": re.msg, "request_id": reqId})
+}
+
+// Cause returns the underlying error.
+func (re *RequestError) Cause() error {
+	return re.err
+}
+
+// Error returns the underlying error message for this request.
+func (re *RequestError) Error() string {
+	return re.err.Error()
+}
+
+// Looks at the given RequestError and determines if it is a specific filesystem
+// error that we can process and return differently for the user.
+//
+// Some external things end up calling fmt.Errorf() on our filesystem errors
+// which ends up just unleashing chaos on the system. For the sake of this,
+// fallback to using text checks.
+//
+// If the error passed into this call is nil or does not match empty values will
+// be returned to the caller.
+func (re *RequestError) asFilesystemError() (int, string) {
+	err := re.Cause()
+	if err == nil {
+		return 0, ""
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeDenylistFile) || strings.Contains(err.Error(), "filesystem: file access prohibited") {
+		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodePathResolution) || strings.Contains(err.Error(), "resolves to a location outside the server root") {
+		return http.StatusNotFound, "The requested resource was not found on the system."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) || strings.Contains(err.Error(), "filesystem: is a directory") {
+		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeDiskSpace) || strings.Contains(err.Error(), "filesystem: not enough disk space") {
+		return http.StatusBadRequest, "There is not enough disk space available to perform that action."
+	}
+	if strings.HasSuffix(err.Error(), "file name too long") {
+		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
+	}
+	if e, ok := err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
+		return http.StatusNotFound, "The requested directory does not exist."
+	}
+	return 0, ""
+}
+
+// AttachRequestID attaches a unique ID to the incoming HTTP request so that any
+// errors that are generated or returned to the client will include this reference
+// allowing for an easier time identifying the specific request that failed for
+// the user.
+//
+// If you are using a tool such as Sentry or Bugsnag for error reporting this is
+// a great location to also attach this request ID to your error handling logic
+// so that you can easily cross-reference the errors.
+func AttachRequestID() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		id := uuid.New().String()
+		c.Set("request_id", id)
+		c.Set("logger", log.WithField("request_id", id))
+		c.Header("X-Request-Id", id)
+		c.Next()
+	}
+}
+
+// AttachServerManager attaches the server manager to the request context which
+// allows routes to access the underlying server collection.
+func AttachServerManager(m *server.Manager) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Set("manager", m)
+		c.Next()
+	}
+}
+
+// AttachApiClient attaches the application API client which allows routes to
+// access server resources from the Panel easily.
+func AttachApiClient(client remote.Client) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Set("api_client", client)
+		c.Next()
+	}
+}
+
+// CaptureAndAbort aborts the request and attaches the provided error to the gin
+// context so it can be reported properly. If the error is missing a stacktrace
+// at the time it is called the stack will be attached.
+func CaptureAndAbort(c *gin.Context, err error) {
+	c.Abort()
+	c.Error(errors.WithStackDepthIf(err, 1))
+}
+
+// CaptureErrors is custom handler function allowing for errors bubbled up by
+// c.Error() to be returned in a standardized format with tracking UUIDs on them
+// for easier log searching.
+func CaptureErrors() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Next()
+		err := c.Errors.Last()
+		if err == nil || err.Err == nil {
+			return
+		}
+
+		status := http.StatusInternalServerError
+		if c.Writer.Status() != 200 {
+			status = c.Writer.Status()
+		}
+		if err.Error() == io.EOF.Error() {
+			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "The data passed in the request was not in a parsable format. Please try again."})
+			return
+		}
+		captured := NewError(err.Err)
+		if status, msg := captured.asFilesystemError(); msg != "" {
+			c.AbortWithStatusJSON(status, gin.H{"error": msg, "request_id": c.Writer.Header().Get("X-Request-Id")})
+			return
+		}
+		captured.Abort(c, status)
+	}
+}
+
+// SetAccessControlHeaders sets the access request control headers on all of
+// the requests.
+func SetAccessControlHeaders() gin.HandlerFunc {
+	origins := config.Get().AllowedOrigins
+	location := config.Get().PanelLocation
+
+	return func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Credentials", "true")
+		c.Header("Access-Control-Allow-Methods", "GET, POST, PATCH, PUT, DELETE, OPTIONS")
+		// Maximum age allowable under Chromium v76 is 2 hours, so just use that since
+		// anything higher will be ignored (even if other browsers do allow higher values).
+		//
+		// @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age#Directives
+		c.Header("Access-Control-Max-Age", "7200")
+		c.Header("Access-Control-Allow-Origin", location)
+		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
+		// Validate that the request origin is coming from an allowed origin. Because you
+		// cannot set multiple values here we need to see if the origin is one of the ones
+		// that we allow, and if so return it explicitly. Otherwise, just return the default
+		// origin which is the same URL that the Panel is located at.
+		origin := c.GetHeader("Origin")
+		if origin != location {
+			for _, o := range origins {
+				if o != "*" && o != origin {
+					continue
+				}
+				c.Header("Access-Control-Allow-Origin", o)
+				break
+			}
+		}
+		if c.Request.Method == http.MethodOptions {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+		c.Next()
+	}
+}
+
+// ServerExists will ensure that the requested server exists in this setup.
+// Returns a 404 if we cannot locate it. If the server is found it is set into
+// the request context, and the logger for the context is also updated to include
+// the server ID in the fields list.
+func ServerExists() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var s *server.Server
+		if c.Param("server") != "" {
+			manager := ExtractManager(c)
+			s = manager.Find(func(s *server.Server) bool {
+				return c.Param("server") == s.Id()
+			})
+		}
+		if s == nil {
+			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"error": "The requested resource does not exist on this instance."})
+			return
+		}
+		c.Set("logger", ExtractLogger(c).WithField("server_id", s.Id()))
+		c.Set("server", s)
+		c.Next()
+	}
+}
+
+// RequireAuthorization authenticates the request token against the given
+// permission string, ensuring that if it is a server permission, the token has
+// control over that server. If it is a global token, this will ensure that the
+// request is using a properly signed global token.
+func RequireAuthorization() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// We don't put this value outside this function since the node's authentication
+		// token can be changed on the fly and the config.Get() call returns a copy, so
+		// if it is rotated this value will never properly get updated.
+		token := config.Get().AuthenticationToken
+		auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
+		if len(auth) != 2 || auth[0] != "Bearer" {
+			c.Header("WWW-Authenticate", "Bearer")
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "The required authorization heads were not present in the request."})
+			return
+		}
+
+		// All requests to Wings must be authorized with the authentication token present in
+		// the Wings configuration file. Remeber, all requests to Wings come from the Panel
+		// backend, or using a signed JWT for temporary authentication.
+		if subtle.ConstantTimeCompare([]byte(auth[1]), []byte(token)) != 1 {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "You are not authorized to access this endpoint."})
+			return
+		}
+		c.Next()
+	}
+}
+
+// RemoteDownloadEnabled checks if remote downloads are enabled for this instance
+// and if not aborts the request.
+func RemoteDownloadEnabled() gin.HandlerFunc {
+	disabled := config.Get().Api.DisableRemoteDownload
+	return func(c *gin.Context) {
+		if disabled {
+			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "This functionality is not currently enabled on this instance."})
+			return
+		}
+		c.Next()
+	}
+}
+
+// ExtractLogger pulls the logger out of the request context and returns it. By
+// default this will include the request ID, but may also include the server ID
+// if that middleware has been used in the chain by the time it is called.
+func ExtractLogger(c *gin.Context) *log.Entry {
+	v, ok := c.Get("logger")
+	if !ok {
+		panic("middleware/middleware: cannot extract logger: not present in request context")
+	}
+	return v.(*log.Entry)
+}
+
+// ExtractServer will return the server from the gin.Context or panic if it is
+// not present.
+func ExtractServer(c *gin.Context) *server.Server {
+	v, ok := c.Get("server")
+	if !ok {
+		panic("middleware/middleware: cannot extract server: not present in request context")
+	}
+	return v.(*server.Server)
+}
+
+// ExtractApiClient returns the API client defined for the routes.
+func ExtractApiClient(c *gin.Context) remote.Client {
+	if v, ok := c.Get("api_client"); ok {
+		return v.(remote.Client)
+	}
+	panic("middleware/middlware: cannot extract api clinet: not present in context")
+}
+
+// ExtractManager returns the server manager instance set on the request context.
+func ExtractManager(c *gin.Context) *server.Manager {
+	if v, ok := c.Get("manager"); ok {
+		return v.(*server.Manager)
+	}
+	panic("middleware/middleware: cannot extract server manager: not present in context")
+}

router/router.go

@@ -3,15 +3,19 @@ package router
 import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/router/middleware"
+	"github.com/pterodactyl/wings/server"
 )
 
-// Configures the routing infrastructure for this daemon instance.
-func Configure() *gin.Engine {
+// Configure configures the routing infrastructure for this daemon instance.
+func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 	gin.SetMode("release")
 
-	m := Middleware{}
 	router := gin.New()
-	router.Use(gin.Recovery(), m.ErrorHandler(), m.SetAccessControlHeaders())
+	router.Use(gin.Recovery())
+	router.Use(middleware.AttachRequestID(), middleware.CaptureErrors(), middleware.SetAccessControlHeaders())
+	router.Use(middleware.AttachServerManager(m), middleware.AttachApiClient(client))
 	// @todo log this into a different file so you can setup IP blocking for abusive requests and such.
 	// This should still dump requests in debug mode since it does help with understanding the request
 	// lifecycle and quickly seeing what was called leading to the logs. However, it isn't feasible to mix
@@ -19,18 +23,15 @@ func Configure() *gin.Engine {
 	// spamfest.
 	router.Use(gin.LoggerWithFormatter(func(params gin.LogFormatterParams) string {
 		log.WithFields(log.Fields{
-			"client_ip": params.ClientIP,
-			"status":    params.StatusCode,
-			"latency":   params.Latency,
+			"client_ip":  params.ClientIP,
+			"status":     params.StatusCode,
+			"latency":    params.Latency,
+			"request_id": params.Keys["request_id"],
 		}).Debugf("%s %s", params.MethodColor()+params.Method+params.ResetColor(), params.Path)
 
 		return ""
 	}))
 
-	router.OPTIONS("/api/system", func(c *gin.Context) {
-		c.Status(200)
-	})
-
 	// These routes use signed URLs to validate access to the resource being requested.
 	router.GET("/download/backup", getDownloadBackup)
 	router.GET("/download/file", getDownloadFile)
@@ -39,16 +40,16 @@ func Configure() *gin.Engine {
 	// This route is special it sits above all of the other requests because we are
 	// using a JWT to authorize access to it, therefore it needs to be publicly
 	// accessible.
-	router.GET("/api/servers/:server/ws", m.ServerExists(), getServerWebsocket)
+	router.GET("/api/servers/:server/ws", middleware.ServerExists(), getServerWebsocket)
 
 	// This request is called by another daemon when a server is going to be transferred out.
 	// This request does not need the AuthorizationMiddleware as the panel should never call it
 	// and requests are authenticated through a JWT the panel issues to the other daemon.
-	router.GET("/api/servers/:server/archive", m.ServerExists(), getServerArchive)
+	router.GET("/api/servers/:server/archive", middleware.ServerExists(), getServerArchive)
 
 	// All of the routes beyond this mount will use an authorization middleware
 	// and will not be accessible without the correct Authorization header provided.
-	protected := router.Use(m.RequireAuthorization())
+	protected := router.Use(middleware.RequireAuthorization())
 	protected.POST("/api/update", postUpdateConfiguration)
 	protected.GET("/api/system", getSystemInformation)
 	protected.GET("/api/servers", getAllServers)
@@ -58,7 +59,7 @@ func Configure() *gin.Engine {
 	// These are server specific routes, and require that the request be authorized, and
 	// that the server exist on the Daemon.
 	server := router.Group("/api/servers/:server")
-	server.Use(m.RequireAuthorization(), m.ServerExists())
+	server.Use(middleware.RequireAuthorization(), middleware.ServerExists())
 	{
 		server.GET("", getServer)
 		server.PATCH("", patchServer)
@@ -88,14 +89,15 @@ func Configure() *gin.Engine {
 			files.POST("/decompress", postServerDecompressFiles)
 			files.POST("/chmod", postServerChmodFile)
 
-			files.GET("/pull", m.CheckRemoteDownloadEnabled(), getServerPullingFiles)
-			files.POST("/pull", m.CheckRemoteDownloadEnabled(), postServerPullRemoteFile)
-			files.DELETE("/pull/:download", m.CheckRemoteDownloadEnabled(), deleteServerPullRemoteFile)
+			files.GET("/pull", middleware.RemoteDownloadEnabled(), getServerPullingFiles)
+			files.POST("/pull", middleware.RemoteDownloadEnabled(), postServerPullRemoteFile)
+			files.DELETE("/pull/:download", middleware.RemoteDownloadEnabled(), deleteServerPullRemoteFile)
 		}
 
 		backup := server.Group("/backup")
 		{
 			backup.POST("", postServerBackup)
+			backup.POST("/:backup/restore", postServerRestoreBackup)
 			backup.DELETE("/:backup", deleteServerBackup)
 		}
 	}

router/router_download.go

@@ -8,27 +8,31 @@ import (
 	"strconv"
 
 	"github.com/gin-gonic/gin"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server/backup"
 )
 
 // Handle a download request for a server backup.
 func getDownloadBackup(c *gin.Context) {
+	client := middleware.ExtractApiClient(c)
+	manager := middleware.ExtractManager(c)
+
 	token := tokens.BackupPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
 		NewTrackedError(err).Abort(c)
 		return
 	}
 
-	s := GetServer(token.ServerUuid)
-	if s == nil || !token.IsUniqueRequest() {
+	s, ok := manager.Get(token.ServerUuid)
+	if !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
 		return
 	}
 
-	b, st, err := backup.LocateLocal(token.BackupUuid)
+	b, st, err := backup.LocateLocal(client, token.BackupUuid)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
 			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
@@ -49,7 +53,7 @@ func getDownloadBackup(c *gin.Context) {
 	defer f.Close()
 
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+st.Name())
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
 	c.Header("Content-Type", "application/octet-stream")
 
 	bufio.NewReader(f).WriteTo(c.Writer)
@@ -57,14 +61,15 @@ func getDownloadBackup(c *gin.Context) {
 
 // Handles downloading a specific file for a server.
 func getDownloadFile(c *gin.Context) {
+	manager := middleware.ExtractManager(c)
 	token := tokens.FilePayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
 		NewTrackedError(err).Abort(c)
 		return
 	}
 
-	s := GetServer(token.ServerUuid)
-	if s == nil || !token.IsUniqueRequest() {
+	s, ok := manager.Get(token.ServerUuid)
+	if !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
@@ -92,7 +97,7 @@ func getDownloadFile(c *gin.Context) {
 	}
 
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+st.Name())
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
 	c.Header("Content-Type", "application/octet-stream")
 
 	bufio.NewReader(f).WriteTo(c.Writer)

router/router_server.go

@@ -11,28 +11,19 @@ import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/pterodactyl/wings/router/downloader"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
 )
 
-type serverProcData struct {
-	server.ResourceUsage
-	Suspended bool `json:"suspended"`
-}
-
 // Returns a single server from the collection of servers.
 func getServer(c *gin.Context) {
-	s := GetServer(c.Param("server"))
-
-	c.JSON(http.StatusOK, serverProcData{
-		ResourceUsage: s.Proc(),
-		Suspended:     s.IsSuspended(),
-	})
+	c.JSON(http.StatusOK, ExtractServer(c).ToAPIResponse())
 }
 
 // Returns the logs for a given server instance.
 func getServerLogs(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	l, _ := strconv.Atoi(c.DefaultQuery("size", "100"))
 	if l <= 0 {
@@ -59,7 +50,7 @@ func getServerLogs(c *gin.Context) {
 // things are happening, so theres no reason to sit and wait for a request to finish. We'll
 // just see over the socket if something isn't working correctly.
 func postServerPower(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Action server.PowerAction `json:"action"`
@@ -109,7 +100,7 @@ func postServerPower(c *gin.Context) {
 
 // Sends an array of commands to a running server instance.
 func postServerCommands(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	if running, err := s.Environment.IsRunning(); err != nil {
 		NewServerError(err, s).Abort(c)
@@ -140,7 +131,7 @@ func postServerCommands(c *gin.Context) {
 
 // Updates information about a server internally.
 func patchServer(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	buf := bytes.Buffer{}
 	buf.ReadFrom(c.Request.Body)
@@ -157,7 +148,7 @@ func patchServer(c *gin.Context) {
 
 // Performs a server installation in a background thread.
 func postServerInstall(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	go func(serv *server.Server) {
 		if err := serv.Install(true); err != nil {
@@ -170,7 +161,7 @@ func postServerInstall(c *gin.Context) {
 
 // Reinstalls a server.
 func postServerReinstall(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	if s.ExecutingPowerAction() {
 		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
@@ -190,7 +181,7 @@ func postServerReinstall(c *gin.Context) {
 
 // Deletes a server from the wings daemon and dissociate it's objects.
 func deleteServer(c *gin.Context) {
-	s := ExtractServer(c)
+	s := middleware.ExtractServer(c)
 
 	// Immediately suspend the server to prevent a user from attempting
 	// to start it while this process is running.
@@ -203,12 +194,6 @@ func deleteServer(c *gin.Context) {
 	s.Events().Destroy()
 	s.Websockets().CancelAll()
 
-	// Delete the server's archive if it exists. We intentionally don't return
-	// here, if the archive fails to delete, the server can still be removed.
-	if err := s.Archiver.DeleteIfExists(); err != nil {
-		s.Log().WithField("error", err).Warn("failed to delete server archive during deletion process")
-	}
-
 	// Remove any pending remote file downloads for the server.
 	for _, dl := range downloader.ByServer(s.Id()) {
 		dl.Cancel()
@@ -234,9 +219,8 @@ func deleteServer(c *gin.Context) {
 		}
 	}(s.Filesystem().Path())
 
-	uuid := s.Id()
-	server.GetServers().Remove(func(s2 *server.Server) bool {
-		return s2.Id() == uuid
+	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
+		return server.Id() == s.Id()
 	})
 
 	// Deallocate the reference to this server.

router/router_server_backup.go

@@ -1,65 +1,181 @@
 package router
 
 import (
-	"fmt"
 	"net/http"
 	"os"
+	"strings"
 
 	"emperror.dev/errors"
+	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/backup"
 )
 
-// Backs up a server.
+// postServerBackup performs a backup against a given server instance using the
+// provided backup adapter.
 func postServerBackup(c *gin.Context) {
-	s := GetServer(c.Param("server"))
-
-	data := &backup.Request{}
-	// BindJSON sends 400 if the request fails, all we need to do is return
+	s := middleware.ExtractServer(c)
+	client := middleware.ExtractApiClient(c)
+	logger := middleware.ExtractLogger(c)
+	var data struct {
+		Adapter backup.AdapterType `json:"adapter"`
+		Uuid    string             `json:"uuid"`
+		Ignore  string             `json:"ignore"`
+	}
 	if err := c.BindJSON(&data); err != nil {
 		return
 	}
 
 	var adapter backup.BackupInterface
-	var err error
-
 	switch data.Adapter {
 	case backup.LocalBackupAdapter:
-		adapter, err = data.NewLocalBackup()
+		adapter = backup.NewLocal(client, data.Uuid, data.Ignore)
 	case backup.S3BackupAdapter:
-		adapter, err = data.NewS3Backup()
+		adapter = backup.NewS3(client, data.Uuid, data.Ignore)
 	default:
-		err = errors.New(fmt.Sprintf("unknown backup adapter [%s] provided", data.Adapter))
+		middleware.CaptureAndAbort(c, errors.New("router/backups: provided adapter is not valid: "+string(data.Adapter)))
 		return
 	}
 
-	if err != nil {
-		NewServerError(err, s).Abort(c)
-		return
-	}
-
-	// Attach the server ID to the backup log output for easier parsing.
+	// Attach the server ID and the request ID to the adapter log context for easier
+	// parsing in the logs.
 	adapter.WithLogContext(map[string]interface{}{
-		"server": s.Id(),
+		"server":     s.Id(),
+		"request_id": c.GetString("request_id"),
 	})
 
-	go func(b backup.BackupInterface, serv *server.Server) {
-		if err := serv.Backup(b); err != nil {
-			serv.Log().WithField("error", errors.WithStackIf(err)).Error("failed to generate backup for server")
+	go func(b backup.BackupInterface, s *server.Server, logger *log.Entry) {
+		if err := s.Backup(b); err != nil {
+			logger.WithField("error", errors.WithStackIf(err)).Error("router: failed to generate server backup")
 		}
-	}(adapter, s)
+	}(adapter, s, logger)
 
 	c.Status(http.StatusAccepted)
 }
 
-// Deletes a local backup of a server. If the backup is not found on the machine just return
-// a 404 error. The service calling this endpoint can make its own decisions as to how it wants
-// to handle that response.
-func deleteServerBackup(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+// postServerRestoreBackup handles restoring a backup for a server by downloading
+// or finding the given backup on the system and then unpacking the archive into
+// the server's data directory. If the TruncateDirectory field is provided and
+// is true all of the files will be deleted for the server.
+//
+// This endpoint will block until the backup is fully restored allowing for a
+// spinner to be displayed in the Panel UI effectively.
+//
+// TODO: stop the server if it is running
+func postServerRestoreBackup(c *gin.Context) {
+	s := middleware.ExtractServer(c)
+	client := middleware.ExtractApiClient(c)
+	logger := middleware.ExtractLogger(c)
 
-	b, _, err := backup.LocateLocal(c.Param("backup"))
+	var data struct {
+		Adapter           backup.AdapterType `binding:"required,oneof=wings s3" json:"adapter"`
+		TruncateDirectory bool               `json:"truncate_directory"`
+		// A UUID is always required for this endpoint, however the download URL
+		// is only present when the given adapter type is s3.
+		DownloadUrl string `json:"download_url"`
+	}
+	if err := c.BindJSON(&data); err != nil {
+		return
+	}
+	if data.Adapter == backup.S3BackupAdapter && data.DownloadUrl == "" {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "The download_url field is required when the backup adapter is set to S3."})
+		return
+	}
+
+	s.SetRestoring(true)
+	hasError := true
+	defer func() {
+		if !hasError {
+			return
+		}
+
+		s.SetRestoring(false)
+	}()
+
+	logger.Info("processing server backup restore request")
+	if data.TruncateDirectory {
+		logger.Info("received \"truncate_directory\" flag in request: deleting server files")
+		if err := s.Filesystem().TruncateRootDirectory(); err != nil {
+			middleware.CaptureAndAbort(c, err)
+			return
+		}
+	}
+
+	// Now that we've cleaned up the data directory if necessary, grab the backup file
+	// and attempt to restore it into the server directory.
+	if data.Adapter == backup.LocalBackupAdapter {
+		b, _, err := backup.LocateLocal(client, c.Param("backup"))
+		if err != nil {
+			middleware.CaptureAndAbort(c, err)
+			return
+		}
+		go func(s *server.Server, b backup.BackupInterface, logger *log.Entry) {
+			logger.Info("starting restoration process for server backup using local driver")
+			if err := s.RestoreBackup(b, nil); err != nil {
+				logger.WithField("error", err).Error("failed to restore local backup to server")
+			}
+			s.Events().Publish(server.DaemonMessageEvent, "Completed server restoration from local backup.")
+			s.Events().Publish(server.BackupRestoreCompletedEvent, "")
+			logger.Info("completed server restoration from local backup")
+			s.SetRestoring(false)
+		}(s, b, logger)
+		hasError = false
+		c.Status(http.StatusAccepted)
+		return
+	}
+
+	// Since this is not a local backup we need to stream the archive and then
+	// parse over the contents as we go in order to restore it to the server.
+	httpClient := http.Client{}
+	logger.Info("downloading backup from remote location...")
+	// TODO: this will hang if there is an issue. We can't use c.Request.Context() (or really any)
+	//  since it will be canceled when the request is closed which happens quickly since we push
+	//  this into the background.
+	//
+	// For now I'm just using the server context so at least the request is canceled if
+	// the server gets deleted.
+	req, err := http.NewRequestWithContext(s.Context(), http.MethodGet, data.DownloadUrl, nil)
+	if err != nil {
+		middleware.CaptureAndAbort(c, err)
+		return
+	}
+	res, err := httpClient.Do(req)
+	if err != nil {
+		middleware.CaptureAndAbort(c, err)
+		return
+	}
+	// Don't allow content types that we know are going to give us problems.
+	if res.Header.Get("Content-Type") == "" || !strings.Contains("application/x-gzip application/gzip", res.Header.Get("Content-Type")) {
+		_ = res.Body.Close()
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": "The provided backup link is not a supported content type. \"" + res.Header.Get("Content-Type") + "\" is not application/x-gzip.",
+		})
+		return
+	}
+
+	go func(s *server.Server, uuid string, logger *log.Entry) {
+		logger.Info("starting restoration process for server backup using S3 driver")
+		if err := s.RestoreBackup(backup.NewS3(client, uuid, ""), res.Body); err != nil {
+			logger.WithField("error", errors.WithStack(err)).Error("failed to restore remote S3 backup to server")
+		}
+		s.Events().Publish(server.DaemonMessageEvent, "Completed server restoration from S3 backup.")
+		s.Events().Publish(server.BackupRestoreCompletedEvent, "")
+		logger.Info("completed server restoration from S3 backup")
+		s.SetRestoring(false)
+	}(s, c.Param("backup"), logger)
+
+	hasError = false
+	c.Status(http.StatusAccepted)
+}
+
+// deleteServerBackup deletes a local backup of a server. If the backup is not
+// found on the machine just return a 404 error. The service calling this
+// endpoint can make its own decisions as to how it wants to handle that
+// response.
+func deleteServerBackup(c *gin.Context) {
+	b, _, err := backup.LocateLocal(middleware.ExtractApiClient(c), c.Param("backup"))
 	if err != nil {
 		// Just return from the function at this point if the backup was not located.
 		if errors.Is(err, os.ErrNotExist) {
@@ -68,20 +184,15 @@ func deleteServerBackup(c *gin.Context) {
 			})
 			return
 		}
-
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
-
-	if err := b.Remove(); err != nil {
-		// I'm not entirely sure how likely this is to happen, however if we did manage to locate
-		// the backup previously and it is now missing when we go to delete, just treat it as having
-		// been successful, rather than returning a 404.
-		if !errors.Is(err, os.ErrNotExist) {
-			NewServerError(err, s).Abort(c)
-			return
-		}
+	// I'm not entirely sure how likely this is to happen, however if we did manage to
+	// locate the backup previously and it is now missing when we go to delete, just
+	// treat it as having been successful, rather than returning a 404.
+	if err := b.Remove(); err != nil && !errors.Is(err, os.ErrNotExist) {
+		middleware.CaptureAndAbort(c, err)
+		return
 	}
-
 	c.Status(http.StatusNoContent)
 }

router/router_server_files.go

@@ -1,7 +1,9 @@
 package router
 
 import (
+	"bufio"
 	"context"
+	"io"
 	"mime/multipart"
 	"net/http"
 	"net/url"
@@ -15,47 +17,49 @@ import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/pterodactyl/wings/router/downloader"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"golang.org/x/sync/errgroup"
 )
 
-// Returns the contents of a file on the server.
+// getServerFileContents returns the contents of a file on the server.
 func getServerFileContents(c *gin.Context) {
-	s := ExtractServer(c)
-	f := c.Query("file")
-	p := "/" + strings.TrimLeft(f, "/")
-	st, err := s.Filesystem().Stat(p)
+	s := middleware.ExtractServer(c)
+	p := "/" + strings.TrimLeft(c.Query("file"), "/")
+	f, st, err := s.Filesystem().File(p)
 	if err != nil {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
+	defer f.Close()
 
 	c.Header("X-Mime-Type", st.Mimetype)
-	c.Header("Content-Length", strconv.Itoa(int(st.Info.Size())))
-
+	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
 	// If a download parameter is included in the URL go ahead and attach the necessary headers
 	// so that the file can be downloaded.
 	if c.Query("download") != "" {
-		c.Header("Content-Disposition", "attachment; filename="+st.Info.Name())
+		c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
 		c.Header("Content-Type", "application/octet-stream")
 	}
-
-	// TODO(dane): should probably come up with a different approach here. If an error is encountered
-	//  by this Readfile call you'll end up causing a (recovered) panic in the program because so many
-	//  headers have already been set. We should probably add a RawReadfile that just returns the file
-	//  to be read and then we can stream from that safely without error.
+	defer c.Writer.Flush()
+	// If you don't do a limited reader here you will trigger a panic on write when
+	// a different server process writes content to the file after you've already
+	// determined the file size. This could lead to some weird content output but
+	// it would technically be accurate based on the content at the time of the request.
 	//
-	// Until that becomes a problem though I'm just going to leave this how it is. The panic is recovered
-	// and a normal 500 error is returned to the client to my knowledge. It is also very unlikely to
-	// happen since we're doing so much before this point that would normally throw an error if there
-	// was a problem with the file.
-	if err := s.Filesystem().Readfile(p, c.Writer); err != nil {
-		WithError(c, err)
+	// "http: wrote more than the declared Content-Length"
+	//
+	// @see https://github.com/pterodactyl/panel/issues/3131
+	r := io.LimitReader(f, st.Size())
+	if _, err = bufio.NewReader(r).WriteTo(c.Writer); err != nil {
+		// Pretty sure this will unleash chaos on the response, but its a risk we can
+		// take since a panic will at least be recovered and this should be incredibly
+		// rare?
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
-	c.Writer.Flush()
 }
 
 // Returns the contents of a directory for a server.
@@ -76,7 +80,7 @@ type renameFile struct {
 
 // Renames (or moves) files for a server.
 func putServerRenameFiles(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Root  string       `json:"root"`
@@ -94,8 +98,7 @@ func putServerRenameFiles(c *gin.Context) {
 		return
 	}
 
-	g, ctx := errgroup.WithContext(context.Background())
-
+	g, ctx := errgroup.WithContext(c.Request.Context())
 	// Loop over the array of files passed in and perform the move or rename action against each.
 	for _, p := range data.Files {
 		pf := path.Join(data.Root, p.From)
@@ -106,16 +109,20 @@ func putServerRenameFiles(c *gin.Context) {
 			case <-ctx.Done():
 				return ctx.Err()
 			default:
-				if err := s.Filesystem().Rename(pf, pt); err != nil {
+				fs := s.Filesystem()
+				// Ignore renames on a file that is on the denylist (both as the rename from or
+				// the rename to value).
+				if err := fs.IsIgnored(pf, pt); err != nil {
+					return err
+				}
+				if err := fs.Rename(pf, pt); err != nil {
 					// Return nil if the error is an is not exists.
 					// NOTE: os.IsNotExist() does not work if the error is wrapped.
 					if errors.Is(err, os.ErrNotExist) {
 						return nil
 					}
-
 					return err
 				}
-
 				return nil
 			}
 		})
@@ -138,7 +145,7 @@ func putServerRenameFiles(c *gin.Context) {
 
 // Copies a server file.
 func postServerCopyFile(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Location string `json:"location"`
@@ -148,6 +155,10 @@ func postServerCopyFile(c *gin.Context) {
 		return
 	}
 
+	if err := s.Filesystem().IsIgnored(data.Location); err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	}
 	if err := s.Filesystem().Copy(data.Location); err != nil {
 		NewServerError(err, s).AbortFilesystemError(c)
 		return
@@ -158,7 +169,7 @@ func postServerCopyFile(c *gin.Context) {
 
 // Deletes files from a server.
 func postServerDeleteFiles(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Root  string   `json:"root"`
@@ -203,11 +214,15 @@ func postServerDeleteFiles(c *gin.Context) {
 
 // Writes the contents of the request to a file on a server.
 func postServerWriteFile(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	f := c.Query("file")
 	f = "/" + strings.TrimLeft(f, "/")
 
+	if err := s.Filesystem().IsIgnored(f); err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	}
 	if err := s.Filesystem().Writefile(f, c.Request.Body); err != nil {
 		if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) {
 			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
@@ -300,7 +315,7 @@ func deleteServerPullRemoteFile(c *gin.Context) {
 
 // Create a directory on a server.
 func postServerCreateDirectory(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Name string `json:"name"`
@@ -327,7 +342,7 @@ func postServerCreateDirectory(c *gin.Context) {
 }
 
 func postServerCompressFiles(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		RootPath string   `json:"root"`
@@ -359,69 +374,52 @@ func postServerCompressFiles(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, &filesystem.Stat{
-		Info:     f,
+		FileInfo: f,
 		Mimetype: "application/tar+gzip",
 	})
 }
 
+// postServerDecompressFiles receives the HTTP request and starts the process
+// of unpacking an archive that exists on the server into the provided RootPath
+// for the server.
 func postServerDecompressFiles(c *gin.Context) {
-	s := GetServer(c.Param("server"))
-
 	var data struct {
 		RootPath string `json:"root"`
 		File     string `json:"file"`
 	}
-
 	if err := c.BindJSON(&data); err != nil {
 		return
 	}
 
-	hasSpace, err := s.Filesystem().SpaceAvailableForDecompression(data.RootPath, data.File)
+	s := middleware.ExtractServer(c)
+	lg := middleware.ExtractLogger(c).WithFields(log.Fields{"root_path": data.RootPath, "file": data.File})
+	lg.Debug("checking if space is available for file decompression")
+	err := s.Filesystem().SpaceAvailableForDecompression(data.RootPath, data.File)
 	if err != nil {
-		// Handle an unknown format error.
 		if filesystem.IsErrorCode(err, filesystem.ErrCodeUnknownArchive) {
-			s.Log().WithField("error", err).Warn("failed to decompress file due to unknown format")
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "unknown archive format",
-			})
+			lg.WithField("error", err).Warn("failed to decompress file: unknown archive format")
+			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "The archive provided is in a format Wings does not understand."})
 			return
 		}
-
-		NewServerError(err, s).Abort(c)
-		return
-	}
-
-	if !hasSpace {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "This server does not have enough available disk space to decompress this archive.",
-		})
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
+	lg.Info("starting file decompression")
 	if err := s.Filesystem().DecompressFile(data.RootPath, data.File); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-				"error": "The requested archive was not found.",
-			})
-			return
-		}
-
 		// If the file is busy for some reason just return a nicer error to the user since there is not
 		// much we specifically can do. They'll need to stop the running server process in order to overwrite
 		// a file like this.
 		if strings.Contains(err.Error(), "text file busy") {
-			s.Log().WithField("error", err).Warn("failed to decompress file due to busy text file")
-
+			lg.WithField("error", errors.WithStackIf(err)).Warn("failed to decompress file: text file busy")
 			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 				"error": "One or more files this archive is attempting to overwrite are currently in use by another process. Please try again.",
 			})
 			return
 		}
-
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
-
 	c.Status(http.StatusNoContent)
 }
 
@@ -433,7 +431,7 @@ type chmodFile struct {
 var errInvalidFileMode = errors.New("invalid file mode")
 
 func postServerChmodFile(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	s := ExtractServer(c)
 
 	var data struct {
 		Root  string      `json:"root"`
@@ -497,14 +495,16 @@ func postServerChmodFile(c *gin.Context) {
 }
 
 func postServerUploadFiles(c *gin.Context) {
+	manager := middleware.ExtractManager(c)
+
 	token := tokens.UploadPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
 		NewTrackedError(err).Abort(c)
 		return
 	}
 
-	s := GetServer(token.ServerUuid)
-	if s == nil || !token.IsUniqueRequest() {
+	s, ok := manager.Get(token.ServerUuid)
+	if !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
@@ -537,14 +537,14 @@ func postServerUploadFiles(c *gin.Context) {
 	for _, header := range headers {
 		p, err := s.Filesystem().SafePath(filepath.Join(directory, header.Filename))
 		if err != nil {
-			NewServerError(err, s).AbortFilesystemError(c)
+			NewServerError(err, s).Abort(c)
 			return
 		}
 
 		// We run this in a different method so I can use defer without any of
 		// the consequences caused by calling it in a loop.
 		if err := handleFileUpload(p, s, header); err != nil {
-			NewServerError(err, s).AbortFilesystemError(c)
+			NewServerError(err, s).Abort(c)
 			return
 		}
 	}
@@ -557,6 +557,9 @@ func handleFileUpload(p string, s *server.Server, header *multipart.FileHeader)
 	}
 	defer file.Close()
 
+	if err := s.Filesystem().IsIgnored(p); err != nil {
+		return err
+	}
 	if err := s.Filesystem().Writefile(p, file); err != nil {
 		return err
 	}

router/router_server_ws.go

@@ -7,12 +7,14 @@ import (
 
 	"github.com/gin-gonic/gin"
 	ws "github.com/gorilla/websocket"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/websocket"
 )
 
 // Upgrades a connection to a websocket and passes events along between.
 func getServerWebsocket(c *gin.Context) {
-	s := GetServer(c.Param("server"))
+	manager := middleware.ExtractManager(c)
+	s, _ := manager.Get(c.Param("server"))
 	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
 	if err != nil {
 		NewServerError(err, s).Abort(c)

router/router_system.go

@@ -9,6 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/installer"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/system"
 )
@@ -28,16 +29,22 @@ func getSystemInformation(c *gin.Context) {
 // Returns all of the servers that are registered and configured correctly on
 // this wings instance.
 func getAllServers(c *gin.Context) {
-	c.JSON(http.StatusOK, server.GetServers().All())
+	servers := middleware.ExtractManager(c).All()
+	out := make([]server.APIResponse, len(servers), len(servers))
+	for i, v := range servers {
+		out[i] = v.ToAPIResponse()
+	}
+	c.JSON(http.StatusOK, out)
 }
 
 // Creates a new server on the wings daemon and begins the installation process
 // for it.
 func postCreateServer(c *gin.Context) {
+	manager := middleware.ExtractManager(c)
 	buf := bytes.Buffer{}
 	buf.ReadFrom(c.Request.Body)
 
-	install, err := installer.New(buf.Bytes())
+	install, err := installer.New(c.Request.Context(), manager, buf.Bytes())
 	if err != nil {
 		if installer.IsValidationError(err) {
 			c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
@@ -46,13 +53,13 @@ func postCreateServer(c *gin.Context) {
 			return
 		}
 
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
 	// Plop that server instance onto the request so that it can be referenced in
 	// requests from here-on out.
-	server.GetServers().Add(install.Server())
+	manager.Add(install.Server())
 
 	// Begin the installation process in the background to not block the request
 	// cycle. If there are any errors they will be logged and communicated back
@@ -72,37 +79,29 @@ func postCreateServer(c *gin.Context) {
 	c.Status(http.StatusAccepted)
 }
 
-// Updates the running configuration for this daemon instance.
+// Updates the running configuration for this Wings instance.
 func postUpdateConfiguration(c *gin.Context) {
-	// A backup of the configuration for error purposes.
-	ccopy := *config.Get()
-	// A copy of the configuration we're using to bind the data received into.
-	cfg := *config.Get()
-
-	// BindJSON sends 400 if the request fails, all we need to do is return
+	cfg := config.Get()
 	if err := c.BindJSON(&cfg); err != nil {
 		return
 	}
-
 	// Keep the SSL certificates the same since the Panel will send through Lets Encrypt
 	// default locations. However, if we picked a different location manually we don't
 	// want to override that.
 	//
 	// If you pass through manual locations in the API call this logic will be skipped.
 	if strings.HasPrefix(cfg.Api.Ssl.KeyFile, "/etc/letsencrypt/live/") {
-		cfg.Api.Ssl.KeyFile = strings.ToLower(ccopy.Api.Ssl.KeyFile)
-		cfg.Api.Ssl.CertificateFile = strings.ToLower(ccopy.Api.Ssl.CertificateFile)
+		cfg.Api.Ssl.KeyFile = strings.ToLower(config.Get().Api.Ssl.KeyFile)
+		cfg.Api.Ssl.CertificateFile = strings.ToLower(config.Get().Api.Ssl.CertificateFile)
 	}
-
-	config.Set(&cfg)
-	if err := config.Get().WriteToDisk(); err != nil {
-		// If there was an error writing to the disk, revert back to the configuration we had
-		// before this code was run.
-		config.Set(&ccopy)
-
-		NewTrackedError(err).Abort(c)
+	// Try to write this new configuration to the disk before updating our global
+	// state with it.
+	if err := config.WriteToDisk(cfg); err != nil {
+		WithError(c, err)
 		return
 	}
-
+	// Since we wrote it to the disk successfully now update the global configuration
+	// state to use this new configuration struct.
+	config.Set(cfg)
 	c.Status(http.StatusNoContent)
 }

router/router_transfer.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"bufio"
+	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
@@ -22,11 +23,13 @@ import (
 	"github.com/juju/ratelimit"
 	"github.com/mholt/archiver/v3"
 	"github.com/mitchellh/colorstring"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/installer"
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server/filesystem"
 	"github.com/pterodactyl/wings/system"
 )
 
@@ -49,6 +52,10 @@ type serverTransferRequest struct {
 	Server   json.RawMessage `json:"server"`
 }
 
+func getArchivePath(sID string) string {
+	return filepath.Join(config.Get().System.ArchiveDirectory, sID+".tar.gz")
+}
+
 // Returns the archive for a server so that it can be transferred to a new node.
 func getServerArchive(c *gin.Context) {
 	auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
@@ -75,43 +82,58 @@ func getServerArchive(c *gin.Context) {
 		return
 	}
 
-	st, err := s.Archiver.Stat()
+	archivePath := getArchivePath(s.Id())
+
+	// Stat the archive file.
+	st, err := os.Lstat(archivePath)
 	if err != nil {
 		if !errors.Is(err, os.ErrNotExist) {
-			WithError(c, err)
+			_ = WithError(c, err)
 			return
 		}
 		c.AbortWithStatus(http.StatusNotFound)
 		return
 	}
 
-	checksum, err := s.Archiver.Checksum()
+	// Compute sha1 checksum.
+	h := sha256.New()
+	f, err := os.Open(archivePath)
 	if err != nil {
-		NewServerError(err, s).SetMessage("failed to calculate checksum").Abort(c)
 		return
 	}
+	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
+		_ = f.Close()
+		_ = WithError(c, err)
+		return
+	}
+	if err := f.Close(); err != nil {
+		_ = WithError(c, err)
+		return
+	}
+	checksum := hex.EncodeToString(h.Sum(nil))
 
-	file, err := os.Open(s.Archiver.Path())
+	// Stream the file to the client.
+	f, err = os.Open(archivePath)
 	if err != nil {
-		WithError(c, err)
+		_ = WithError(c, err)
 		return
 	}
-	defer file.Close()
+	defer f.Close()
 
 	c.Header("X-Checksum", checksum)
-	c.Header("X-Mime-Type", st.Mimetype)
-	c.Header("Content-Length", strconv.Itoa(int(st.Info.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+s.Archiver.Name())
+	c.Header("X-Mime-Type", "application/tar+gzip")
+	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(s.Id()+".tar.gz"))
 	c.Header("Content-Type", "application/octet-stream")
 
-	bufio.NewReader(file).WriteTo(c.Writer)
+	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
 }
 
 func postServerArchive(c *gin.Context) {
-	s := ExtractServer(c)
+	s := middleware.ExtractServer(c)
+	manager := middleware.ExtractManager(c)
 
 	go func(s *server.Server) {
-		r := api.New()
 		l := log.WithField("server", s.Id())
 
 		// This function automatically adds the Source Node prefix and Timestamp to the log
@@ -132,12 +154,11 @@ func postServerArchive(c *gin.Context) {
 
 			// Mark the server as not being transferred so it can actually be used.
 			s.SetTransferring(false)
-
 			s.Events().Publish(server.TransferStatusEvent, "failure")
 
 			sendTransferLog("Attempting to notify panel of archive failure..")
-			if err := r.SendArchiveStatus(s.Id(), false); err != nil {
-				if !api.IsRequestError(err) {
+			if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), false); err != nil {
+				if !remote.IsRequestError(err) {
 					sendTransferLog("Failed to notify panel of archive failure: " + err.Error())
 					l.WithField("error", err).Error("failed to notify panel of failed archive status")
 					return
@@ -163,8 +184,13 @@ func postServerArchive(c *gin.Context) {
 			return
 		}
 
+		// Create an archive of the entire server's data directory.
+		a := &filesystem.Archive{
+			BasePath: s.Filesystem().Path(),
+		}
+
 		// Attempt to get an archive of the server.
-		if err := s.Archiver.Archive(); err != nil {
+		if err := a.Create(getArchivePath(s.Id())); err != nil {
 			sendTransferLog("An error occurred while archiving the server: " + err.Error())
 			l.WithField("error", err).Error("failed to get transfer archive for server")
 			return
@@ -173,8 +199,8 @@ func postServerArchive(c *gin.Context) {
 		sendTransferLog("Successfully created archive, attempting to notify panel..")
 		l.Info("successfully created server transfer archive, notifying panel..")
 
-		if err := r.SendArchiveStatus(s.Id(), true); err != nil {
-			if !api.IsRequestError(err) {
+		if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), true); err != nil {
+			if !remote.IsRequestError(err) {
 				sendTransferLog("Failed to notify panel of archive success: " + err.Error())
 				l.WithField("error", err).Error("failed to notify panel of successful archive status")
 				return
@@ -226,7 +252,7 @@ func (str serverTransferRequest) downloadArchive() (*http.Response, error) {
 
 // Returns the path to the local archive on the system.
 func (str serverTransferRequest) path() string {
-	return filepath.Join(config.Get().System.ArchiveDirectory, str.ServerID+".tar.gz")
+	return getArchivePath(str.ServerID)
 }
 
 // Creates the archive location on this machine by first checking that the required file
@@ -259,25 +285,24 @@ func (str serverTransferRequest) removeArchivePath() {
 // expected value from the transfer request. The string value returned is the computed
 // checksum on the system.
 func (str serverTransferRequest) verifyChecksum(matches string) (bool, string, error) {
-	file, err := os.Open(str.path())
+	f, err := os.Open(str.path())
 	if err != nil {
 		return false, "", err
 	}
-	defer file.Close()
-	hash := sha256.New()
-	buf := make([]byte, 1024*4)
-	if _, err := io.CopyBuffer(hash, file, buf); err != nil {
+	defer f.Close()
+	h := sha256.New()
+	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
 		return false, "", err
 	}
-	checksum := hex.EncodeToString(hash.Sum(nil))
+	checksum := hex.EncodeToString(h.Sum(nil))
 	return checksum == matches, checksum, nil
 }
 
 // Sends a notification to the Panel letting it know what the status of this transfer is.
-func (str serverTransferRequest) sendTransferStatus(successful bool) error {
+func (str serverTransferRequest) sendTransferStatus(client remote.Client, successful bool) error {
 	lg := str.log().WithField("transfer_successful", successful)
 	lg.Info("notifying Panel of server transfer state")
-	if err := api.New().SendTransferStatus(str.ServerID, successful); err != nil {
+	if err := client.SetTransferStatus(context.Background(), str.ServerID, successful); err != nil {
 		lg.WithField("error", err).Error("error notifying panel of transfer state")
 		return err
 	}
@@ -293,6 +318,7 @@ func postTransfer(c *gin.Context) {
 		return
 	}
 
+	manager := middleware.ExtractManager(c)
 	u, err := uuid.Parse(data.ServerID)
 	if err != nil {
 		WithError(c, err)
@@ -309,9 +335,9 @@ func postTransfer(c *gin.Context) {
 
 		// Create a new server installer. This will only configure the environment and not
 		// run the installer scripts.
-		i, err := installer.New(data.Server)
+		i, err := installer.New(context.Background(), manager, data.Server)
 		if err != nil {
-			_ = data.sendTransferStatus(false)
+			_ = data.sendTransferStatus(manager.Client(), false)
 			data.log().WithField("error", err).Error("failed to validate received server data")
 			return
 		}
@@ -326,15 +352,15 @@ func postTransfer(c *gin.Context) {
 		// Mark the server as transferring to prevent problems later on during the process and
 		// then push the server into the global server collection for this instance.
 		i.Server().SetTransferring(true)
-		server.GetServers().Add(i.Server())
+		manager.Add(i.Server())
 		defer func(s *server.Server) {
 			// In the event that this transfer call fails, remove the server from the global
 			// server tracking so that we don't have a dangling instance.
-			if err := data.sendTransferStatus(!hasError); hasError || err != nil {
+			if err := data.sendTransferStatus(manager.Client(), !hasError); hasError || err != nil {
 				sendTransferLog("Server transfer failed, check Wings logs for additional information.")
 				s.Events().Publish(server.TransferStatusEvent, "failure")
-				server.GetServers().Remove(func(s2 *server.Server) bool {
-					return s.Id() == s2.Id()
+				manager.Remove(func(match *server.Server) bool {
+					return match.Id() == s.Id()
 				})
 
 				// If the transfer status was successful but the request failed, act like the transfer failed.
@@ -360,7 +386,7 @@ func postTransfer(c *gin.Context) {
 			return
 		}
 		defer res.Body.Close()
-		if res.StatusCode != 200 {
+		if res.StatusCode != http.StatusOK {
 			data.log().WithField("error", err).WithField("status", res.StatusCode).Error("unexpected error response from transfer endpoint")
 			return
 		}

router/websocket/listeners.go

@@ -45,6 +45,7 @@ var e = []string{
 	server.InstallCompletedEvent,
 	server.DaemonMessageEvent,
 	server.BackupCompletedEvent,
+	server.BackupRestoreCompletedEvent,
 	server.TransferLogsEvent,
 	server.TransferStatusEvent,
 }

server/archiver.go

@@ -1,120 +0,0 @@
-package server
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	"emperror.dev/errors"
-	"github.com/mholt/archiver/v3"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server/filesystem"
-)
-
-// Archiver represents a Server Archiver.
-type Archiver struct {
-	Server *Server
-}
-
-// Path returns the path to the server's archive.
-func (a *Archiver) Path() string {
-	return filepath.Join(config.Get().System.ArchiveDirectory, a.Name())
-}
-
-// Name returns the name of the server's archive.
-func (a *Archiver) Name() string {
-	return a.Server.Id() + ".tar.gz"
-}
-
-// Exists returns a boolean based off if the archive exists.
-func (a *Archiver) Exists() bool {
-	if _, err := os.Stat(a.Path()); os.IsNotExist(err) {
-		return false
-	}
-
-	return true
-}
-
-// Stat stats the archive file.
-func (a *Archiver) Stat() (*filesystem.Stat, error) {
-	s, err := os.Stat(a.Path())
-	if err != nil {
-		return nil, err
-	}
-
-	return &filesystem.Stat{
-		Info:     s,
-		Mimetype: "application/tar+gzip",
-	}, nil
-}
-
-// Archive creates an archive of the server and deletes the previous one.
-func (a *Archiver) Archive() error {
-	path := a.Server.Filesystem().Path()
-
-	// Get the list of root files and directories to archive.
-	var files []string
-	fileInfo, err := ioutil.ReadDir(path)
-	if err != nil {
-		return err
-	}
-
-	for _, file := range fileInfo {
-		f := filepath.Join(path, file.Name())
-		// If the file is a symlink we cannot safely assume that the result of a filepath.Join() will be
-		// a safe destination. We need to check if the file is a symlink, and if so pass off to the SafePath
-		// function to resolve it to the final destination.
-		//
-		// ioutil.ReadDir() calls Lstat, so this will work correctly. If it did not call Lstat, but rather
-		// just did a normal Stat call, this would fail since that would be looking at the symlink destination
-		// and not the actual file in this listing.
-		if file.Mode()&os.ModeSymlink != 0 {
-			f, err = a.Server.Filesystem().SafePath(filepath.Join(path, file.Name()))
-			if err != nil {
-				return err
-			}
-		}
-
-		files = append(files, f)
-	}
-
-	if err := a.DeleteIfExists(); err != nil {
-		return err
-	}
-
-	return archiver.NewTarGz().Archive(files, a.Path())
-}
-
-// DeleteIfExists deletes the archive if it exists.
-func (a *Archiver) DeleteIfExists() error {
-	if _, err := a.Stat(); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-
-		return err
-	}
-
-	return errors.WithMessage(os.Remove(a.Path()), "archiver: failed to delete archive from system")
-}
-
-// Checksum computes a SHA256 checksum of the server's archive.
-func (a *Archiver) Checksum() (string, error) {
-	file, err := os.Open(a.Path())
-	if err != nil {
-		return "", err
-	}
-	defer file.Close()
-
-	hash := sha256.New()
-
-	buf := make([]byte, 1024*4)
-	if _, err := io.CopyBuffer(hash, file, buf); err != nil {
-		return "", err
-	}
-
-	return hex.EncodeToString(hash.Sum(nil)), nil
-}

server/backup.go

@@ -1,20 +1,23 @@
 package server
 
 import (
+	"io"
 	"io/ioutil"
 	"os"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
-	"github.com/pterodactyl/wings/api"
+	"github.com/docker/docker/client"
+	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/backup"
 )
 
 // Notifies the panel of a backup's state and returns an error if one is encountered
 // while performing this action.
 func (s *Server) notifyPanelOfBackup(uuid string, ad *backup.ArchiveDetails, successful bool) error {
-	if err := api.New().SendBackupStatus(uuid, ad.ToRequest(successful)); err != nil {
-		if !api.IsRequestError(err) {
+	if err := s.client.SetBackupStatus(s.Context(), uuid, ad.ToRequest(successful)); err != nil {
+		if !remote.IsRequestError(err) {
 			s.Log().WithFields(log.Fields{
 				"backup": uuid,
 				"error":  err,
@@ -50,9 +53,9 @@ func (s *Server) getServerwideIgnoredFiles() (string, error) {
 	return string(b), nil
 }
 
-// Performs a server backup and then emits the event over the server websocket. We
-// let the actual backup system handle notifying the panel of the status, but that
-// won't emit a websocket event.
+// Backup performs a server backup and then emits the event over the server
+// websocket. We let the actual backup system handle notifying the panel of the
+// status, but that won't emit a websocket event.
 func (s *Server) Backup(b backup.BackupInterface) error {
 	ignored := b.Ignored()
 	if b.Ignored() == "" {
@@ -108,3 +111,49 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 
 	return nil
 }
+
+// RestoreBackup calls the Restore function on the provided backup. Once this
+// restoration is completed an event is emitted to the websocket to notify the
+// Panel that is has been completed.
+//
+// In addition to the websocket event an API call is triggered to notify the
+// Panel of the new state.
+func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (err error) {
+	s.Config().SetSuspended(true)
+	// Local backups will not pass a reader through to this function, so check first
+	// to make sure it is a valid reader before trying to close it.
+	defer func() {
+		s.Config().SetSuspended(false)
+		if reader != nil {
+			reader.Close()
+		}
+	}()
+	// Send an API call to the Panel as soon as this function is done running so that
+	// the Panel is informed of the restoration status of this backup.
+	defer func() {
+		if rerr := s.client.SendRestorationStatus(s.Context(), b.Identifier(), err == nil); rerr != nil {
+			s.Log().WithField("error", rerr).WithField("backup", b.Identifier()).Error("failed to notify Panel of backup restoration status")
+		}
+	}()
+
+	// Don't try to restore the server until we have completely stopped the running
+	// instance, otherwise you'll likely hit all types of write errors due to the
+	// server being suspended.
+	if s.Environment.State() != environment.ProcessOfflineState {
+		if err = s.Environment.WaitForStop(120, false); err != nil {
+			if !client.IsErrNotFound(err) {
+				return errors.WrapIf(err, "server/backup: restore: failed to wait for container stop")
+			}
+		}
+	}
+
+	// Attempt to restore the backup to the server by running through each entry
+	// in the file one at a time and writing them to the disk.
+	s.Log().Debug("starting file writing process for backup restoration")
+	err = b.Restore(reader, func(file string, r io.Reader) error {
+		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
+		return s.Filesystem().Writefile(file, r)
+	})
+
+	return errors.WithStackIf(err)
+}

server/backup/backup.go

@@ -3,13 +3,14 @@ package backup
 import (
 	"crypto/sha1"
 	"encoding/hex"
-	"github.com/apex/log"
-	"github.com/pterodactyl/wings/api"
-	"github.com/pterodactyl/wings/config"
 	"io"
 	"os"
 	"path"
 	"sync"
+
+	"github.com/apex/log"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/remote"
 )
 
 type AdapterType string
@@ -19,15 +20,19 @@ const (
 	S3BackupAdapter    AdapterType = "s3"
 )
 
+// RestoreCallback is a generic restoration callback that exists for both local
+// and remote backups allowing the files to be restored.
+type RestoreCallback func(file string, r io.Reader) error
+
 type ArchiveDetails struct {
 	Checksum     string `json:"checksum"`
 	ChecksumType string `json:"checksum_type"`
 	Size         int64  `json:"size"`
 }
 
-// Returns a request object.
-func (ad *ArchiveDetails) ToRequest(successful bool) api.BackupRequest {
-	return api.BackupRequest{
+// ToRequest returns a request object.
+func (ad *ArchiveDetails) ToRequest(successful bool) remote.BackupRequest {
+	return remote.BackupRequest{
 		Checksum:     ad.Checksum,
 		ChecksumType: ad.ChecksumType,
 		Size:         ad.Size,
@@ -44,41 +49,46 @@ type Backup struct {
 	// compatible with a standard .gitignore structure.
 	Ignore string `json:"ignore"`
 
+	client     remote.Client
 	adapter    AdapterType
 	logContext map[string]interface{}
 }
 
 // noinspection GoNameStartsWithPackageName
 type BackupInterface interface {
-	// Returns the UUID of this backup as tracked by the panel instance.
+	// SetClient sets the API request client on the backup interface.
+	SetClient(c remote.Client)
+	// Identifier returns the UUID of this backup as tracked by the panel
+	// instance.
 	Identifier() string
-
-	// Attaches additional context to the log output for this backup.
+	// WithLogContext attaches additional context to the log output for this
+	// backup.
 	WithLogContext(map[string]interface{})
-
-	// Generates a backup in whatever the configured source for the specific
-	// implementation is.
+	// Generate creates a backup in whatever the configured source for the
+	// specific implementation is.
 	Generate(string, string) (*ArchiveDetails, error)
-
-	// Returns the ignored files for this backup instance.
+	// Ignored returns the ignored files for this backup instance.
 	Ignored() string
-
-	// Returns a SHA1 checksum for the generated backup.
+	// Checksum returns a SHA1 checksum for the generated backup.
 	Checksum() ([]byte, error)
-
-	// Returns the size of the generated backup.
+	// Size returns the size of the generated backup.
 	Size() (int64, error)
-
-	// Returns the path to the backup on the machine. This is not always the final
-	// storage location of the backup, simply the location we're using to store
-	// it until it is moved to the final spot.
+	// Path returns the path to the backup on the machine. This is not always
+	// the final storage location of the backup, simply the location we're using
+	// to store it until it is moved to the final spot.
 	Path() string
-
-	// Returns details about the archive.
+	// Details returns details about the archive.
 	Details() *ArchiveDetails
-
-	// Removes a backup file.
+	// Remove removes a backup file.
 	Remove() error
+	// Restore is called when a backup is ready to be restored to the disk from
+	// the given source. Not every backup implementation will support this nor
+	// will every implementation require a reader be provided.
+	Restore(reader io.Reader, callback RestoreCallback) error
+}
+
+func (b *Backup) SetClient(c remote.Client) {
+	b.client = c
 }
 
 func (b *Backup) Identifier() string {

server/backup/backup_local.go

@@ -2,8 +2,13 @@ package backup
 
 import (
 	"errors"
-	"github.com/pterodactyl/wings/server/filesystem"
+	"io"
 	"os"
+
+	"github.com/pterodactyl/wings/server/filesystem"
+
+	"github.com/mholt/archiver/v3"
+	"github.com/pterodactyl/wings/remote"
 )
 
 type LocalBackup struct {
@@ -12,16 +17,21 @@ type LocalBackup struct {
 
 var _ BackupInterface = (*LocalBackup)(nil)
 
-// Locates the backup for a server and returns the local path. This will obviously only
-// work if the backup was created as a local backup.
-func LocateLocal(uuid string) (*LocalBackup, os.FileInfo, error) {
-	b := &LocalBackup{
+func NewLocal(client remote.Client, uuid string, ignore string) *LocalBackup {
+	return &LocalBackup{
 		Backup{
-			Uuid:   uuid,
-			Ignore: "",
+			client:  client,
+			Uuid:    uuid,
+			Ignore:  ignore,
+			adapter: LocalBackupAdapter,
 		},
 	}
+}
 
+// LocateLocal finds the backup for a server and returns the local path. This
+// will obviously only work if the backup was created as a local backup.
+func LocateLocal(client remote.Client, uuid string) (*LocalBackup, os.FileInfo, error) {
+	b := NewLocal(client, uuid, "")
 	st, err := os.Stat(b.Path())
 	if err != nil {
 		return nil, nil, err
@@ -34,18 +44,18 @@ func LocateLocal(uuid string) (*LocalBackup, os.FileInfo, error) {
 	return b, st, nil
 }
 
-// Removes a backup from the system.
+// Remove removes a backup from the system.
 func (b *LocalBackup) Remove() error {
 	return os.Remove(b.Path())
 }
 
-// Attaches additional context to the log output for this backup.
+// WithLogContext attaches additional context to the log output for this backup.
 func (b *LocalBackup) WithLogContext(c map[string]interface{}) {
 	b.logContext = c
 }
 
-// Generates a backup of the selected files and pushes it to the defined location
-// for this instance.
+// Generate generates a backup of the selected files and pushes it to the
+// defined location for this instance.
 func (b *LocalBackup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
 	a := &filesystem.Archive{
 		BasePath: basePath,
@@ -60,3 +70,14 @@ func (b *LocalBackup) Generate(basePath, ignore string) (*ArchiveDetails, error)
 
 	return b.Details(), nil
 }
+
+// Restore will walk over the archive and call the callback function for each
+// file encountered.
+func (b *LocalBackup) Restore(_ io.Reader, callback RestoreCallback) error {
+	return archiver.Walk(b.Path(), func(f archiver.File) error {
+		if f.IsDir() {
+			return nil
+		}
+		return callback(filesystem.ExtractNameFromArchive(f), f)
+	})
+}

server/backup/backup_request.go

@@ -1,42 +0,0 @@
-package backup
-
-import (
-	"errors"
-	"fmt"
-)
-
-type Request struct {
-	Adapter AdapterType `json:"adapter"`
-	Uuid    string      `json:"uuid"`
-	Ignore  string      `json:"ignore"`
-}
-
-// Generates a new local backup struct.
-func (r *Request) NewLocalBackup() (*LocalBackup, error) {
-	if r.Adapter != LocalBackupAdapter {
-		return nil, errors.New(fmt.Sprintf("cannot create local backup using [%s] adapter", r.Adapter))
-	}
-
-	return &LocalBackup{
-		Backup{
-			Uuid:    r.Uuid,
-			Ignore:  r.Ignore,
-			adapter: LocalBackupAdapter,
-		},
-	}, nil
-}
-
-// Generates a new S3 backup struct.
-func (r *Request) NewS3Backup() (*S3Backup, error) {
-	if r.Adapter != S3BackupAdapter {
-		return nil, errors.New(fmt.Sprintf("cannot create s3 backup using [%s] adapter", r.Adapter))
-	}
-
-	return &S3Backup{
-		Backup: Backup{
-			Uuid:    r.Uuid,
-			Ignore:  r.Ignore,
-			adapter: S3BackupAdapter,
-		},
-	}, nil
-}

server/backup/backup_s3.go

@@ -1,13 +1,19 @@
 package backup
 
 import (
+	"archive/tar"
+	"compress/gzip"
+	"context"
 	"fmt"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"io"
 	"net/http"
 	"os"
 	"strconv"
+
+	"github.com/juju/ratelimit"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/remote"
 )
 
 type S3Backup struct {
@@ -16,18 +22,29 @@ type S3Backup struct {
 
 var _ BackupInterface = (*S3Backup)(nil)
 
-// Removes a backup from the system.
+func NewS3(client remote.Client, uuid string, ignore string) *S3Backup {
+	return &S3Backup{
+		Backup{
+			client:  client,
+			Uuid:    uuid,
+			Ignore:  ignore,
+			adapter: S3BackupAdapter,
+		},
+	}
+}
+
+// Remove removes a backup from the system.
 func (s *S3Backup) Remove() error {
 	return os.Remove(s.Path())
 }
 
-// Attaches additional context to the log output for this backup.
+// WithLogContext attaches additional context to the log output for this backup.
 func (s *S3Backup) WithLogContext(c map[string]interface{}) {
 	s.logContext = c
 }
 
-// Generates a new backup on the disk, moves it into the S3 bucket via the provided
-// presigned URL, and then deletes the backup from the disk.
+// Generate creates a new backup on the disk, moves it into the S3 bucket via
+// the provided presigned URL, and then deletes the backup from the disk.
 func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
 	defer s.Remove()
 
@@ -77,7 +94,7 @@ func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
 	s.log().WithField("size", size).Debug("got size of backup")
 
 	s.log().Debug("attempting to get S3 upload urls from Panel...")
-	urls, err := api.New().GetBackupRemoteUploadURLs(s.Backup.Uuid, size)
+	urls, err := s.client.GetBackupRemoteUploadURLs(context.Background(), s.Backup.Uuid, size)
 	if err != nil {
 		return err
 	}
@@ -139,3 +156,40 @@ func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
 
 	return nil
 }
+
+// Restore will read from the provided reader assuming that it is a gzipped
+// tar reader. When a file is encountered in the archive the callback function
+// will be triggered. If the callback returns an error the entire process is
+// stopped, otherwise this function will run until all files have been written.
+//
+// This restoration uses a workerpool to use up to the number of CPUs available
+// on the machine when writing files to the disk.
+func (s *S3Backup) Restore(r io.Reader, callback RestoreCallback) error {
+	reader := r
+	// Steal the logic we use for making backups which will be applied when restoring
+	// this specific backup. This allows us to prevent overloading the disk unintentionally.
+	if writeLimit := int64(config.Get().System.Backups.WriteLimit * 1024 * 1024); writeLimit > 0 {
+		reader = ratelimit.Reader(r, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
+	}
+	gr, err := gzip.NewReader(reader)
+	if err != nil {
+		return err
+	}
+	defer gr.Close()
+	tr := tar.NewReader(gr)
+	for {
+		header, err := tr.Next()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		if header.Typeflag == tar.TypeReg {
+			if err := callback(header.Name, tr); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

server/collection.go

@@ -1,77 +0,0 @@
-package server
-
-import "sync"
-
-type Collection struct {
-	items []*Server
-	sync.RWMutex
-}
-
-// Create a new collection from a slice of servers.
-func NewCollection(servers []*Server) *Collection {
-	return &Collection{
-		items: servers,
-	}
-}
-
-// Return all of the items in the collection.
-func (c *Collection) All() []*Server {
-	c.RLock()
-	defer c.RUnlock()
-
-	return c.items
-}
-
-// Adds an item to the collection store.
-func (c *Collection) Add(s *Server) {
-	c.Lock()
-	c.items = append(c.items, s)
-	c.Unlock()
-}
-
-// Returns only those items matching the filter criteria.
-func (c *Collection) Filter(filter func(*Server) bool) []*Server {
-	c.RLock()
-	defer c.RUnlock()
-
-	r := make([]*Server, 0)
-	for _, v := range c.items {
-		if filter(v) {
-			r = append(r, v)
-		}
-	}
-
-	return r
-}
-
-// Returns a single element from the collection matching the filter. If nothing is
-// found a nil result is returned.
-func (c *Collection) Find(filter func(*Server) bool) *Server {
-	c.RLock()
-	defer c.RUnlock()
-
-	for _, v := range c.items {
-		if filter(v) {
-			return v
-		}
-	}
-
-	return nil
-}
-
-// Removes all items from the collection that match the filter function.
-//
-// TODO: cancel the context?
-func (c *Collection) Remove(filter func(*Server) bool) {
-	c.Lock()
-	defer c.Unlock()
-
-	r := make([]*Server, 0)
-	for _, v := range c.items {
-		if !filter(v) {
-			r = append(r, v)
-		}
-	}
-
-	c.items = r
-}

server/configuration.go

@@ -6,6 +6,16 @@ import (
 	"github.com/pterodactyl/wings/environment"
 )
 
+type EggConfiguration struct {
+	// The internal UUID of the Egg on the Panel.
+	ID string `json:"id"`
+
+	// Maintains a list of files that are blacklisted for opening/editing/downloading
+	// or basically any type of access on the server by any user. This is NOT the same
+	// as a per-user denylist, this is defined at the Egg level.
+	FileDenylist []string `json:"file_denylist"`
+}
+
 type Configuration struct {
 	mu sync.RWMutex
 
@@ -33,7 +43,7 @@ type Configuration struct {
 	Build                 environment.Limits      `json:"build"`
 	CrashDetectionEnabled bool                    `default:"true" json:"enabled" yaml:"enabled"`
 	Mounts                []Mount                 `json:"mounts"`
-	Resources             ResourceUsage           `json:"resources"`
+	Egg                   EggConfiguration        `json:"egg,omitempty"`
 
 	Container struct {
 		// Defines the Docker image that will be used for this server

server/console.go

@@ -13,6 +13,11 @@ import (
 	"github.com/pterodactyl/wings/system"
 )
 
+// appName is a local cache variable to avoid having to make expensive copies of
+// the configuration every time we need to send output along to the websocket for
+// a server.
+var appName string
+
 var ErrTooMuchConsoleData = errors.New("console is outputting too much data")
 
 type ConsoleThrottler struct {
@@ -122,11 +127,14 @@ func (s *Server) Throttler() *ConsoleThrottler {
 	return s.throttler
 }
 
-// Sends output to the server console formatted to appear correctly as being sent
-// from Wings.
+// PublishConsoleOutputFromDaemon sends output to the server console formatted
+// to appear correctly as being sent from Wings.
 func (s *Server) PublishConsoleOutputFromDaemon(data string) {
+	if appName == "" {
+		appName = config.Get().AppName
+	}
 	s.Events().Publish(
 		ConsoleOutputEvent,
-		colorstring.Color(fmt.Sprintf("[yellow][bold][Pterodactyl Daemon]:[default] %s", data)),
+		colorstring.Color(fmt.Sprintf("[yellow][bold][%s Daemon]:[default] %s", appName, data)),
 	)
 }

server/errors.go

@@ -9,6 +9,7 @@ var (
 	ErrSuspended            = errors.New("server is currently in a suspended state")
 	ErrServerIsInstalling   = errors.New("server is currently installing")
 	ErrServerIsTransferring = errors.New("server is currently being transferred")
+	ErrServerIsRestoring    = errors.New("server is currently being restored")
 )
 
 type crashTooFrequent struct {

server/events.go

@@ -7,16 +7,17 @@ import (
 // Defines all of the possible output events for a server.
 // noinspection GoNameStartsWithPackageName
 const (
-	DaemonMessageEvent    = "daemon message"
-	InstallOutputEvent    = "install output"
-	InstallStartedEvent   = "install started"
-	InstallCompletedEvent = "install completed"
-	ConsoleOutputEvent    = "console output"
-	StatusEvent           = "status"
-	StatsEvent            = "stats"
-	BackupCompletedEvent  = "backup completed"
-	TransferLogsEvent     = "transfer logs"
-	TransferStatusEvent   = "transfer status"
+	DaemonMessageEvent          = "daemon message"
+	InstallOutputEvent          = "install output"
+	InstallStartedEvent         = "install started"
+	InstallCompletedEvent       = "install completed"
+	ConsoleOutputEvent          = "console output"
+	StatusEvent                 = "status"
+	StatsEvent                  = "stats"
+	BackupRestoreCompletedEvent = "backup restore completed"
+	BackupCompletedEvent        = "backup completed"
+	TransferLogsEvent           = "transfer logs"
+	TransferStatusEvent         = "transfer status"
 )
 
 // Returns the server's emitter instance.

server/filesystem.go

@@ -1,30 +0,0 @@
-package server
-
-import (
-	"os"
-
-	"github.com/pterodactyl/wings/server/filesystem"
-)
-
-func (s *Server) Filesystem() *filesystem.Filesystem {
-	return s.fs
-}
-
-// Ensures that the data directory for the server instance exists.
-func (s *Server) EnsureDataDirectoryExists() error {
-	if _, err := os.Stat(s.fs.Path()); err != nil && !os.IsNotExist(err) {
-		return err
-	} else if err != nil {
-		// Create the server data directory because it does not currently exist
-		// on the system.
-		if err := os.MkdirAll(s.fs.Path(), 0700); err != nil {
-			return err
-		}
-
-		if err := s.fs.Chown("/"); err != nil {
-			s.Log().WithField("error", err).Warn("failed to chown server data directory")
-		}
-	}
-
-	return nil
-}

server/filesystem/archive.go

@@ -2,6 +2,12 @@ package filesystem
 
 import (
 	"archive/tar"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/juju/ratelimit"
@@ -9,11 +15,6 @@ import (
 	"github.com/klauspost/pgzip"
 	"github.com/pterodactyl/wings/config"
 	"github.com/sabhiram/go-gitignore"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
 )
 
 const memory = 4 * 1024
@@ -39,7 +40,8 @@ type Archive struct {
 	Files []string
 }
 
-// Creates an archive at dst with all of the files defined in the included files struct.
+// Create creates an archive at dst with all of the files defined in the
+// included files struct.
 func (a *Archive) Create(dst string) error {
 	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {

server/filesystem/compress.go

@@ -1,21 +1,30 @@
 package filesystem
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
 	"fmt"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/mholt/archiver/v3"
 )
 
-// Compresses all of the files matching the given paths in the specified directory. This function
-// also supports passing nested paths to only compress certain files and folders when working in
-// a larger directory. This effectively creates a local backup, but rather than ignoring specific
-// files and folders, it takes an allow-list of files and folders.
+// CompressFiles compresses all of the files matching the given paths in the
+// specified directory. This function also supports passing nested paths to only
+// compress certain files and folders when working in a larger directory. This
+// effectively creates a local backup, but rather than ignoring specific files
+// and folders, it takes an allow-list of files and folders.
 //
-// All paths are relative to the dir that is passed in as the first argument, and the compressed
-// file will be placed at that location named `archive-{date}.tar.gz`.
+// All paths are relative to the dir that is passed in as the first argument,
+// and the compressed file will be placed at that location named
+// `archive-{date}.tar.gz`.
 func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, error) {
 	cleanedRootDir, err := fs.SafePath(dir)
 	if err != nil {
@@ -57,3 +66,111 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 
 	return f, nil
 }
+
+// SpaceAvailableForDecompression looks through a given archive and determines
+// if decompressing it would put the server over its allocated disk space limit.
+func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) error {
+	// Don't waste time trying to determine this if we know the server will have the space for
+	// it since there is no limit.
+	if fs.MaxDisk() <= 0 {
+		return nil
+	}
+
+	source, err := fs.SafePath(filepath.Join(dir, file))
+	if err != nil {
+		return err
+	}
+
+	// Get the cached size in a parallel process so that if it is not cached we are not
+	// waiting an unnecessary amount of time on this call.
+	dirSize, err := fs.DiskUsage(false)
+
+	var size int64
+	// Walk over the archive and figure out just how large the final output would be from unarchiving it.
+	err = archiver.Walk(source, func(f archiver.File) error {
+		if atomic.AddInt64(&size, f.Size())+dirSize > fs.MaxDisk() {
+			return newFilesystemError(ErrCodeDiskSpace, nil)
+		}
+		return nil
+	})
+	if err != nil {
+		if IsUnknownArchiveFormatError(err) {
+			return newFilesystemError(ErrCodeUnknownArchive, err)
+		}
+		return err
+	}
+	return err
+}
+
+// DecompressFile will decompress a file in a given directory by using the
+// archiver tool to infer the file type and go from there. This will walk over
+// all of the files within the given archive and ensure that there is not a
+// zip-slip attack being attempted by validating that the final path is within
+// the server data directory.
+func (fs *Filesystem) DecompressFile(dir string, file string) error {
+	source, err := fs.SafePath(filepath.Join(dir, file))
+	if err != nil {
+		return err
+	}
+	// Ensure that the source archive actually exists on the system.
+	if _, err := os.Stat(source); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Walk all of the files in the archiver file and write them to the disk. If any
+	// directory is encountered it will be skipped since we handle creating any missing
+	// directories automatically when writing files.
+	err = archiver.Walk(source, func(f archiver.File) error {
+		if f.IsDir() {
+			return nil
+		}
+		p := filepath.Join(dir, ExtractNameFromArchive(f))
+		// If it is ignored, just don't do anything with the file and skip over it.
+		if err := fs.IsIgnored(p); err != nil {
+			return nil
+		}
+		if err := fs.Writefile(p, f); err != nil {
+			return wrapError(err, source)
+		}
+		return nil
+	})
+	if err != nil {
+		if IsUnknownArchiveFormatError(err) {
+			return newFilesystemError(ErrCodeUnknownArchive, err)
+		}
+		return err
+	}
+	return nil
+}
+
+// ExtractNameFromArchive looks at an archive file to try and determine the name
+// for a given element in an archive. Because of... who knows why, each file type
+// uses different methods to determine the file name.
+//
+// If there is a archiver.File#Sys() value present we will try to use the name
+// present in there, otherwise falling back to archiver.File#Name() if all else
+// fails. Without this logic present, some archive types such as zip/tars/etc.
+// will write all of the files to the base directory, rather than the nested
+// directory that is expected.
+//
+// For files like ".rar" types, there is no f.Sys() value present, and the value
+// of archiver.File#Name() will be what you need.
+func ExtractNameFromArchive(f archiver.File) string {
+	sys := f.Sys()
+	// Some archive types won't have a value returned when you call f.Sys() on them,
+	// such as ".rar" archives for example. In those cases the only thing you can do
+	// is hope that "f.Name()" is actually correct for them.
+	if sys == nil {
+		return f.Name()
+	}
+	switch s := sys.(type) {
+	case *tar.Header:
+		return s.Name
+	case *gzip.Header:
+		return s.Name
+	case *zip.FileHeader:
+		return s.Name
+	default:
+		return f.Name()
+	}
+}

server/filesystem/decompress.go

@@ -1,110 +0,0 @@
-package filesystem
-
-import (
-	"archive/tar"
-	"archive/zip"
-	"compress/gzip"
-	"emperror.dev/errors"
-	"fmt"
-	"github.com/mholt/archiver/v3"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"sync/atomic"
-)
-
-// Look through a given archive and determine if decompressing it would put the server over
-// its allocated disk space limit.
-func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) (bool, error) {
-	// Don't waste time trying to determine this if we know the server will have the space for
-	// it since there is no limit.
-	if fs.MaxDisk() <= 0 {
-		return true, nil
-	}
-
-	source, err := fs.SafePath(filepath.Join(dir, file))
-	if err != nil {
-		return false, err
-	}
-
-	// Get the cached size in a parallel process so that if it is not cached we are not
-	// waiting an unnecessary amount of time on this call.
-	dirSize, err := fs.DiskUsage(false)
-
-	var size int64
-	// Walk over the archive and figure out just how large the final output would be from unarchiving it.
-	err = archiver.Walk(source, func(f archiver.File) error {
-		if atomic.AddInt64(&size, f.Size())+dirSize > fs.MaxDisk() {
-			return &Error{code: ErrCodeDiskSpace}
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		if strings.HasPrefix(err.Error(), "format ") {
-			return false, &Error{code: ErrCodeUnknownArchive}
-		}
-
-		return false, err
-	}
-
-	return true, err
-}
-
-// Decompress a file in a given directory by using the archiver tool to infer the file
-// type and go from there. This will walk over all of the files within the given archive
-// and ensure that there is not a zip-slip attack being attempted by validating that the
-// final path is within the server data directory.
-func (fs *Filesystem) DecompressFile(dir string, file string) error {
-	source, err := fs.SafePath(filepath.Join(dir, file))
-	if err != nil {
-		return err
-	}
-
-	// Make sure the file exists basically.
-	if _, err := os.Stat(source); err != nil {
-		return err
-	}
-
-	// Walk over all of the files spinning up an additional go-routine for each file we've encountered
-	// and then extract that file from the archive and write it to the disk. If any part of this process
-	// encounters an error the entire process will be stopped.
-	err = archiver.Walk(source, func(f archiver.File) error {
-		// Don't waste time with directories, we don't need to create them if they have no contents, and
-		// we will ensure the directory exists when opening the file for writing anyways.
-		if f.IsDir() {
-			return nil
-		}
-
-		var name string
-
-		switch s := f.Sys().(type) {
-		case *tar.Header:
-			name = s.Name
-		case *gzip.Header:
-			name = s.Name
-		case *zip.FileHeader:
-			name = s.Name
-		default:
-			return errors.New(fmt.Sprintf("could not parse underlying data source with type %s", reflect.TypeOf(s).String()))
-		}
-
-		p, err := fs.SafePath(filepath.Join(dir, name))
-		if err != nil {
-			return errors.WithMessage(err, "failed to generate a safe path to server file")
-		}
-
-		return errors.WithMessage(fs.Writefile(p, f), "could not extract file from archive")
-	})
-	if err != nil {
-		if strings.HasPrefix(err.Error(), "format ") {
-			return &Error{code: ErrCodeUnknownArchive}
-		}
-
-		return err
-	}
-
-	return nil
-}

server/filesystem/disk_space.go

@@ -1,12 +1,14 @@
 package filesystem
 
 import (
-	"github.com/apex/log"
-	"github.com/karrick/godirwalk"
 	"sync"
 	"sync/atomic"
 	"syscall"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/karrick/godirwalk"
 )
 
 type SpaceCheckingOpts struct {
@@ -47,7 +49,7 @@ func (fs *Filesystem) SetDiskLimit(i int64) {
 // no space, rather than a boolean value.
 func (fs *Filesystem) HasSpaceErr(allowStaleValue bool) error {
 	if !fs.HasSpaceAvailable(allowStaleValue) {
-		return &Error{code: ErrCodeDiskSpace}
+		return newFilesystemError(ErrCodeDiskSpace, nil)
 	}
 	return nil
 }
@@ -189,7 +191,7 @@ func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
 		},
 	})
 
-	return size, err
+	return size, errors.WrapIf(err, "server/filesystem: directorysize: failed to walk directory")
 }
 
 // Helper function to determine if a server has space available for a file of a given size.
@@ -199,16 +201,13 @@ func (fs *Filesystem) HasSpaceFor(size int64) error {
 	if fs.MaxDisk() == 0 {
 		return nil
 	}
-
 	s, err := fs.DiskUsage(true)
 	if err != nil {
 		return err
 	}
-
 	if (s + size) > fs.MaxDisk() {
-		return &Error{code: ErrCodeDiskSpace}
+		return newFilesystemError(ErrCodeDiskSpace, nil)
 	}
-
 	return nil
 }
 

server/filesystem/errors.go

@@ -1,11 +1,13 @@
 package filesystem
 
 import (
-	"emperror.dev/errors"
 	"fmt"
-	"github.com/apex/log"
 	"os"
 	"path/filepath"
+	"strings"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
 )
 
 type ErrorCode string
@@ -15,61 +17,69 @@ const (
 	ErrCodeDiskSpace      ErrorCode = "E_NODISK"
 	ErrCodeUnknownArchive ErrorCode = "E_UNKNFMT"
 	ErrCodePathResolution ErrorCode = "E_BADPATH"
+	ErrCodeDenylistFile   ErrorCode = "E_DENYLIST"
+	ErrCodeUnknownError   ErrorCode = "E_UNKNOWN"
 )
 
 type Error struct {
-	code     ErrorCode
-	path     string
+	code ErrorCode
+	// Contains the underlying error leading to this. This value may or may not be
+	// present, it is entirely dependent on how this error was triggered.
+	err error
+	// This contains the value of the final destination that triggered this specific
+	// error event.
 	resolved string
+	// This value is generally only present on errors stemming from a path resolution
+	// error. For everything else you should be setting and reading the resolved path
+	// value which will be far more useful.
+	path string
+}
+
+// newFilesystemError returns a new error instance with a stack trace associated.
+func newFilesystemError(code ErrorCode, err error) error {
+	if err != nil {
+		return errors.WithStackDepth(&Error{code: code, err: err}, 1)
+	}
+	return errors.WithStackDepth(&Error{code: code}, 1)
+}
+
+// Code returns the ErrorCode for this specific error instance.
+func (e *Error) Code() ErrorCode {
+	return e.code
 }
 
 // Returns a human-readable error string to identify the Error by.
 func (e *Error) Error() string {
 	switch e.code {
 	case ErrCodeIsDirectory:
-		return "filesystem: is a directory"
+		return fmt.Sprintf("filesystem: cannot perform action: [%s] is a directory", e.resolved)
 	case ErrCodeDiskSpace:
 		return "filesystem: not enough disk space"
 	case ErrCodeUnknownArchive:
 		return "filesystem: unknown archive format"
+	case ErrCodeDenylistFile:
+		r := e.resolved
+		if r == "" {
+			r = "<empty>"
+		}
+		return fmt.Sprintf("filesystem: file access prohibited: [%s] is on the denylist", r)
 	case ErrCodePathResolution:
 		r := e.resolved
 		if r == "" {
 			r = "<empty>"
 		}
 		return fmt.Sprintf("filesystem: server path [%s] resolves to a location outside the server root: %s", e.path, r)
+	case ErrCodeUnknownError:
+		fallthrough
+	default:
+		return fmt.Sprintf("filesystem: an error occurred: %s", e.Unwrap())
 	}
-	return "filesystem: unhandled error type"
 }
 
-// Returns the ErrorCode for this specific error instance.
-func (e *Error) Code() ErrorCode {
-	return e.code
-}
-
-// Checks if the given error is one of the Filesystem errors.
-func IsFilesystemError(err error) (*Error, bool) {
-	if e := errors.Unwrap(err); e != nil {
-		err = e
-	}
-	if fserr, ok := err.(*Error); ok {
-		return fserr, true
-	}
-	return nil, false
-}
-
-// Checks if "err" is a filesystem Error type. If so, it will then drop in and check
-// that the error code is the same as the provided ErrorCode passed in "code".
-func IsErrorCode(err error, code ErrorCode) bool {
-	if e, ok := IsFilesystemError(err); ok {
-		return e.code == code
-	}
-	return false
-}
-
-// Returns a new BadPathResolution error.
-func NewBadPathResolution(path string, resolved string) *Error {
-	return &Error{code: ErrCodePathResolution, path: path, resolved: resolved}
+// Unwrap returns the underlying cause of this filesystem error. In some causes
+// there may not be a cause present, in which case nil will be returned.
+func (e *Error) Unwrap() error {
+	return e.err
 }
 
 // Generates an error logger instance with some basic information.
@@ -86,10 +96,52 @@ func (fs *Filesystem) handleWalkerError(err error, f os.FileInfo) error {
 	if !IsErrorCode(err, ErrCodePathResolution) {
 		return err
 	}
-
 	if f != nil && f.IsDir() {
 		return filepath.SkipDir
 	}
-
 	return nil
 }
+
+// IsFilesystemError checks if the given error is one of the Filesystem errors.
+func IsFilesystemError(err error) bool {
+	var fserr *Error
+	if err != nil && errors.As(err, &fserr) {
+		return true
+	}
+	return false
+}
+
+// IsErrorCode checks if "err" is a filesystem Error type. If so, it will then
+// drop in and check that the error code is the same as the provided ErrorCode
+// passed in "code".
+func IsErrorCode(err error, code ErrorCode) bool {
+	var fserr *Error
+	if err != nil && errors.As(err, &fserr) {
+		return fserr.code == code
+	}
+	return false
+}
+
+// IsUnknownArchiveFormatError checks if the error is due to the archive being
+// in an unexpected file format.
+func IsUnknownArchiveFormatError(err error) bool {
+	if err != nil && strings.HasPrefix(err.Error(), "format ") {
+		return true
+	}
+	return false
+}
+
+// NewBadPathResolution returns a new BadPathResolution error.
+func NewBadPathResolution(path string, resolved string) error {
+	return errors.WithStackDepth(&Error{code: ErrCodePathResolution, path: path, resolved: resolved}, 1)
+}
+
+// wrapError wraps the provided error as a Filesystem error and attaches the
+// provided resolved source to it. If the error is already a Filesystem error
+// no action is taken.
+func wrapError(err error, resolved string) error {
+	if err == nil || IsFilesystemError(err) {
+		return err
+	}
+	return errors.WithStackDepth(&Error{code: ErrCodeUnknownError, err: err, resolved: resolved}, 1)
+}

server/filesystem/errors_test.go

@@ -1,13 +1,45 @@
 package filesystem
 
 import (
-	. "github.com/franela/goblin"
+	"io"
 	"testing"
+
+	"emperror.dev/errors"
+	. "github.com/franela/goblin"
 )
 
+type stackTracer interface {
+	StackTrace() errors.StackTrace
+}
+
 func TestFilesystem_PathResolutionError(t *testing.T) {
 	g := Goblin(t)
 
+	g.Describe("NewFilesystemError", func() {
+		g.It("includes a stack trace for the error", func() {
+			err := newFilesystemError(ErrCodeUnknownError, nil)
+
+			_, ok := err.(stackTracer)
+			g.Assert(ok).IsTrue()
+		})
+
+		g.It("properly wraps the underlying error cause", func() {
+			underlying := io.EOF
+			err := newFilesystemError(ErrCodeUnknownError, underlying)
+
+			_, ok := err.(stackTracer)
+			g.Assert(ok).IsTrue()
+
+			_, ok = err.(*Error)
+			g.Assert(ok).IsFalse()
+
+			fserr, ok := errors.Unwrap(err).(*Error)
+			g.Assert(ok).IsTrue()
+			g.Assert(fserr.Unwrap()).IsNotNil()
+			g.Assert(fserr.Unwrap()).Equal(underlying)
+		})
+	})
+
 	g.Describe("NewBadPathResolutionError", func() {
 		g.It("is can detect itself as an error correctly", func() {
 			err := NewBadPathResolution("foo", "bar")
@@ -18,6 +50,7 @@ func TestFilesystem_PathResolutionError(t *testing.T) {
 
 		g.It("returns <empty> if no destination path is provided", func() {
 			err := NewBadPathResolution("foo", "")
+			g.Assert(err).IsNotNil()
 			g.Assert(err.Error()).Equal("filesystem: server path [foo] resolves to a location outside the server root: <empty>")
 		})
 	})

server/filesystem/filesystem.go

@@ -2,11 +2,6 @@ package filesystem
 
 import (
 	"bufio"
-	"emperror.dev/errors"
-	"github.com/gabriel-vasile/mimetype"
-	"github.com/karrick/godirwalk"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/system"
 	"io"
 	"io/ioutil"
 	"os"
@@ -16,7 +11,15 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/gabriel-vasile/mimetype"
+	"github.com/karrick/godirwalk"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/system"
+	ignore "github.com/sabhiram/go-gitignore"
 )
 
 type Filesystem struct {
@@ -25,6 +28,7 @@ type Filesystem struct {
 	lookupInProgress  *system.AtomicBool
 	diskUsed          int64
 	diskCheckInterval time.Duration
+	denylist          *ignore.GitIgnore
 
 	// The maximum amount of disk space (in bytes) that this Filesystem instance can use.
 	diskLimit int64
@@ -35,42 +39,81 @@ type Filesystem struct {
 	isTest bool
 }
 
-// Creates a new Filesystem instance for a given server.
-func New(root string, size int64) *Filesystem {
+// New creates a new Filesystem instance for a given server.
+func New(root string, size int64, denylist []string) *Filesystem {
 	return &Filesystem{
 		root:              root,
 		diskLimit:         size,
 		diskCheckInterval: time.Duration(config.Get().System.DiskCheckInterval),
 		lastLookupTime:    &usageLookupTime{},
 		lookupInProgress:  system.NewAtomicBool(false),
+		denylist:          ignore.CompileIgnoreLines(denylist...),
 	}
 }
 
-// Returns the root path for the Filesystem instance.
+// Path returns the root path for the Filesystem instance.
 func (fs *Filesystem) Path() string {
 	return fs.root
 }
 
-// Returns a reader for a file instance.
-func (fs *Filesystem) File(p string) (*os.File, os.FileInfo, error) {
+// File returns a reader for a file instance as well as the stat information.
+func (fs *Filesystem) File(p string) (*os.File, Stat, error) {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return nil, nil, err
+		return nil, Stat{}, err
 	}
-	st, err := os.Stat(cleaned)
+	st, err := fs.Stat(cleaned)
 	if err != nil {
-		return nil, nil, err
+		return nil, Stat{}, err
 	}
 	if st.IsDir() {
-		return nil, nil, &Error{code: ErrCodeIsDirectory}
+		return nil, Stat{}, newFilesystemError(ErrCodeIsDirectory, nil)
 	}
 	f, err := os.Open(cleaned)
 	if err != nil {
-		return nil, nil, err
+		return nil, Stat{}, err
 	}
 	return f, st, nil
 }
 
+// Acts by creating the given file and path on the disk if it is not present already. If
+// it is present, the file is opened using the defaults which will truncate the contents.
+// The opened file is then returned to the caller.
+func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return nil, err
+	}
+	f, err := os.OpenFile(cleaned, flag, 0644)
+	if err == nil {
+		return f, nil
+	}
+	// If the error is not because it doesn't exist then we just need to bail at this point.
+	if !errors.Is(err, os.ErrNotExist) {
+		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file handle")
+	}
+	// Only create and chown the directory if it doesn't exist.
+	if _, err := os.Stat(filepath.Dir(cleaned)); errors.Is(err, os.ErrNotExist) {
+		// Create the path leading up to the file we're trying to create, setting the final perms
+		// on it as we go.
+		if err := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
+			return nil, errors.Wrap(err, "server/filesystem: touch: failed to create directory tree")
+		}
+		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
+			return nil, err
+		}
+	}
+	o := &fileOpener{}
+	// Try to open the file now that we have created the pathing necessary for it, and then
+	// Chown that file so that the permissions don't mess with things.
+	f, err = o.open(cleaned, flag, 0644)
+	if err != nil {
+		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file with wait")
+	}
+	_ = fs.Chown(cleaned)
+	return f, nil
+}
+
 // Reads a file on the system and returns it as a byte representation in a file
 // reader. This is not the most memory efficient usage since it will be reading the
 // entirety of the file into memory.
@@ -84,7 +127,9 @@ func (fs *Filesystem) Readfile(p string, w io.Writer) error {
 	return err
 }
 
-// Writes a file to the system. If the file does not already exist one will be created.
+// Writefile writes a file to the system. If the file does not already exist one
+// will be created. This will also properly recalculate the disk space used by
+// the server when writing new files or modifying existing ones.
 func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
@@ -96,10 +141,10 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	// to it and an empty file. We'll then write to it later on after this completes.
 	stat, err := os.Stat(cleaned)
 	if err != nil && !os.IsNotExist(err) {
-		return err
+		return errors.Wrap(err, "server/filesystem: writefile: failed to stat file")
 	} else if err == nil {
 		if stat.IsDir() {
-			return &Error{code: ErrCodeIsDirectory}
+			return errors.WithStack(&Error{code: ErrCodeIsDirectory, resolved: cleaned})
 		}
 		currentSize = stat.Size()
 	}
@@ -112,22 +157,9 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 		return err
 	}
 
-	// If we were unable to stat the location because it did not exist, go ahead and create
-	// it now. We do this after checking the disk space so that we do not just create empty
-	// directories at random.
-	if err != nil {
-		if err := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
-			return err
-		}
-		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
-			return err
-		}
-	}
-
-	o := &fileOpener{}
-	// This will either create the file if it does not already exist, or open and
-	// truncate the existing file.
-	file, err := o.open(cleaned, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	// Touch the file and return the handle to it at this point. This will create the file,
+	// any necessary directories, and set the proper owner of the file.
+	file, err := fs.Touch(cleaned, os.O_RDWR|os.O_CREATE|os.O_TRUNC)
 	if err != nil {
 		return err
 	}
@@ -139,8 +171,6 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	// Adjust the disk usage to account for the old size and the new size of the file.
 	fs.addDisk(sz - currentSize)
 
-	// Finally, chown the file to ensure the permissions don't end up out-of-whack
-	// if we had just created it.
 	return fs.Chown(cleaned)
 }
 
@@ -150,7 +180,6 @@ func (fs *Filesystem) CreateDirectory(name string, p string) error {
 	if err != nil {
 		return err
 	}
-
 	return os.MkdirAll(cleaned, 0755)
 }
 
@@ -207,21 +236,21 @@ func (fs *Filesystem) Chown(path string) error {
 
 	// Start by just chowning the initial path that we received.
 	if err := os.Chown(cleaned, uid, gid); err != nil {
-		return err
+		return errors.Wrap(err, "server/filesystem: chown: failed to chown path")
 	}
 
 	// If this is not a directory we can now return from the function, there is nothing
 	// left that we need to do.
-	if st, _ := os.Stat(cleaned); !st.IsDir() {
+	if st, err := os.Stat(cleaned); err != nil || !st.IsDir() {
 		return nil
 	}
 
 	// If this was a directory, begin walking over its contents recursively and ensure that all
 	// of the subfiles and directories get their permissions updated as well.
-	return godirwalk.Walk(cleaned, &godirwalk.Options{
+	err = godirwalk.Walk(cleaned, &godirwalk.Options{
 		Unsorted: true,
 		Callback: func(p string, e *godirwalk.Dirent) error {
-			// Do not attempt to chmod a symlink. Go's os.Chown function will affect the symlink
+			// Do not attempt to chown a symlink. Go's os.Chown function will affect the symlink
 			// so if it points to a location outside the data directory the user would be able to
 			// (un)intentionally modify that files permissions.
 			if e.IsSymlink() {
@@ -235,6 +264,8 @@ func (fs *Filesystem) Chown(path string) error {
 			return os.Chown(p, uid, gid)
 		},
 	})
+
+	return errors.Wrap(err, "server/filesystem: chown: failed to chown during walk function")
 }
 
 func (fs *Filesystem) Chmod(path string, mode os.FileMode) error {
@@ -339,8 +370,21 @@ func (fs *Filesystem) Copy(p string) error {
 	return fs.Writefile(path.Join(relative, n), source)
 }
 
-// Deletes a file or folder from the system. Prevents the user from accidentally
-// (or maliciously) removing their root server data directory.
+// TruncateRootDirectory removes _all_ files and directories from a server's
+// data directory and resets the used disk space to zero.
+func (fs *Filesystem) TruncateRootDirectory() error {
+	if err := os.RemoveAll(fs.Path()); err != nil {
+		return err
+	}
+	if err := os.Mkdir(fs.Path(), 0755); err != nil {
+		return err
+	}
+	atomic.StoreInt64(&fs.diskUsed, 0)
+	return nil
+}
+
+// Delete removes a file or folder from the system. Prevents the user from
+// accidentally (or maliciously) removing their root server data directory.
 func (fs *Filesystem) Delete(p string) error {
 	wg := sync.WaitGroup{}
 	// This is one of the few (only?) places in the codebase where we're explicitly not using
@@ -411,9 +455,9 @@ func (fo *fileOpener) open(path string, flags int, perm os.FileMode) (*os.File,
 	}
 }
 
-// Lists the contents of a given directory and returns stat information about each
-// file and folder within it.
-func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) {
+// ListDirectory lists the contents of a given directory and returns stat
+// information about each file and folder within it.
+func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
 		return nil, err
@@ -429,7 +473,7 @@ func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) {
 	// You must initialize the output of this directory as a non-nil value otherwise
 	// when it is marshaled into a JSON object you'll just get 'null' back, which will
 	// break the panel badly.
-	out := make([]*Stat, len(files))
+	out := make([]Stat, len(files))
 
 	// Iterate over all of the files and directories returned and perform an async process
 	// to get the mime-type for them all.
@@ -456,15 +500,10 @@ func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) {
 				}
 			}
 
-			st := &Stat{
-				Info:     f,
-				Mimetype: d,
-			}
-
+			st := Stat{FileInfo: f, Mimetype: d}
 			if m != nil {
 				st.Mimetype = m.String()
 			}
-
 			out[idx] = st
 		}(i, file)
 	}
@@ -474,17 +513,16 @@ func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) {
 	// Sort the output alphabetically to begin with since we've run the output
 	// through an asynchronous process and the order is gonna be very random.
 	sort.SliceStable(out, func(i, j int) bool {
-		if out[i].Info.Name() == out[j].Info.Name() || out[i].Info.Name() > out[j].Info.Name() {
+		if out[i].Name() == out[j].Name() || out[i].Name() > out[j].Name() {
 			return true
 		}
-
 		return false
 	})
 
 	// Then, sort it so that directories are listed first in the output. Everything
 	// will continue to be alphabetized at this point.
 	sort.SliceStable(out, func(i, j int) bool {
-		return out[i].Info.IsDir()
+		return out[i].IsDir()
 	})
 
 	return out, nil

server/filesystem/filesystem_test.go

@@ -3,8 +3,6 @@ package filesystem
 import (
 	"bytes"
 	"errors"
-	. "github.com/franela/goblin"
-	"github.com/pterodactyl/wings/config"
 	"io/ioutil"
 	"math/rand"
 	"os"
@@ -12,6 +10,9 @@ import (
 	"sync/atomic"
 	"testing"
 	"unicode/utf8"
+
+	. "github.com/franela/goblin"
+	"github.com/pterodactyl/wings/config"
 )
 
 func NewFs() (*Filesystem, *rootFs) {
@@ -33,7 +34,7 @@ func NewFs() (*Filesystem, *rootFs) {
 
 	rfs.reset()
 
-	fs := New(filepath.Join(tmpDir, "/server"), 0)
+	fs := New(filepath.Join(tmpDir, "/server"), 0, []string{})
 	fs.isTest = true
 
 	return fs, &rfs

server/filesystem/path.go

@@ -2,13 +2,30 @@ package filesystem
 
 import (
 	"context"
-	"golang.org/x/sync/errgroup"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
+
+	"emperror.dev/errors"
+	"golang.org/x/sync/errgroup"
 )
 
+// Checks if the given file or path is in the server's file denylist. If so, an Error
+// is returned, otherwise nil is returned.
+func (fs *Filesystem) IsIgnored(paths ...string) error {
+	for _, p := range paths {
+		sp, err := fs.SafePath(p)
+		if err != nil {
+			return err
+		}
+		if fs.denylist.MatchesPath(sp) {
+			return errors.WithStack(&Error{code: ErrCodeDenylistFile, path: p, resolved: sp})
+		}
+	}
+	return nil
+}
+
 // Normalizes a directory being passed in to ensure the user is not able to escape
 // from their data directory. After normalization if the directory is still within their home
 // path it is returned. If they managed to "escape" an error will be returned.
@@ -25,7 +42,7 @@ func (fs *Filesystem) SafePath(p string) (string, error) {
 	// is truly pointing to.
 	ep, err := filepath.EvalSymlinks(r)
 	if err != nil && !os.IsNotExist(err) {
-		return "", err
+		return "", errors.Wrap(err, "server/filesystem: failed to evaluate symlink")
 	} else if os.IsNotExist(err) {
 		// The requested directory doesn't exist, so at this point we need to iterate up the
 		// path chain until we hit a directory that _does_ exist and can be validated.

server/filesystem/path_test.go

@@ -2,11 +2,12 @@ package filesystem
 
 import (
 	"bytes"
-	"emperror.dev/errors"
-	. "github.com/franela/goblin"
 	"os"
 	"path/filepath"
 	"testing"
+
+	"emperror.dev/errors"
+	. "github.com/franela/goblin"
 )
 
 func TestFilesystem_Path(t *testing.T) {

server/filesystem/stat.go

@@ -2,14 +2,15 @@ package filesystem
 
 import (
 	"encoding/json"
-	"github.com/gabriel-vasile/mimetype"
 	"os"
 	"strconv"
 	"time"
+
+	"github.com/gabriel-vasile/mimetype"
 )
 
 type Stat struct {
-	Info     os.FileInfo
+	os.FileInfo
 	Mimetype string
 }
 
@@ -26,50 +27,48 @@ func (s *Stat) MarshalJSON() ([]byte, error) {
 		Symlink   bool   `json:"symlink"`
 		Mime      string `json:"mime"`
 	}{
-		Name:     s.Info.Name(),
+		Name:     s.Name(),
 		Created:  s.CTime().Format(time.RFC3339),
-		Modified: s.Info.ModTime().Format(time.RFC3339),
-		Mode:     s.Info.Mode().String(),
+		Modified: s.ModTime().Format(time.RFC3339),
+		Mode:     s.Mode().String(),
 		// Using `&os.ModePerm` on the file's mode will cause the mode to only have the permission values, and nothing else.
-		ModeBits:  strconv.FormatUint(uint64(s.Info.Mode()&os.ModePerm), 8),
-		Size:      s.Info.Size(),
-		Directory: s.Info.IsDir(),
-		File:      !s.Info.IsDir(),
-		Symlink:   s.Info.Mode().Perm()&os.ModeSymlink != 0,
+		ModeBits:  strconv.FormatUint(uint64(s.Mode()&os.ModePerm), 8),
+		Size:      s.Size(),
+		Directory: s.IsDir(),
+		File:      !s.IsDir(),
+		Symlink:   s.Mode().Perm()&os.ModeSymlink != 0,
 		Mime:      s.Mimetype,
 	})
 }
 
-// Stats a file or folder and returns the base stat object from go along with the
-// MIME data that can be used for editing files.
-func (fs *Filesystem) Stat(p string) (*Stat, error) {
+// Stat stats a file or folder and returns the base stat object from go along
+// with the MIME data that can be used for editing files.
+func (fs *Filesystem) Stat(p string) (Stat, error) {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return nil, err
+		return Stat{}, err
 	}
-
 	return fs.unsafeStat(cleaned)
 }
 
-func (fs *Filesystem) unsafeStat(p string) (*Stat, error) {
+func (fs *Filesystem) unsafeStat(p string) (Stat, error) {
 	s, err := os.Stat(p)
 	if err != nil {
-		return nil, err
+		return Stat{}, err
 	}
 
 	var m *mimetype.MIME
 	if !s.IsDir() {
 		m, err = mimetype.DetectFile(p)
 		if err != nil {
-			return nil, err
+			return Stat{}, err
 		}
 	}
 
-	st := &Stat{
-		Info:     s,
+	st := Stat{
+		FileInfo: s,
 		Mimetype: "inode/directory",
 	}
-
 	if m != nil {
 		st.Mimetype = m.String()
 	}

server/filesystem/stat_darwin.go

@@ -5,9 +5,9 @@ import (
 	"time"
 )
 
-// Returns the time that the file/folder was created.
+// CTime returns the time that the file/folder was created.
 func (s *Stat) CTime() time.Time {
-	st := s.Info.Sys().(*syscall.Stat_t)
+	st := s.Sys().(*syscall.Stat_t)
 
 	return time.Unix(st.Ctimespec.Sec, st.Ctimespec.Nsec)
 }

server/filesystem/stat_linux.go

@@ -7,7 +7,7 @@ import (
 
 // Returns the time that the file/folder was created.
 func (s *Stat) CTime() time.Time {
-	st := s.Info.Sys().(*syscall.Stat_t)
+	st := s.Sys().(*syscall.Stat_t)
 
 	// Do not remove these "redundant" type-casts, they are required for 32-bit builds to work.
 	return time.Unix(int64(st.Ctim.Sec), int64(st.Ctim.Nsec))

server/filesystem/stat_windows.go

@@ -8,5 +8,5 @@ import (
 // However, I have no idea how to do this on windows, so we're skipping it
 // for right now.
 func (s *Stat) CTime() time.Time {
-	return s.Info.ModTime()
+	return s.ModTime()
 }

server/install.go

@@ -17,9 +17,9 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/system"
 )
 
@@ -48,7 +48,7 @@ func (s *Server) Install(sync bool) error {
 		s.Log().Info("server configured to skip running installation scripts for this egg, not executing process")
 	}
 
-	s.Log().Debug("notifying panel of server install state")
+	s.Log().WithField("was_successful", err == nil).Debug("notifying panel of server install state")
 	if serr := s.SyncInstallState(err == nil); serr != nil {
 		l := s.Log().WithField("was_successful", err == nil)
 
@@ -88,9 +88,9 @@ func (s *Server) Reinstall() error {
 
 // Internal installation function used to simplify reporting back to the Panel.
 func (s *Server) internalInstall() error {
-	script, err := api.New().GetInstallationScript(s.Id())
+	script, err := s.client.GetInstallationScript(s.Context(), s.Id())
 	if err != nil {
-		if !api.IsRequestError(err) {
+		if !remote.IsRequestError(err) {
 			return err
 		}
 
@@ -113,7 +113,7 @@ func (s *Server) internalInstall() error {
 
 type InstallationProcess struct {
 	Server *Server
-	Script *api.InstallationScript
+	Script *remote.InstallationScript
 
 	client  *client.Client
 	context context.Context
@@ -121,13 +121,13 @@ type InstallationProcess struct {
 
 // Generates a new installation process struct that will be used to create containers,
 // and otherwise perform installation commands for a server.
-func NewInstallationProcess(s *Server, script *api.InstallationScript) (*InstallationProcess, error) {
+func NewInstallationProcess(s *Server, script *remote.InstallationScript) (*InstallationProcess, error) {
 	proc := &InstallationProcess{
 		Script: script,
 		Server: s,
 	}
 
-	if c, err := environment.DockerClient(); err != nil {
+	if c, err := environment.Docker(); err != nil {
 		return nil, err
 	} else {
 		proc.client = c
@@ -151,6 +151,14 @@ func (s *Server) SetTransferring(state bool) {
 	s.transferring.Store(state)
 }
 
+func (s *Server) IsRestoring() bool {
+	return s.restoring.Load()
+}
+
+func (s *Server) SetRestoring(state bool) {
+	s.restoring.Store(state)
+}
+
 // Removes the installer container for the server.
 func (ip *InstallationProcess) RemoveContainer() error {
 	err := ip.client.ContainerRemove(ip.context, ip.Server.Id()+"_installer", types.ContainerRemoveOptions{
@@ -186,15 +194,15 @@ func (ip *InstallationProcess) Run() error {
 		return err
 	}
 
-	cid, err := ip.Execute()
+	cID, err := ip.Execute()
 	if err != nil {
-		ip.RemoveContainer()
+		_ = ip.RemoveContainer()
 		return err
 	}
 
 	// If this step fails, log a warning but don't exit out of the process. This is completely
 	// internal to the daemon's functionality, and does not affect the status of the server itself.
-	if err := ip.AfterExecute(cid); err != nil {
+	if err := ip.AfterExecute(cID); err != nil {
 		ip.Server.Log().WithField("error", err).Warn("failed to complete after-execute step of installation process")
 	}
 
@@ -326,7 +334,7 @@ func (ip *InstallationProcess) BeforeExecute() error {
 
 // Returns the log path for the installation process.
 func (ip *InstallationProcess) GetLogPath() string {
-	return filepath.Join(config.Get().System.GetInstallLogPath(), ip.Server.Id()+".log")
+	return filepath.Join(config.Get().System.LogDirectory, "/install", ip.Server.Id()+".log")
 }
 
 // Cleans up after the execution of the installation process. This grabs the logs from the
@@ -447,6 +455,14 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		NetworkMode: container.NetworkMode(config.Get().Docker.Network.Mode),
 	}
 
+	// Ensure the root directory for the server exists properly before attempting
+	// to trigger the reinstall of the server. It is possible the directory would
+	// not exist when this runs if Wings boots with a missing directory and a user
+	// triggers a reinstall before trying to start the server.
+	if err := ip.Server.EnsureDataDirectoryExists(); err != nil {
+		return "", err
+	}
+
 	ip.Server.Log().WithField("install_script", ip.tempDir()+"/install.sh").Info("creating install container for server process")
 	// Remove the temporary directory when the installation process finishes for this server container.
 	defer func() {
@@ -524,9 +540,9 @@ func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) erro
 // value of "true" means everything was successful, "false" means something went
 // wrong and the server must be deleted and re-created.
 func (s *Server) SyncInstallState(successful bool) error {
-	err := api.New().SendInstallationStatus(s.Id(), successful)
+	err := s.client.SetInstallationStatus(s.Context(), s.Id(), successful)
 	if err != nil {
-		if !api.IsRequestError(err) {
+		if !remote.IsRequestError(err) {
 			return err
 		}
 

server/listeners.go

@@ -7,10 +7,10 @@ import (
 	"sync"
 
 	"github.com/apex/log"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/remote"
 )
 
 var dockerEvents = []string{
@@ -136,7 +136,7 @@ func (s *Server) StartEventListeners() {
 		}
 	}
 
-	s.Log().Info("registering event listeners: console, state, resources...")
+	s.Log().Debug("registering event listeners: console, state, resources...")
 	s.Environment.Events().On(environment.ConsoleOutputEvent, &console)
 	s.Environment.Events().On(environment.StateChangeEvent, &state)
 	s.Environment.Events().On(environment.ResourceEvent, &stats)
@@ -186,7 +186,7 @@ func (s *Server) onConsoleOutput(data string) {
 	if s.IsRunning() {
 		stop := processConfiguration.Stop
 
-		if stop.Type == api.ProcessStopCommand && data == stop.Value {
+		if stop.Type == remote.ProcessStopCommand && data == stop.Value {
 			s.Environment.SetState(environment.ProcessOfflineState)
 		}
 	}

server/loader.go

@@ -1,134 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/gammazero/workerpool"
-	"github.com/pterodactyl/wings/api"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/environment/docker"
-	"github.com/pterodactyl/wings/server/filesystem"
-)
-
-var servers = NewCollection(nil)
-
-func GetServers() *Collection {
-	return servers
-}
-
-// Iterates over a given directory and loads all of the servers listed before returning
-// them to the calling function.
-func LoadDirectory() error {
-	if len(servers.items) != 0 {
-		return errors.New("cannot call LoadDirectory with a non-nil collection")
-	}
-
-	log.Info("fetching list of servers from API")
-	configs, err := api.New().GetServers()
-	if err != nil {
-		if !api.IsRequestError(err) {
-			return err
-		}
-
-		return errors.New(err.Error())
-	}
-
-	start := time.Now()
-	log.WithField("total_configs", len(configs)).Info("processing servers returned by the API")
-
-	pool := workerpool.New(runtime.NumCPU())
-	log.Debugf("using %d workerpools to instantiate server instances", runtime.NumCPU())
-	for _, data := range configs {
-		data := data
-
-		pool.Submit(func() {
-			// Parse the json.RawMessage into an expected struct value. We do this here so that a single broken
-			// server does not cause the entire boot process to hang, and allows us to show more useful error
-			// messaging in the output.
-			d := api.ServerConfigurationResponse{
-				Settings: data.Settings,
-			}
-
-			log.WithField("server", data.Uuid).Info("creating new server object from API response")
-			if err := json.Unmarshal(data.ProcessConfiguration, &d.ProcessConfiguration); err != nil {
-				log.WithField("server", data.Uuid).WithField("error", err).Error("failed to parse server configuration from API response, skipping...")
-				return
-			}
-
-			s, err := FromConfiguration(d)
-			if err != nil {
-				log.WithField("server", data.Uuid).WithField("error", err).Error("failed to load server, skipping...")
-				return
-			}
-
-			servers.Add(s)
-		})
-	}
-
-	// Wait until we've processed all of the configuration files in the directory
-	// before continuing.
-	pool.StopWait()
-
-	diff := time.Now().Sub(start)
-	log.WithField("duration", fmt.Sprintf("%s", diff)).Info("finished processing server configurations")
-
-	return nil
-}
-
-// Initializes a server using a data byte array. This will be marshaled into the
-// given struct using a YAML marshaler. This will also configure the given environment
-// for a server.
-func FromConfiguration(data api.ServerConfigurationResponse) (*Server, error) {
-	s, err := New()
-	if err != nil {
-		return nil, errors.WithMessage(err, "loader: failed to instantiate empty server struct")
-	}
-	if err := s.UpdateDataStructure(data.Settings); err != nil {
-		return nil, err
-	}
-
-	s.Archiver = Archiver{Server: s}
-	s.fs = filesystem.New(filepath.Join(config.Get().System.Data, s.Id()), s.DiskSpace())
-
-	// Right now we only support a Docker based environment, so I'm going to hard code
-	// this logic in. When we're ready to support other environment we'll need to make
-	// some modifications here obviously.
-	settings := environment.Settings{
-		Mounts:      s.Mounts(),
-		Allocations: s.cfg.Allocations,
-		Limits:      s.cfg.Build,
-	}
-
-	envCfg := environment.NewConfiguration(settings, s.GetEnvironmentVariables())
-	meta := docker.Metadata{
-		Image: s.Config().Container.Image,
-	}
-
-	if env, err := docker.New(s.Id(), &meta, envCfg); err != nil {
-		return nil, err
-	} else {
-		s.Environment = env
-		s.StartEventListeners()
-		s.Throttler().StartTimer(s.Context())
-	}
-
-	// Forces the configuration to be synced with the panel.
-	if err := s.SyncWithConfiguration(data); err != nil {
-		return nil, err
-	}
-
-	// If the server's data directory exists, force disk usage calculation.
-	if _, err := os.Stat(s.Filesystem().Path()); err == nil {
-		s.Filesystem().HasSpaceAvailable(true)
-	}
-
-	return s, nil
-}

server/manager.go

@@ -0,0 +1,263 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"time"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/gammazero/workerpool"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/environment/docker"
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server/filesystem"
+)
+
+type Manager struct {
+	mu      sync.RWMutex
+	client  remote.Client
+	servers []*Server
+}
+
+// NewManager returns a new server manager instance. This will boot up all of
+// the servers that are currently present on the filesystem and set them into
+// the manager.
+func NewManager(ctx context.Context, client remote.Client) (*Manager, error) {
+	m := NewEmptyManager(client)
+	if err := m.init(ctx); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// NewEmptyManager returns a new empty manager collection without actually
+// loading any of the servers from the disk. This allows the caller to set their
+// own servers into the collection as needed.
+func NewEmptyManager(client remote.Client) *Manager {
+	return &Manager{client: client}
+}
+
+// Client returns the HTTP client interface that allows interaction with the
+// Panel API.
+func (m *Manager) Client() remote.Client {
+	return m.client
+}
+
+// Put replaces all of the current values in the collection with the value that
+// is passed through.
+func (m *Manager) Put(s []*Server) {
+	m.mu.Lock()
+	m.servers = s
+	m.mu.Unlock()
+}
+
+// All returns all of the items in the collection.
+func (m *Manager) All() []*Server {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.servers
+}
+
+// Add adds an item to the collection store.
+func (m *Manager) Add(s *Server) {
+	m.mu.Lock()
+	m.servers = append(m.servers, s)
+	m.mu.Unlock()
+}
+
+// Get returns a single server instance and a boolean value indicating if it was
+// found in the global collection or not.
+func (m *Manager) Get(uuid string) (*Server, bool) {
+	match := m.Find(func(server *Server) bool {
+		return server.Id() == uuid
+	})
+	return match, match != nil
+}
+
+// Filter returns only those items matching the filter criteria.
+func (m *Manager) Filter(filter func(match *Server) bool) []*Server {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	r := make([]*Server, 0)
+	for _, v := range m.servers {
+		if filter(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}
+
+// Find returns a single element from the collection matching the filter. If
+// nothing is found a nil result is returned.
+func (m *Manager) Find(filter func(match *Server) bool) *Server {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	for _, v := range m.servers {
+		if filter(v) {
+			return v
+		}
+	}
+	return nil
+}
+
+// Remove removes all items from the collection that match the filter function.
+func (m *Manager) Remove(filter func(match *Server) bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	r := make([]*Server, 0)
+	for _, v := range m.servers {
+		if !filter(v) {
+			r = append(r, v)
+		}
+	}
+	m.servers = r
+}
+
+// PersistStates writes the current environment states to the disk for each
+// server. This is generally called at a specific interval defined in the root
+// runner command to avoid hammering disk I/O when tons of server switch states
+// at once. It is fine if this file falls slightly out of sync, it is just here
+// to make recovering from an unexpected system reboot a little easier.
+func (m *Manager) PersistStates() error {
+	states := map[string]string{}
+	for _, s := range m.All() {
+		states[s.Id()] = s.Environment.State()
+	}
+	data, err := json.Marshal(states)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	if err := ioutil.WriteFile(config.Get().System.GetStatesPath(), data, 0644); err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
+}
+
+// ReadStates returns the state of the servers.
+func (m *Manager) ReadStates() (map[string]string, error) {
+	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer f.Close()
+	var states map[string]string
+	if err := json.NewDecoder(f).Decode(&states); err != nil && err != io.EOF {
+		return nil, errors.WithStack(err)
+	}
+	out := make(map[string]string, 0)
+	// Only return states for servers that we're currently tracking in the system.
+	for id, state := range states {
+		if _, ok := m.Get(id); ok {
+			out[id] = state
+		}
+	}
+	return out, nil
+}
+
+// InitServer initializes a server using a data byte array. This will be
+// marshaled into the given struct using a YAML marshaler. This will also
+// configure the given environment for a server.
+func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server, error) {
+	s, err := New(m.client)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.UpdateDataStructure(data.Settings); err != nil {
+		return nil, err
+	}
+
+	s.fs = filesystem.New(filepath.Join(config.Get().System.Data, s.Id()), s.DiskSpace(), s.Config().Egg.FileDenylist)
+
+	// Right now we only support a Docker based environment, so I'm going to hard code
+	// this logic in. When we're ready to support other environment we'll need to make
+	// some modifications here obviously.
+	settings := environment.Settings{
+		Mounts:      s.Mounts(),
+		Allocations: s.cfg.Allocations,
+		Limits:      s.cfg.Build,
+	}
+
+	envCfg := environment.NewConfiguration(settings, s.GetEnvironmentVariables())
+	meta := docker.Metadata{
+		Image: s.Config().Container.Image,
+	}
+
+	if env, err := docker.New(s.Id(), &meta, envCfg); err != nil {
+		return nil, err
+	} else {
+		s.Environment = env
+		s.StartEventListeners()
+		s.Throttler().StartTimer(s.Context())
+	}
+
+	// Forces the configuration to be synced with the panel.
+	if err := s.SyncWithConfiguration(data); err != nil {
+		return nil, err
+	}
+
+	// If the server's data directory exists, force disk usage calculation.
+	if _, err := os.Stat(s.Filesystem().Path()); err == nil {
+		s.Filesystem().HasSpaceAvailable(true)
+	}
+
+	return s, nil
+}
+
+// initializeFromRemoteSource iterates over a given directory and loads all of
+// the servers listed before returning them to the calling function.
+func (m *Manager) init(ctx context.Context) error {
+	log.Info("fetching list of servers from API")
+	servers, err := m.client.GetServers(ctx, config.Get().RemoteQuery.BootServersPerPage)
+	if err != nil {
+		if !remote.IsRequestError(err) {
+			return errors.WithStackIf(err)
+		}
+		return errors.WrapIf(err, "manager: failed to retrieve server configurations")
+	}
+
+	start := time.Now()
+	log.WithField("total_configs", len(servers)).Info("processing servers returned by the API")
+
+	pool := workerpool.New(runtime.NumCPU())
+	log.Debugf("using %d workerpools to instantiate server instances", runtime.NumCPU())
+	for _, data := range servers {
+		data := data
+		pool.Submit(func() {
+			// Parse the json.RawMessage into an expected struct value. We do this here so that a single broken
+			// server does not cause the entire boot process to hang, and allows us to show more useful error
+			// messaging in the output.
+			d := remote.ServerConfigurationResponse{
+				Settings: data.Settings,
+			}
+			log.WithField("server", data.Uuid).Info("creating new server object from API response")
+			if err := json.Unmarshal(data.ProcessConfiguration, &d.ProcessConfiguration); err != nil {
+				log.WithField("server", data.Uuid).WithField("error", err).Error("failed to parse server configuration from API response, skipping...")
+				return
+			}
+			s, err := m.InitServer(d)
+			if err != nil {
+				log.WithField("server", data.Uuid).WithField("error", err).Error("failed to load server, skipping...")
+				return
+			}
+			m.Add(s)
+		})
+	}
+
+	// Wait until we've processed all of the configuration files in the directory
+	// before continuing.
+	pool.StopWait()
+
+	diff := time.Now().Sub(start)
+	log.WithField("duration", fmt.Sprintf("%s", diff)).Info("finished processing server configurations")
+
+	return nil
+}

server/power.go

@@ -70,6 +70,10 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 		return ErrServerIsTransferring
 	}
 
+	if s.IsRestoring() {
+		return ErrServerIsRestoring
+	}
+
 	if s.powerLock == nil {
 		s.powerLock = semaphore.NewWeighted(1)
 	}
@@ -83,7 +87,9 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 		// Determines if we should wait for the lock or not. If a value greater than 0 is passed
 		// into this function we will wait that long for a lock to be acquired.
 		if len(waitSeconds) > 0 && waitSeconds[0] != 0 {
-			ctx, _ := context.WithTimeout(context.Background(), time.Second*time.Duration(waitSeconds[0]))
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(waitSeconds[0]))
+			defer cancel()
+
 			// Attempt to acquire a lock on the power action lock for up to 30 seconds. If more
 			// time than that passes an error will be propagated back up the chain and this
 			// request will be aborted.

server/server.go

@@ -3,23 +3,25 @@ package server
 import (
 	"context"
 	"fmt"
+	"os"
 	"strings"
 	"sync"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/creasty/defaults"
-	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"github.com/pterodactyl/wings/system"
 	"golang.org/x/sync/semaphore"
 )
 
-// High level definition for a server instance being controlled by Wings.
+// Server is the high level definition for a server instance being controlled
+// by Wings.
 type Server struct {
 	// Internal mutex used to block actions that need to occur sequentially, such as
 	// writing the configuration to the disk.
@@ -33,13 +35,13 @@ type Server struct {
 
 	// Maintains the configuration for the server. This is the data that gets returned by the Panel
 	// such as build settings and container images.
-	cfg Configuration
+	cfg    Configuration
+	client remote.Client
 
 	// The crash handler for this server instance.
 	crasher CrashHandler
 
 	resources   ResourceUsage
-	Archiver    Archiver                       `json:"-"`
 	Environment environment.ProcessEnvironment `json:"-"`
 
 	fs *filesystem.Filesystem
@@ -50,7 +52,7 @@ type Server struct {
 	// Defines the process configuration for the server instance. This is dynamically
 	// fetched from the Pterodactyl Server instance each time the server process is
 	// started, and then cached here.
-	procConfig *api.ProcessConfiguration
+	procConfig *remote.ProcessConfiguration
 
 	// Tracks the installation process for this server and prevents a server from running
 	// two installer processes at the same time. This also allows us to cancel a running
@@ -58,6 +60,7 @@ type Server struct {
 	// installer process is still running.
 	installing   *system.AtomicBool
 	transferring *system.AtomicBool
+	restoring    *system.AtomicBool
 
 	// The console throttler instance used to control outputs.
 	throttler *ConsoleThrottler
@@ -67,27 +70,29 @@ type Server struct {
 	wsBagLocker sync.Mutex
 }
 
-// Returns a new server instance with a context and all of the default values set on
-// the instance.
-func New() (*Server, error) {
+// New returns a new server instance with a context and all of the default
+// values set on the struct.
+func New(client remote.Client) (*Server, error) {
 	ctx, cancel := context.WithCancel(context.Background())
 	s := Server{
 		ctx:          ctx,
 		ctxCancel:    &cancel,
+		client:       client,
 		installing:   system.NewAtomicBool(false),
 		transferring: system.NewAtomicBool(false),
+		restoring:    system.NewAtomicBool(false),
 	}
 	if err := defaults.Set(&s); err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "server: could not set default values for struct")
 	}
 	if err := defaults.Set(&s.cfg); err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "server: could not set defaults for server configuration")
 	}
 	s.resources.State = system.NewAtomicString(environment.ProcessOfflineState)
 	return &s, nil
 }
 
-// Returns the UUID for the server instance.
+// Id returns the UUID for the server instance.
 func (s *Server) Id() string {
 	return s.Config().GetUuid()
 }
@@ -138,20 +143,20 @@ func (s *Server) Log() *log.Entry {
 	return log.WithField("server", s.Id())
 }
 
-// Syncs the state of the server on the Panel with Wings. This ensures that we're always
-// using the state of the server from the Panel and allows us to not require successful
-// API calls to Wings to do things.
+// Sync syncs the state of the server on the Panel with Wings. This ensures that
+// we're always using the state of the server from the Panel and allows us to
+// not require successful API calls to Wings to do things.
 //
-// This also means mass actions can be performed against servers on the Panel and they
-// will automatically sync with Wings when the server is started.
+// This also means mass actions can be performed against servers on the Panel
+// and they will automatically sync with Wings when the server is started.
 func (s *Server) Sync() error {
-	cfg, err := api.New().GetServerConfiguration(s.Id())
+	cfg, err := s.client.GetServerConfiguration(s.Context(), s.Id())
 	if err != nil {
-		if !api.IsRequestError(err) {
+		if !remote.IsRequestError(err) {
 			return err
 		}
 
-		if err.(*api.RequestError).Status == "404" {
+		if err.(*remote.RequestError).Status == "404" {
 			return &serverDoesNotExist{}
 		}
 
@@ -161,7 +166,7 @@ func (s *Server) Sync() error {
 	return s.SyncWithConfiguration(cfg)
 }
 
-func (s *Server) SyncWithConfiguration(cfg api.ServerConfigurationResponse) error {
+func (s *Server) SyncWithConfiguration(cfg remote.ServerConfigurationResponse) error {
 	// Update the data structure and persist it to the disk.
 	if err := s.UpdateDataStructure(cfg.Settings); err != nil {
 		return err
@@ -215,9 +220,109 @@ func (s *Server) IsSuspended() bool {
 	return s.Config().Suspended
 }
 
-func (s *Server) ProcessConfiguration() *api.ProcessConfiguration {
+func (s *Server) ProcessConfiguration() *remote.ProcessConfiguration {
 	s.RLock()
 	defer s.RUnlock()
 
 	return s.procConfig
 }
+
+// Filesystem returns an instance of the filesystem for this server.
+func (s *Server) Filesystem() *filesystem.Filesystem {
+	return s.fs
+}
+
+// EnsureDataDirectoryExists ensures that the data directory for the server
+// instance exists.
+func (s *Server) EnsureDataDirectoryExists() error {
+	if _, err := os.Lstat(s.fs.Path()); err != nil {
+		if os.IsNotExist(err) {
+			s.Log().Debug("server: creating root directory and setting permissions")
+			if err := os.MkdirAll(s.fs.Path(), 0700); err != nil {
+				return errors.WithStack(err)
+			}
+			if err := s.fs.Chown("/"); err != nil {
+				s.Log().WithField("error", err).Warn("server: failed to chown server data directory")
+			}
+		} else {
+			return errors.WrapIf(err, "server: failed to stat server root directory")
+		}
+	}
+	return nil
+}
+
+// Sets the state of the server internally. This function handles crash detection as
+// well as reporting to event listeners for the server.
+func (s *Server) OnStateChange() {
+	prevState := s.resources.State.Load()
+
+	st := s.Environment.State()
+	// Update the currently tracked state for the server.
+	s.resources.State.Store(st)
+
+	// Emit the event to any listeners that are currently registered.
+	if prevState != s.Environment.State() {
+		s.Log().WithField("status", st).Debug("saw server status change event")
+		s.Events().Publish(StatusEvent, st)
+	}
+
+	// Reset the resource usage to 0 when the process fully stops so that all of the UI
+	// views in the Panel correctly display 0.
+	if st == environment.ProcessOfflineState {
+		s.resources.Reset()
+		s.emitProcUsage()
+	}
+
+	// If server was in an online state, and is now in an offline state we should handle
+	// that as a crash event. In that scenario, check the last crash time, and the crash
+	// counter.
+	//
+	// In the event that we have passed the thresholds, don't do anything, otherwise
+	// automatically attempt to start the process back up for the user. This is done in a
+	// separate thread as to not block any actions currently taking place in the flow
+	// that called this function.
+	if (prevState == environment.ProcessStartingState || prevState == environment.ProcessRunningState) && s.Environment.State() == environment.ProcessOfflineState {
+		s.Log().Info("detected server as entering a crashed state; running crash handler")
+
+		go func(server *Server) {
+			if err := server.handleServerCrash(); err != nil {
+				if IsTooFrequentCrashError(err) {
+					server.Log().Info("did not restart server after crash; occurred too soon after the last")
+				} else {
+					s.PublishConsoleOutputFromDaemon("Server crash was detected but an error occurred while handling it.")
+					server.Log().WithField("error", err).Error("failed to handle server crash")
+				}
+			}
+		}(s)
+	}
+}
+
+// IsRunning determines if the server state is running or not. This is different
+// than the environment state, it is simply the tracked state from this daemon
+// instance, and not the response from Docker.
+func (s *Server) IsRunning() bool {
+	st := s.Environment.State()
+
+	return st == environment.ProcessRunningState || st == environment.ProcessStartingState
+}
+
+// APIResponse is a type returned when requesting details about a single server
+// instance on Wings. This includes the information needed by the Panel in order
+// to show resource utilization and the current state on this system.
+type APIResponse struct {
+	State         string        `json:"state"`
+	IsSuspended   bool          `json:"is_suspended"`
+	Utilization   ResourceUsage `json:"utilization"`
+	Configuration Configuration `json:"configuration"`
+}
+
+// ToAPIResponse returns the server struct as an API object that can be consumed
+// by callers.
+func (s *Server) ToAPIResponse() APIResponse {
+	return APIResponse{
+		State:         s.Environment.State(),
+		IsSuspended:   s.IsSuspended(),
+		Utilization:   s.Proc(),
+		Configuration: *s.Config(),
+	}
+}

server/state.go

@@ -1,137 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	"os"
-	"sync"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/environment"
-)
-
-var stateMutex sync.Mutex
-
-// Returns the state of the servers.
-func CachedServerStates() (map[string]string, error) {
-	// Request a lock after we check if the file exists.
-	stateMutex.Lock()
-	defer stateMutex.Unlock()
-
-	// Open the states file.
-	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	// Convert the json object to a map.
-	states := map[string]string{}
-	if err := json.NewDecoder(f).Decode(&states); err != nil && err != io.EOF {
-		return nil, err
-	}
-
-	return states, nil
-}
-
-// saveServerStates .
-func saveServerStates() error {
-	// Get the states of all servers on the daemon.
-	states := map[string]string{}
-	for _, s := range GetServers().All() {
-		states[s.Id()] = s.Environment.State()
-	}
-
-	// Convert the map to a json object.
-	data, err := json.Marshal(states)
-	if err != nil {
-		return err
-	}
-
-	stateMutex.Lock()
-	defer stateMutex.Unlock()
-
-	// Write the data to the file
-	if err := ioutil.WriteFile(config.Get().System.GetStatesPath(), data, 0644); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Sets the state of the server internally. This function handles crash detection as
-// well as reporting to event listeners for the server.
-func (s *Server) OnStateChange() {
-	prevState := s.resources.State.Load()
-
-	st := s.Environment.State()
-	// Update the currently tracked state for the server.
-	s.resources.State.Store(st)
-
-	// Emit the event to any listeners that are currently registered.
-	if prevState != s.Environment.State() {
-		s.Log().WithField("status", st).Debug("saw server status change event")
-		s.Events().Publish(StatusEvent, st)
-	}
-
-	// Persist this change to the disk immediately so that should the Daemon be stopped or
-	// crash we can immediately restore the server state.
-	//
-	// This really only makes a difference if all of the Docker containers are also stopped,
-	// but this was a highly requested feature and isn't hard to work with, so lets do it.
-	//
-	// We also get the benefit of server status changes always propagating corrected configurations
-	// to the disk should we forget to do it elsewhere.
-	go func() {
-		if err := saveServerStates(); err != nil {
-			s.Log().WithField("error", err).Warn("failed to write server states to disk")
-		}
-	}()
-
-	// Reset the resource usage to 0 when the process fully stops so that all of the UI
-	// views in the Panel correctly display 0.
-	if st == environment.ProcessOfflineState {
-		s.resources.Reset()
-		s.emitProcUsage()
-	}
-
-	// If server was in an online state, and is now in an offline state we should handle
-	// that as a crash event. In that scenario, check the last crash time, and the crash
-	// counter.
-	//
-	// In the event that we have passed the thresholds, don't do anything, otherwise
-	// automatically attempt to start the process back up for the user. This is done in a
-	// separate thread as to not block any actions currently taking place in the flow
-	// that called this function.
-	if (prevState == environment.ProcessStartingState || prevState == environment.ProcessRunningState) && s.Environment.State() == environment.ProcessOfflineState {
-		s.Log().Info("detected server as entering a crashed state; running crash handler")
-
-		go func(server *Server) {
-			if err := server.handleServerCrash(); err != nil {
-				if IsTooFrequentCrashError(err) {
-					server.Log().Info("did not restart server after crash; occurred too soon after the last")
-				} else {
-					s.PublishConsoleOutputFromDaemon("Server crash was detected but an error occurred while handling it.")
-					server.Log().WithField("error", err).Error("failed to handle server crash")
-				}
-			}
-		}(s)
-	}
-}
-
-// Returns the current state of the server in a race-safe manner.
-// Deprecated
-// use Environment.State()
-func (s *Server) GetState() string {
-	return s.Environment.State()
-}
-
-// Determines if the server state is running or not. This is different than the
-// environment state, it is simply the tracked state from this daemon instance, and
-// not the response from Docker.
-func (s *Server) IsRunning() bool {
-	st := s.Environment.State()
-
-	return st == environment.ProcessRunningState || st == environment.ProcessStartingState
-}

server/update.go

@@ -9,9 +9,9 @@ import (
 	"github.com/pterodactyl/wings/environment"
 )
 
-// Merges data passed through in JSON form into the existing server object.
-// Any changes to the build settings will apply immediately in the environment
-// if the environment supports it.
+// UpdateDataStructure merges data passed through in JSON form into the existing
+// server object. Any changes to the build settings will apply immediately in
+// the environment if the environment supports it.
 //
 // The server will be marked as requiring a rebuild on the next boot sequence,
 // it is up to the specific environment to determine what needs to happen when
@@ -19,14 +19,14 @@ import (
 func (s *Server) UpdateDataStructure(data []byte) error {
 	src := new(Configuration)
 	if err := json.Unmarshal(data, src); err != nil {
-		return err
+		return errors.Wrap(err, "server/update: could not unmarshal source data into Configuration struct")
 	}
 
 	// Don't allow obviously corrupted data to pass through into this function. If the UUID
 	// doesn't match something has gone wrong and the API is attempting to meld this server
 	// instance into a totally different one, which would be bad.
 	if src.Uuid != "" && s.Id() != "" && src.Uuid != s.Id() {
-		return errors.New("attempting to merge a data stack with an invalid UUID")
+		return errors.New("server/update: attempting to merge a data stack with an invalid UUID")
 	}
 
 	// Grab a copy of the configuration to work on.
@@ -48,25 +48,21 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 	// Merge the new data object that we have received with the existing server data object
 	// and then save it to the disk so it is persistent.
 	if err := mergo.Merge(&c, src, mergo.WithOverride); err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	// Don't explode if we're setting CPU limits to 0. Mergo sees that as an empty value
 	// so it won't override the value we've passed through in the API call. However, we can
 	// safely assume that we're passing through valid data structures here. I foresee this
 	// backfiring at some point, but until then...
-	//
-	// We'll go ahead and do this with swap as well.
-	c.Build.CpuLimit = src.Build.CpuLimit
-	c.Build.Swap = src.Build.Swap
-	c.Build.DiskSpace = src.Build.DiskSpace
+	c.Build = src.Build
 
 	// Mergo can't quite handle this boolean value correctly, so for now we'll just
 	// handle this edge case manually since none of the other data passed through in this
 	// request is going to be boolean. Allegedly.
 	if v, err := jsonparser.GetBoolean(data, "container", "oom_disabled"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return err
+			return errors.WithStack(err)
 		}
 	} else {
 		c.Build.OOMDisabled = v
@@ -75,7 +71,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 	// Mergo also cannot handle this boolean value.
 	if v, err := jsonparser.GetBoolean(data, "suspended"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return err
+			return errors.WithStack(err)
 		}
 	} else {
 		c.Suspended = v
@@ -83,7 +79,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 
 	if v, err := jsonparser.GetBoolean(data, "skip_egg_scripts"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return err
+			return errors.WithStack(err)
 		}
 	} else {
 		c.SkipEggScripts = v

sftp/errors.go

@@ -1,19 +0,0 @@
-package sftp
-
-type fxerr uint32
-
-const (
-	// Extends the default SFTP server to return a quota exceeded error to the client.
-	//
-	// @see https://tools.ietf.org/id/draft-ietf-secsh-filexfer-13.txt
-	ErrSshQuotaExceeded = fxerr(15)
-)
-
-func (e fxerr) Error() string {
-	switch e {
-	case ErrSshQuotaExceeded:
-		return "Quota Exceeded"
-	default:
-		return "Failure"
-	}
-}

sftp/handler.go

@@ -5,31 +5,17 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 
+	"emperror.dev/errors"
 	"github.com/apex/log"
-	"github.com/patrickmn/go-cache"
 	"github.com/pkg/sftp"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/server/filesystem"
+	"golang.org/x/crypto/ssh"
 )
 
-type FileSystem struct {
-	UUID        string
-	Permissions []string
-	ReadOnly    bool
-	User        User
-	Cache       *cache.Cache
-
-	PathValidator func(fs FileSystem, p string) (string, error)
-	HasDiskSpace  func(fs FileSystem) bool
-
-	logger *log.Entry
-	lock   sync.Mutex
-}
-
-func (fs FileSystem) buildPath(p string) (string, error) {
-	return fs.PathValidator(fs, p)
-}
-
 const (
 	PermissionFileRead        = "file.read"
 	PermissionFileReadContent = "file.read-content"
@@ -38,343 +24,269 @@ const (
 	PermissionFileDelete      = "file.delete"
 )
 
+type Handler struct {
+	permissions []string
+	mu          sync.Mutex
+	fs          *filesystem.Filesystem
+	logger      *log.Entry
+	ro          bool
+}
+
+// Returns a new connection handler for the SFTP server. This allows a given user
+// to access the underlying filesystem.
+func NewHandler(sc *ssh.ServerConn, fs *filesystem.Filesystem) *Handler {
+	return &Handler{
+		fs:          fs,
+		ro:          config.Get().System.Sftp.ReadOnly,
+		permissions: strings.Split(sc.Permissions.Extensions["permissions"], ","),
+		logger: log.WithFields(log.Fields{
+			"subsystem": "sftp",
+			"username":  sc.User(),
+			"ip":        sc.RemoteAddr(),
+		}),
+	}
+}
+
+// Returns the sftp.Handlers for this struct.
+func (h *Handler) Handlers() sftp.Handlers {
+	return sftp.Handlers{
+		FileGet:  h,
+		FilePut:  h,
+		FileCmd:  h,
+		FileList: h,
+	}
+}
+
 // Fileread creates a reader for a file on the system and returns the reader back.
-func (fs FileSystem) Fileread(request *sftp.Request) (io.ReaderAt, error) {
+func (h *Handler) Fileread(request *sftp.Request) (io.ReaderAt, error) {
 	// Check first if the user can actually open and view a file. This permission is named
 	// really poorly, but it is checking if they can read. There is an addition permission,
 	// "save-files" which determines if they can write that file.
-	if !fs.can(PermissionFileReadContent) {
-		return nil, sftp.ErrSshFxPermissionDenied
+	if !h.can(PermissionFileReadContent) {
+		return nil, sftp.ErrSSHFxPermissionDenied
 	}
-
-	p, err := fs.buildPath(request.Filepath)
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	f, _, err := h.fs.File(request.Filepath)
 	if err != nil {
-		return nil, sftp.ErrSshFxNoSuchFile
+		if !errors.Is(err, os.ErrNotExist) {
+			h.logger.WithField("error", err).Error("error processing readfile request")
+			return nil, sftp.ErrSSHFxFailure
+		}
+		return nil, sftp.ErrSSHFxNoSuchFile
 	}
-
-	fs.lock.Lock()
-	defer fs.lock.Unlock()
-
-	if _, err := os.Stat(p); os.IsNotExist(err) {
-		return nil, sftp.ErrSshFxNoSuchFile
-	} else if err != nil {
-		fs.logger.WithField("error", err).Error("error while processing file stat")
-
-		return nil, sftp.ErrSshFxFailure
-	}
-
-	file, err := os.Open(p)
-	if err != nil {
-		fs.logger.WithField("source", p).WithField("error", err).Error("could not open file for reading")
-		return nil, sftp.ErrSshFxFailure
-	}
-
-	return file, nil
+	return f, nil
 }
 
 // Filewrite handles the write actions for a file on the system.
-func (fs FileSystem) Filewrite(request *sftp.Request) (io.WriterAt, error) {
-	if fs.ReadOnly {
-		return nil, sftp.ErrSshFxOpUnsupported
+func (h *Handler) Filewrite(request *sftp.Request) (io.WriterAt, error) {
+	if h.ro {
+		return nil, sftp.ErrSSHFxOpUnsupported
 	}
-
-	p, err := fs.buildPath(request.Filepath)
-	if err != nil {
-		return nil, sftp.ErrSshFxNoSuchFile
-	}
-
-	l := fs.logger.WithField("source", p)
-
+	l := h.logger.WithField("source", request.Filepath)
 	// If the user doesn't have enough space left on the server it should respond with an
 	// error since we won't be letting them write this file to the disk.
-	if !fs.HasDiskSpace(fs) {
-		return nil, ErrSshQuotaExceeded
+	if !h.fs.HasSpaceAvailable(true) {
+		return nil, ErrSSHQuotaExceeded
 	}
 
-	fs.lock.Lock()
-	defer fs.lock.Unlock()
-
-	stat, statErr := os.Stat(p)
-	// If the file doesn't exist we need to create it, as well as the directory pathway
-	// leading up to where that file will be created.
-	if os.IsNotExist(statErr) {
-		// This is a different pathway than just editing an existing file. If it doesn't exist already
-		// we need to determine if this user has permission to create files.
-		if !fs.can(PermissionFileCreate) {
-			return nil, sftp.ErrSshFxPermissionDenied
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	// The specific permission required to perform this action. If the file exists on the
+	// system already it only needs to be an update, otherwise we'll check for a create.
+	permission := PermissionFileUpdate
+	_, sterr := h.fs.Stat(request.Filepath)
+	if sterr != nil {
+		if !errors.Is(sterr, os.ErrNotExist) {
+			l.WithField("error", sterr).Error("error while getting file reader")
+			return nil, sftp.ErrSSHFxFailure
 		}
-
-		// Create all of the directories leading up to the location where this file is being created.
-		if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
-			l.WithFields(log.Fields{
-				"path":  filepath.Dir(p),
-				"error": err,
-			}).Error("error making path for file")
-
-			return nil, sftp.ErrSshFxFailure
-		}
-
-		file, err := os.Create(p)
-		if err != nil {
-			l.WithField("error", err).Error("failed to create file")
-
-			return nil, sftp.ErrSshFxFailure
-		}
-
-		// Not failing here is intentional. We still made the file, it is just owned incorrectly
-		// and will likely cause some issues.
-		if err := os.Chown(p, fs.User.Uid, fs.User.Gid); err != nil {
-			l.WithField("error", err).Warn("failed to set permissions on file")
-		}
-
-		return file, nil
+		permission = PermissionFileCreate
 	}
-
-	// If the stat error isn't about the file not existing, there is some other issue
-	// at play and we need to go ahead and bail out of the process.
-	if statErr != nil {
-		l.WithField("error", statErr).Error("encountered error performing file stat")
-
-		return nil, sftp.ErrSshFxFailure
+	// Confirm the user has permission to perform this action BEFORE calling Touch, otherwise
+	// you'll potentially create a file on the system and then fail out because of user
+	// permission checking after the fact.
+	if !h.can(permission) {
+		return nil, sftp.ErrSSHFxPermissionDenied
 	}
-
-	// If we've made it here it means the file already exists and we don't need to do anything
-	// fancy to handle it. Just pass over the request flags so the system knows what the end
-	// goal with the file is going to be.
-	//
-	// But first, check that the user has permission to save modified files.
-	if !fs.can(PermissionFileUpdate) {
-		return nil, sftp.ErrSshFxPermissionDenied
-	}
-
-	// Not sure this would ever happen, but lets not find out.
-	if stat.IsDir() {
-		return nil, sftp.ErrSshFxOpUnsupported
-	}
-
-	file, err := os.Create(p)
+	f, err := h.fs.Touch(request.Filepath, os.O_RDWR|os.O_CREATE|os.O_TRUNC)
 	if err != nil {
-		// Prevent errors if the file is deleted between the stat and this call.
-		if os.IsNotExist(err) {
-			return nil, sftp.ErrSSHFxNoSuchFile
-		}
-
 		l.WithField("flags", request.Flags).WithField("error", err).Error("failed to open existing file on system")
-		return nil, sftp.ErrSshFxFailure
+		return nil, sftp.ErrSSHFxFailure
 	}
-
-	// Not failing here is intentional. We still made the file, it is just owned incorrectly
-	// and will likely cause some issues.
-	if err := os.Chown(p, fs.User.Uid, fs.User.Gid); err != nil {
-		l.WithField("error", err).Warn("error chowning file")
-	}
-
-	return file, nil
+	return f, nil
 }
 
 // Filecmd hander for basic SFTP system calls related to files, but not anything to do with reading
 // or writing to those files.
-func (fs FileSystem) Filecmd(request *sftp.Request) error {
-	if fs.ReadOnly {
-		return sftp.ErrSshFxOpUnsupported
+func (h *Handler) Filecmd(request *sftp.Request) error {
+	if h.ro {
+		return sftp.ErrSSHFxOpUnsupported
 	}
-
-	p, err := fs.buildPath(request.Filepath)
-	if err != nil {
-		return sftp.ErrSshFxNoSuchFile
-	}
-
-	l := fs.logger.WithField("source", p)
-
-	var target string
-	// If a target is provided in this request validate that it is going to the correct
-	// location for the server. If it is not, return an operation unsupported error. This
-	// is maybe not the best error response, but its not wrong either.
+	l := h.logger.WithField("source", request.Filepath)
 	if request.Target != "" {
-		target, err = fs.buildPath(request.Target)
-		if err != nil {
-			return sftp.ErrSshFxOpUnsupported
-		}
+		l = l.WithField("target", request.Target)
 	}
 
 	switch request.Method {
+	// Allows a user to make changes to the permissions of a given file or directory
+	// on their server using their SFTP client.
 	case "Setstat":
-		if !fs.can(PermissionFileUpdate) {
-			return sftp.ErrSshFxPermissionDenied
+		if !h.can(PermissionFileUpdate) {
+			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		mode := os.FileMode(0644)
-		// If the client passed a valid file permission use that, otherwise use the
-		// default of 0644 set above.
-		if request.Attributes().FileMode().Perm() != 0000 {
-			mode = request.Attributes().FileMode().Perm()
+		mode := request.Attributes().FileMode().Perm()
+		// If the client passes an invalid FileMode just use the default 0644.
+		if mode == 0000 {
+			mode = os.FileMode(0644)
 		}
-
-		// Force directories to be 0755
+		// Force directories to be 0755.
 		if request.Attributes().FileMode().IsDir() {
 			mode = 0755
 		}
-
-		if err := os.Chmod(p, mode); err != nil {
-			if os.IsNotExist(err) {
+		if err := h.fs.Chmod(request.Filepath, mode); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
 				return sftp.ErrSSHFxNoSuchFile
 			}
-
 			l.WithField("error", err).Error("failed to perform setstat on item")
 			return sftp.ErrSSHFxFailure
 		}
-		return nil
+		break
+	// Support renaming a file (aka Move).
 	case "Rename":
-		if !fs.can(PermissionFileUpdate) {
+		if !h.can(PermissionFileUpdate) {
 			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		if err := os.Rename(p, target); err != nil {
-			if os.IsNotExist(err) {
+		if err := h.fs.Rename(request.Filepath, request.Target); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
 				return sftp.ErrSSHFxNoSuchFile
 			}
-
-			l.WithField("target", target).WithField("error", err).Error("failed to rename file")
-
-			return sftp.ErrSshFxFailure
+			l.WithField("error", err).Error("failed to rename file")
+			return sftp.ErrSSHFxFailure
 		}
-
 		break
+	// Handle deletion of a directory. This will properly delete all of the files and
+	// folders within that directory if it is not already empty (unlike a lot of SFTP
+	// clients that must delete each file individually).
 	case "Rmdir":
-		if !fs.can(PermissionFileDelete) {
-			return sftp.ErrSshFxPermissionDenied
+		if !h.can(PermissionFileDelete) {
+			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		if err := os.RemoveAll(p); err != nil {
+		if err := h.fs.Delete(request.Filepath); err != nil {
 			l.WithField("error", err).Error("failed to remove directory")
-
-			return sftp.ErrSshFxFailure
+			return sftp.ErrSSHFxFailure
 		}
-
-		return sftp.ErrSshFxOk
+		return sftp.ErrSSHFxOk
+	// Handle requests to create a new Directory.
 	case "Mkdir":
-		if !fs.can(PermissionFileCreate) {
-			return sftp.ErrSshFxPermissionDenied
+		if !h.can(PermissionFileCreate) {
+			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		if err := os.MkdirAll(p, 0755); err != nil {
+		name := strings.Split(filepath.Clean(request.Filepath), "/")
+		err := h.fs.CreateDirectory(name[len(name)-1], strings.Join(name[0:len(name)-1], "/"))
+		if err != nil {
 			l.WithField("error", err).Error("failed to create directory")
-
-			return sftp.ErrSshFxFailure
+			return sftp.ErrSSHFxFailure
 		}
-
 		break
+	// Support creating symlinks between files. The source and target must resolve within
+	// the server home directory.
 	case "Symlink":
-		if !fs.can(PermissionFileCreate) {
-			return sftp.ErrSshFxPermissionDenied
+		if !h.can(PermissionFileCreate) {
+			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		if err := os.Symlink(p, target); err != nil {
+		source, err := h.fs.SafePath(request.Filepath)
+		if err != nil {
+			return sftp.ErrSSHFxNoSuchFile
+		}
+		target, err := h.fs.SafePath(request.Target)
+		if err != nil {
+			return sftp.ErrSSHFxNoSuchFile
+		}
+		if err := os.Symlink(source, target); err != nil {
 			l.WithField("target", target).WithField("error", err).Error("failed to create symlink")
-
-			return sftp.ErrSshFxFailure
+			return sftp.ErrSSHFxFailure
 		}
-
 		break
+	// Called when deleting a file.
 	case "Remove":
-		if !fs.can(PermissionFileDelete) {
-			return sftp.ErrSshFxPermissionDenied
+		if !h.can(PermissionFileDelete) {
+			return sftp.ErrSSHFxPermissionDenied
 		}
-
-		if err := os.Remove(p); err != nil {
-			if os.IsNotExist(err) {
+		if err := h.fs.Delete(request.Filepath); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
 				return sftp.ErrSSHFxNoSuchFile
 			}
-
 			l.WithField("error", err).Error("failed to remove a file")
-
-			return sftp.ErrSshFxFailure
+			return sftp.ErrSSHFxFailure
 		}
-
-		return sftp.ErrSshFxOk
+		return sftp.ErrSSHFxOk
 	default:
-		return sftp.ErrSshFxOpUnsupported
+		return sftp.ErrSSHFxOpUnsupported
 	}
 
-	var fileLocation = p
-	if target != "" {
-		fileLocation = target
+	target := request.Filepath
+	if request.Target != "" {
+		target = request.Target
 	}
-
 	// Not failing here is intentional. We still made the file, it is just owned incorrectly
 	// and will likely cause some issues. There is no logical check for if the file was removed
 	// because both of those cases (Rmdir, Remove) have an explicit return rather than break.
-	if err := os.Chown(fileLocation, fs.User.Uid, fs.User.Gid); err != nil {
+	if err := h.fs.Chown(target); err != nil {
 		l.WithField("error", err).Warn("error chowning file")
 	}
 
-	return sftp.ErrSshFxOk
+	return sftp.ErrSSHFxOk
 }
 
 // Filelist is the handler for SFTP filesystem list calls. This will handle calls to list the contents of
 // a directory as well as perform file/folder stat calls.
-func (fs FileSystem) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
-	p, err := fs.buildPath(request.Filepath)
-	if err != nil {
-		return nil, sftp.ErrSshFxNoSuchFile
+func (h *Handler) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
+	if !h.can(PermissionFileRead) {
+		return nil, sftp.ErrSSHFxPermissionDenied
 	}
 
 	switch request.Method {
 	case "List":
-		if !fs.can(PermissionFileRead) {
-			return nil, sftp.ErrSshFxPermissionDenied
+		p, err := h.fs.SafePath(request.Filepath)
+		if err != nil {
+			return nil, sftp.ErrSSHFxNoSuchFile
 		}
-
 		files, err := ioutil.ReadDir(p)
 		if err != nil {
-			fs.logger.WithField("error", err).Error("error while listing directory")
+			h.logger.WithField("source", request.Filepath).WithField("error", err).Error("error while listing directory")
 
-			return nil, sftp.ErrSshFxFailure
+			return nil, sftp.ErrSSHFxFailure
 		}
-
 		return ListerAt(files), nil
 	case "Stat":
-		if !fs.can(PermissionFileRead) {
-			return nil, sftp.ErrSshFxPermissionDenied
+		st, err := h.fs.Stat(request.Filepath)
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				return nil, sftp.ErrSSHFxNoSuchFile
+			}
+			h.logger.WithField("source", request.Filepath).WithField("error", err).Error("error performing stat on file")
+			return nil, sftp.ErrSSHFxFailure
 		}
-
-		s, err := os.Stat(p)
-		if os.IsNotExist(err) {
-			return nil, sftp.ErrSshFxNoSuchFile
-		} else if err != nil {
-			fs.logger.WithField("source", p).WithField("error", err).Error("error performing stat on file")
-
-			return nil, sftp.ErrSshFxFailure
-		}
-
-		return ListerAt([]os.FileInfo{s}), nil
+		return ListerAt([]os.FileInfo{st.FileInfo}), nil
 	default:
-		// Before adding readlink support we need to evaluate any potential security risks
-		// as a result of navigating around to a location that is outside the home directory
-		// for the logged in user. I don't foresee it being much of a problem, but I do want to
-		// check it out before slapping some code here. Until then, we'll just return an
-		// unsupported response code.
-		return nil, sftp.ErrSshFxOpUnsupported
+		return nil, sftp.ErrSSHFxOpUnsupported
 	}
 }
 
 // Determines if a user has permission to perform a specific action on the SFTP server. These
 // permissions are defined and returned by the Panel API.
-func (fs FileSystem) can(permission string) bool {
-	// Server owners and super admins have their permissions returned as '[*]' via the Panel
+func (h *Handler) can(permission string) bool {
+	// SFTPServer owners and super admins have their permissions returned as '[*]' via the Panel
 	// API, so for the sake of speed do an initial check for that before iterating over the
 	// entire array of permissions.
-	if len(fs.Permissions) == 1 && fs.Permissions[0] == "*" {
+	if len(h.permissions) == 1 && h.permissions[0] == "*" {
 		return true
 	}
-
-	// Not the owner or an admin, loop over the permissions that were returned to determine
-	// if they have the passed permission.
-	for _, p := range fs.Permissions {
+	for _, p := range h.permissions {
 		if p == permission {
 			return true
 		}
 	}
-
 	return false
 }

sftp/server.go

@@ -1,239 +1,210 @@
 package sftp
 
 import (
+	"context"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
-	"fmt"
 	"io"
 	"io/ioutil"
 	"net"
 	"os"
 	"path"
+	"regexp"
+	"strconv"
 	"strings"
-	"time"
 
+	"emperror.dev/errors"
 	"github.com/apex/log"
-	"github.com/patrickmn/go-cache"
 	"github.com/pkg/sftp"
-	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server"
 	"golang.org/x/crypto/ssh"
 )
 
-type Settings struct {
-	BasePath    string
-	ReadOnly    bool
-	BindPort    int
-	BindAddress string
+// Usernames all follow the same format, so don't even bother hitting the API if the username is not
+// at least in the expected format. This is very basic protection against random bots finding the SFTP
+// server and sending a flood of usernames.
+var validUsernameRegexp = regexp.MustCompile(`^(?i)(.+)\.([a-z0-9]{8})$`)
+
+//goland:noinspection GoNameStartsWithPackageName
+type SFTPServer struct {
+	manager  *server.Manager
+	BasePath string
+	ReadOnly bool
+	Listen   string
 }
 
-type User struct {
-	Uid int
-	Gid int
-}
-
-type Server struct {
-	cache *cache.Cache
-
-	Settings Settings
-	User     User
-
-	PathValidator      func(fs FileSystem, p string) (string, error)
-	DiskSpaceValidator func(fs FileSystem) bool
-
-	// Validator function that is called when a user connects to the server. This should
-	// check against whatever system is desired to confirm if the given username and password
-	// combination is valid. If so, should return an authentication response.
-	CredentialValidator func(r api.SftpAuthRequest) (*api.SftpAuthResponse, error)
-}
-
-// Create a new server configuration instance.
-func New(c *Server) error {
-	c.cache = cache.New(5*time.Minute, 10*time.Minute)
-
-	return nil
-}
-
-// Initialize the SFTP server and add a persistent listener to handle inbound SFTP connections.
-func (c *Server) Initialize() error {
-	serverConfig := &ssh.ServerConfig{
-		NoClientAuth: false,
-		MaxAuthTries: 6,
-		PasswordCallback: func(conn ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
-			resp, err := c.CredentialValidator(api.SftpAuthRequest{
-				User:          conn.User(),
-				Pass:          string(pass),
-				IP:            conn.RemoteAddr().String(),
-				SessionID:     conn.SessionID(),
-				ClientVersion: conn.ClientVersion(),
-			})
-
-			if err != nil {
-				return nil, err
-			}
-
-			sshPerm := &ssh.Permissions{
-				Extensions: map[string]string{
-					"uuid":        resp.Server,
-					"user":        conn.User(),
-					"permissions": strings.Join(resp.Permissions, ","),
-				},
-			}
-
-			return sshPerm, nil
-		},
+func New(m *server.Manager) *SFTPServer {
+	cfg := config.Get().System
+	return &SFTPServer{
+		manager:  m,
+		BasePath: cfg.Data,
+		ReadOnly: cfg.Sftp.ReadOnly,
+		Listen:   cfg.Sftp.Address + ":" + strconv.Itoa(cfg.Sftp.Port),
 	}
+}
 
-	if _, err := os.Stat(path.Join(c.Settings.BasePath, ".sftp/id_rsa")); os.IsNotExist(err) {
+// Starts the SFTP server and add a persistent listener to handle inbound SFTP connections.
+func (c *SFTPServer) Run() error {
+	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_rsa")); os.IsNotExist(err) {
 		if err := c.generatePrivateKey(); err != nil {
 			return err
 		}
 	} else if err != nil {
-		return err
+		return errors.Wrap(err, "sftp/server: could not stat private key file")
 	}
-
-	privateBytes, err := ioutil.ReadFile(path.Join(c.Settings.BasePath, ".sftp/id_rsa"))
+	pb, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_rsa"))
+	if err != nil {
+		return errors.Wrap(err, "sftp/server: could not read private key file")
+	}
+	private, err := ssh.ParsePrivateKey(pb)
 	if err != nil {
 		return err
 	}
 
-	private, err := ssh.ParsePrivateKey(privateBytes)
+	conf := &ssh.ServerConfig{
+		NoClientAuth:     false,
+		MaxAuthTries:     6,
+		PasswordCallback: c.passwordCallback,
+	}
+	conf.AddHostKey(private)
+
+	listener, err := net.Listen("tcp", c.Listen)
 	if err != nil {
 		return err
 	}
 
-	// Add our private key to the server configuration.
-	serverConfig.AddHostKey(private)
-
-	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", c.Settings.BindAddress, c.Settings.BindPort))
-	if err != nil {
-		return err
-	}
-
-	log.WithField("host", c.Settings.BindAddress).WithField("port", c.Settings.BindPort).Info("sftp subsystem listening for connections")
-
+	log.WithField("listen", c.Listen).Info("sftp server listening for connections")
 	for {
-		conn, _ := listener.Accept()
-		if conn != nil {
-			go c.AcceptInboundConnection(conn, serverConfig)
+		if conn, _ := listener.Accept(); conn != nil {
+			go func(conn net.Conn) {
+				defer conn.Close()
+				c.AcceptInbound(conn, conf)
+			}(conn)
 		}
 	}
 }
 
-// Handles an inbound connection to the instance and determines if we should serve the request
-// or not.
-func (c Server) AcceptInboundConnection(conn net.Conn, config *ssh.ServerConfig) {
-	defer conn.Close()
-
+// Handles an inbound connection to the instance and determines if we should serve the
+// request or not.
+func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 	// Before beginning a handshake must be performed on the incoming net.Conn
 	sconn, chans, reqs, err := ssh.NewServerConn(conn, config)
 	if err != nil {
 		return
 	}
 	defer sconn.Close()
-
 	go ssh.DiscardRequests(reqs)
 
-	for newChannel := range chans {
+	for ch := range chans {
 		// If its not a session channel we just move on because its not something we
 		// know how to handle at this point.
-		if newChannel.ChannelType() != "session" {
-			newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
+		if ch.ChannelType() != "session" {
+			ch.Reject(ssh.UnknownChannelType, "unknown channel type")
 			continue
 		}
 
-		channel, requests, err := newChannel.Accept()
+		channel, requests, err := ch.Accept()
 		if err != nil {
 			continue
 		}
 
-		// Channels have a type that is dependent on the protocol. For SFTP this is "subsystem"
-		// with a payload that (should) be "sftp". Discard anything else we receive ("pty", "shell", etc)
 		go func(in <-chan *ssh.Request) {
 			for req := range in {
-				ok := false
-
-				switch req.Type {
-				case "subsystem":
-					if string(req.Payload[4:]) == "sftp" {
-						ok = true
-					}
-				}
-
-				req.Reply(ok, nil)
+				// Channels have a type that is dependent on the protocol. For SFTP
+				// this is "subsystem" with a payload that (should) be "sftp". Discard
+				// anything else we receive ("pty", "shell", etc)
+				req.Reply(req.Type == "subsystem" && string(req.Payload[4:]) == "sftp", nil)
 			}
 		}(requests)
 
-		// Configure the user's home folder for the rest of the request cycle.
-		if sconn.Permissions.Extensions["uuid"] == "" {
+		// If no UUID has been set on this inbound request then we can assume we
+		// have screwed up something in the authentication code. This is a sanity
+		// check, but should never be encountered (ideally...).
+		//
+		// This will also attempt to match a specific server out of the global server
+		// store and return nil if there is no match.
+		uuid := sconn.Permissions.Extensions["uuid"]
+		srv := c.manager.Find(func(s *server.Server) bool {
+			if uuid == "" {
+				return false
+			}
+			return s.Id() == uuid
+		})
+		if srv == nil {
 			continue
 		}
 
-		// Create a new handler for the currently logged in user's server.
-		fs := c.createHandler(sconn)
-
-		// Create the server instance for the channel using the filesystem we created above.
-		server := sftp.NewRequestServer(channel, fs)
-
-		if err := server.Serve(); err == io.EOF {
-			server.Close()
+		// Spin up a SFTP server instance for the authenticated user's server allowing
+		// them access to the underlying filesystem.
+		handler := sftp.NewRequestServer(channel, NewHandler(sconn, srv.Filesystem()).Handlers())
+		if err := handler.Serve(); err == io.EOF {
+			handler.Close()
 		}
 	}
 }
 
-// Creates a new SFTP handler for a given server. The directory argument should
-// be the base directory for a server. All actions done on the server will be
-// relative to that directory, and the user will not be able to escape out of it.
-func (c Server) createHandler(sc *ssh.ServerConn) sftp.Handlers {
-	p := FileSystem{
-		UUID:          sc.Permissions.Extensions["uuid"],
-		Permissions:   strings.Split(sc.Permissions.Extensions["permissions"], ","),
-		ReadOnly:      c.Settings.ReadOnly,
-		Cache:         c.cache,
-		User:          c.User,
-		HasDiskSpace:  c.DiskSpaceValidator,
-		PathValidator: c.PathValidator,
-		logger: log.WithFields(log.Fields{
-			"subsystem": "sftp",
-			"username":  sc.User(),
-			"ip":        sc.RemoteAddr(),
-		}),
-	}
-
-	return sftp.Handlers{
-		FileGet:  p,
-		FilePut:  p,
-		FileCmd:  p,
-		FileList: p,
-	}
-}
-
 // Generates a private key that will be used by the SFTP server.
-func (c Server) generatePrivateKey() error {
+func (c *SFTPServer) generatePrivateKey() error {
 	key, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
-		return err
+		return errors.WithStack(err)
 	}
-
-	if err := os.MkdirAll(path.Join(c.Settings.BasePath, ".sftp"), 0755); err != nil {
-		return err
+	if err := os.MkdirAll(path.Join(c.BasePath, ".sftp"), 0755); err != nil {
+		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
 	}
-
-	o, err := os.OpenFile(path.Join(c.Settings.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	o, err := os.OpenFile(path.Join(c.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 	defer o.Close()
 
-	pkey := &pem.Block{
+	err = pem.Encode(o, &pem.Block{
 		Type:  "RSA PRIVATE KEY",
 		Bytes: x509.MarshalPKCS1PrivateKey(key),
-	}
-
-	if err := pem.Encode(o, pkey); err != nil {
-		return err
-	}
-
-	return nil
+	})
+	return errors.WithStack(err)
+}
+
+// A function capable of validating user credentials with the Panel API.
+func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
+	request := remote.SftpAuthRequest{
+		User:          conn.User(),
+		Pass:          string(pass),
+		IP:            conn.RemoteAddr().String(),
+		SessionID:     conn.SessionID(),
+		ClientVersion: conn.ClientVersion(),
+	}
+
+	logger := log.WithFields(log.Fields{"subsystem": "sftp", "username": conn.User(), "ip": conn.RemoteAddr().String()})
+	logger.Debug("validating credentials for SFTP connection")
+
+	if !validUsernameRegexp.MatchString(request.User) {
+		logger.Warn("failed to validate user credentials (invalid format)")
+		return nil, &remote.SftpInvalidCredentialsError{}
+	}
+
+	resp, err := c.manager.Client().ValidateSftpCredentials(context.Background(), request)
+	if err != nil {
+		if _, ok := err.(*remote.SftpInvalidCredentialsError); ok {
+			logger.Warn("failed to validate user credentials (invalid username or password)")
+		} else {
+			logger.WithField("error", err).Error("encountered an error while trying to validate user credentials")
+		}
+		return nil, err
+	}
+
+	logger.WithField("server", resp.Server).Debug("credentials validated and matched to server instance")
+	sshPerm := &ssh.Permissions{
+		Extensions: map[string]string{
+			"uuid":        resp.Server,
+			"user":        conn.User(),
+			"permissions": strings.Join(resp.Permissions, ","),
+		},
+	}
+
+	return sshPerm, nil
 }

sftp/sftp.go

@@ -1,97 +0,0 @@
-package sftp
-
-import (
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/pterodactyl/wings/api"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server"
-)
-
-var noMatchingServerError = errors.New("no matching server with that UUID was found")
-
-func Initialize(config config.SystemConfiguration) error {
-	s := &Server{
-		User: User{
-			Uid: config.User.Uid,
-			Gid: config.User.Gid,
-		},
-		Settings: Settings{
-			BasePath:    config.Data,
-			ReadOnly:    config.Sftp.ReadOnly,
-			BindAddress: config.Sftp.Address,
-			BindPort:    config.Sftp.Port,
-		},
-		CredentialValidator: validateCredentials,
-		PathValidator:       validatePath,
-		DiskSpaceValidator:  validateDiskSpace,
-	}
-
-	if err := New(s); err != nil {
-		return err
-	}
-
-	// Initialize the SFTP server in a background thread since this is
-	// a long running operation.
-	go func(s *Server) {
-		if err := s.Initialize(); err != nil {
-			log.WithField("subsystem", "sftp").WithField("error", err).Error("failed to initialize SFTP subsystem")
-		}
-	}(s)
-
-	return nil
-}
-
-func validatePath(fs FileSystem, p string) (string, error) {
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == fs.UUID
-	})
-
-	if s == nil {
-		return "", noMatchingServerError
-	}
-
-	return s.Filesystem().SafePath(p)
-}
-
-func validateDiskSpace(fs FileSystem) bool {
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == fs.UUID
-	})
-
-	if s == nil {
-		return false
-	}
-
-	return s.Filesystem().HasSpaceAvailable(true)
-}
-
-// Validates a set of credentials for a SFTP login against Pterodactyl Panel and returns
-// the server's UUID if the credentials were valid.
-func validateCredentials(c api.SftpAuthRequest) (*api.SftpAuthResponse, error) {
-	f := log.Fields{"subsystem": "sftp", "username": c.User, "ip": c.IP}
-
-	log.WithFields(f).Debug("validating credentials for SFTP connection")
-	resp, err := api.New().ValidateSftpCredentials(c)
-	if err != nil {
-		if api.IsInvalidCredentialsError(err) {
-			log.WithFields(f).Warn("failed to validate user credentials (invalid username or password)")
-		} else {
-			log.WithFields(f).Error("encountered an error while trying to validate user credentials")
-		}
-
-		return resp, err
-	}
-
-	s := server.GetServers().Find(func(server *server.Server) bool {
-		return server.Id() == resp.Server
-	})
-
-	if s == nil {
-		return resp, noMatchingServerError
-	}
-
-	s.Log().WithFields(f).Debug("credentials successfully validated and matched user to server instance")
-
-	return resp, err
-}

sftp/utils.go

@@ -5,6 +5,13 @@ import (
 	"os"
 )
 
+const (
+	// Extends the default SFTP server to return a quota exceeded error to the client.
+	//
+	// @see https://tools.ietf.org/id/draft-ietf-secsh-filexfer-13.txt
+	ErrSSHQuotaExceeded = fxerr(15)
+)
+
 type ListerAt []os.FileInfo
 
 // Returns the number of entries copied and an io.EOF error if we made it to the end of the file list.
@@ -20,3 +27,14 @@ func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
 		return n, nil
 	}
 }
+
+type fxerr uint32
+
+func (e fxerr) Error() string {
+	switch e {
+	case ErrSSHQuotaExceeded:
+		return "Quota Exceeded"
+	default:
+		return "Failure"
+	}
+}

system/utils.go

@@ -7,14 +7,35 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
+
+	"emperror.dev/errors"
 )
 
 var cr = []byte(" \r")
 var crr = []byte("\r\n")
 
+// FirstNotEmpty returns the first string passed in that is not an empty value.
+func FirstNotEmpty(v ...string) string {
+	for _, val := range v {
+		if val != "" {
+			return val
+		}
+	}
+	return ""
+}
+
+func MustInt(v string) int {
+	i, err := strconv.Atoi(v)
+	if err != nil {
+		panic(errors.Wrap(err, "system/utils: could not parse int"))
+	}
+	return i
+}
+
 func ScanReader(r io.Reader, callback func(line string)) error {
 	br := bufio.NewReader(r)
 	// Avoid constantly re-allocating memory when we're flooding lines through this