Merge branch 'develop' into v2

Due to the order of the previous logic in ScanReader, an error not caused by EOF would effectively get ignored since an error will always be returned with `isPrefix` equal to false, thus triggering the first break, and error checking is not performed beyond that point.

Thus, canceling an installation process for a server while this process was running would hang the routine and cause the loop to run endlessly, even with a canceled context.

.github/workflows/build-test.yml

@@ -2,17 +2,17 @@ name: Run Tests
 on:
   push:
     branches:
-      - 'develop'
+      - develop
   pull_request:
     branches:
-      - 'develop'
+      - develop
 jobs:
   build:
     strategy:
       fail-fast: false
       matrix:
         os: [ ubuntu-20.04 ]
-        go: [ '^1.15', '^1.16' ]
+        go: [ '^1.17' ]
         goos: [ linux ]
         goarch: [ amd64, arm64 ]
     runs-on: ${{ matrix.os }}
@@ -32,17 +32,20 @@ jobs:
           go env
           printf "\n\nSystem Environment:\n\n"
           env
-
+          printf "Git Version: $(git version)\n\n"
           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)"
+          echo "::set-output name=go_mod_cache::$(go env GOMODCACHE)"
       - name: Build Cache
         uses: actions/cache@v2
         with:
-          path: ${{ steps.env.outputs.go_cache }}
-          key: ${{ runner.os }}-${{ matrix.go }}-go-${{ hashFiles('**/go.sum') }}
+          key: ${{ runner.os }}-go${{ matrix.go }}-${{ hashFiles('**/go.sum') }}
           restore-keys: |
-            ${{ runner.os }}-${{ matrix.go }}-go
+            ${{ runner.os }}-go${{ matrix.go }}-
+          path: |
+            ${{ steps.env.outputs.go_cache }}
+            ${{ steps.env.outputs.go_mod_cache }}
       - name: Get Dependencies
         run: |
           go get -v -t -d ./...
@@ -53,14 +56,21 @@ jobs:
           CGO_ENABLED: 0
           SRC_PATH: github.com/pterodactyl/wings
         run: |
-          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
+          go build -v -trimpath -ldflags="-s -w -X ${SRC_PATH}/system.Version=dev-${GIT_COMMIT:0:7}" -o build/wings_${GOOS}_${GOARCH} wings.go
+          go build -v -trimpath -ldflags="-X ${SRC_PATH}/system.Version=dev-${GIT_COMMIT:0:7}" -o build/wings_${GOOS}_${GOARCH}_debug wings.go
+          upx build/wings_${GOOS}_${{ matrix.goarch }}
+          chmod +x build/*
+      - name: Tests
+        run: go test -race ./...
+      - name: Upload Release Artifact
         uses: actions/upload-artifact@v2
-        if: ${{ matrix.go == '^1.15' && (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
+        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
         with:
-          name: wings_${{ matrix.goos }}_${{ matrix.goarch }}
-          path: build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
+          name: wings_linux_${{ matrix.goarch }}
+          path: build/wings_linux_${{ matrix.goarch }}
+      - name: Upload Debug Artifact
+        uses: actions/upload-artifact@v2
+        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
+        with:
+          name: wings_linux_${{ matrix.goarch }}_debug
+          path: build/wings_linux_${{ matrix.goarch }}_debug

.github/workflows/codeql-analysis.yml

@@ -2,30 +2,29 @@ name: CodeQL
 on:
   push:
     branches:
-      - 'develop'
+      - develop
   pull_request:
     branches:
-      - 'develop'
+      - develop
   schedule:
     - cron: '0 9 * * 4'
 jobs:
   analyze:
     name: Analyze
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
     strategy:
       fail-fast: false
       matrix:
-        language:
-          - go
+        language: [ 'go' ]
     steps:
-      - name: Code Checkout
-        uses: actions/checkout@v2
-      - name: Checkout Head
-        run: git checkout HEAD^2
-        if: ${{ github.event_name == 'pull_request' }}
+      - uses: actions/checkout@v2
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v1
         with:
           languages: ${{ matrix.language }}
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+      - uses: github/codeql-action/autobuild@v1
+      - uses: github/codeql-action/analyze@v1

.github/workflows/docker.yml

@@ -2,8 +2,7 @@ name: Publish Docker Image
 on:
   push:
     branches:
-      - 'develop'
-
+      - develop
     tags:
       - 'v*'
 jobs:
@@ -35,7 +34,7 @@ jobs:
       - name: Get Build Information
         id: build_info
         run: |
-          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
+          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\/v/}"
           echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
       - name: Release Production Build
         uses: docker/build-push-action@v2
@@ -44,6 +43,7 @@ jobs:
           build-args: |
             VERSION=${{ steps.build_info.outputs.version_tag }}
           labels: ${{ steps.docker_meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: ${{ steps.docker_meta.outputs.tags }}
       - name: Release Development Build
@@ -53,5 +53,6 @@ jobs:
           build-args: |
             VERSION=dev-${{ steps.build_info.outputs.short_sha }}
           labels: ${{ steps.docker_meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.docker_meta.outputs.tags }}

.github/workflows/release.yml

@@ -11,7 +11,7 @@ jobs:
         uses: actions/checkout@v2
       - uses: actions/setup-go@v2
         with:
-          go-version: '^1.15'
+          go-version: '^1.17'
       - name: Build
         env:
           REF: ${{ github.ref }}
@@ -45,7 +45,7 @@ jobs:
           git config --local user.name "Pterodactyl CI"
           git checkout -b $BRANCH
           git push -u origin $BRANCH
-          sed -i "s/	Version = \".*\"/	Version = \"${REF:11}\"/" system/const.go
+          sed -i "s/var Version = \".*\"/var Version = \"${REF:11}\"/" system/const.go
           git add system/const.go
           git commit -m "bump version for release"
           git push

.gitignore

@@ -49,3 +49,4 @@ debug
 .DS_Store
 *.pprof
 *.pdf
+pprof.*

CHANGELOG.md

@@ -1,5 +1,163 @@
 # Changelog
 
+## v1.6.1
+### Fixed
+* Fixes error that would sometimes occur when starting a server that would cause the temporary power action lock to never be released due to a blocked channel.
+* Fixes a bug causing the CPU usage of Wings to get stuck at 100% when a server is deleted while the installation process is running.
+
+### Changed
+* Cleans up a lot of the logic for handling events between the server and environment process to make it easier to make modifications to down the road.
+* Cleans up logic handling the `StopAndWait` logic for stopping a server gracefully before terminating the process if it does not respond.
+
+## v1.6.0
+### Fixed
+* Internal logic for processing a server start event has been adjusted to attach to the Docker container before attempting to start the container. This should fix issues where a server would get stuck after pulling the container image.
+* Fixes a bug in the console output that was dropping console lines when a large number of lines were sent at once.
+
+### Changed
+* Removed the console throttle logic that would terminate a server instance that was sending too much data. This logic has been replaced with simpler logic that only throttles the console, it does not try to terminate the server. In addition, this change has reduced the number of go-routines needed by the application and dramatically simplified internal logic.
+* Removed the `--profiler` flag and replaced it with `--pprof` which will start an internal server listening on `localhost:6060` allowing you to use Go's standard `pprof` tooling.
+* Replaced the `json` log driver for Docker containers with `local` to reduce the amount of overhead when it comes to streaming logs from instances.
+
+## v1.5.6
+### Fixed
+* Rewrote handler logic for the power actions lock to hopefully address issues people have been having when a server crashes and they're unable to start it again until restarting Wings.
+* Fixes files uploaded with SFTP not being owned by the Pterodactyl user.
+* Fixes excessive memory usage when large lines are sent through the console event handler.
+
+### Changed
+* Replaced usage of `encoding/json` throughout the codebase with a more performant encoder (`goccy/go-json`) to hopefully improve overall performance for JSON operations.
+* Added custom `ContainerInspect` function to handle direct calls to Docker's CLI and make use of the new JSON encoder logic. This should reduce the total number of memory allocations and be more performant overall in a hot pathway.
+
+## v1.5.5
+### Fixed
+* Fixes sending to a closed channel when sending server logs over the websocket
+* Fixes `wings diagnostics` uploading no content
+* Fixes a panic caused by the event bus closing channels multiple times when a server is deleted
+
+## v1.5.4
+### Fixed
+* Fixes SSL paths being improperly converted to lowercase in environments where the path is case-sensitive.
+* Fixes a memory leak due to the implemention of server event processing.
+
+### Changed
+* Selecting to redact information now redacts URLs from the log output when running the diagnostic command.
+
+### Added
+* Adds support for modifying the default memory overhead percentages in environments where the shipped values are not adequate.
+* Adds support for sending the `Access-Control-Request-Private-Network` header in environments where Wings will be accessed over a private network. This is defaulted to `off`.
+
+## v1.5.3
+### Fixed
+* Fixes improper event registration and error handling during socket authentication that would cause the incorrect error message to be returned to the client, or no error in some scenarios. Event registration is now delayed until the socket is fully authenticated to ensure needless listeners are not registed.
+* Fixes dollar signs always being evaluated as environment variables with no way to escape them. They can now be escaped as `$$` which will transform into a single dollar sign.
+
+### Changed
+* A websocket connection to a server will be closed by Wings if there is a send error encountered and the client will be left to handle reconnections, rather than simply logging the error and continuing to listen for new events.
+
+## v1.5.2
+### Fixed
+* Fixes servers not properly re-syncing with the Panel if they are already running causing them to be hard-stopped when terminated, rather than stopped with the configured action.
+
+### Changed
+* Changes SFTP server implementation to use ED25519 server keys rather than deprecated SHA1 RSA keys.
+
+### Added
+* Adds server uptime output in the stats event emitted to the websocket.
+
+## v1.5.1
+### Added
+* Global configuration option for toggling server crash detection (`system.crash_detection.enabled`)
+* RPM specfile
+
+## v1.5.0
+### Fixed
+* Fixes a race condition when setting the application name in the console output for a server.
+* Fixes a server being reinstalled causing the `file_denylist` parameter for an Egg to be ignored until Wings is restarted.
+* Fixes YAML file parser not correctly setting boolean values.
+* Fixes potential issue where the underlying websocket connection is closed but the parent request context is not yet canceled causing a write over a closed connection.
+* Fixes race condition when closing all active websocket connections when a server is deleted.
+* Fixes logic to determine if a server's context is closed out and send a websocket close message to connected clients. Previously this fired off whenever the request itself was closed, and not when the server context was closed.
+
+### Added
+* Exposes `8080` in the default Docker setup to better support proxy tools.
+
+### Changed
+* Releases are now built using `Go 1.17` — the minimum version required to build Wings remains `Go 1.16`.
+* Simplifed the logic powering server updates to only pull information from the Panel rather than trying to accept updated values. All parts of Wings needing the most up-to-date server details should call `Server#Sync()` to fetch the latest stored build information.
+* `Installer#New()` no longer requires passing all of the server data as a byte slice, rather a new `Installer#ServerDetails` struct is exposed which can be passed and accepts a UUID and if the server should be started after the installer finishes.
+
+### Removed
+* Removes complicated (and unused) logic during the server installation process that was a hold-over from legacy Wings architectures.
+* Removes the `PATCH /api/servers/:server` endpoint — if you were previously using this API call it should be replaced with `POST /api/servers/:server/sync`.
+
+## v1.4.7
+### Fixed
+* SFTP access is now properly denied if a server is suspended.
+* Correctly uses `start_on_completion` and `crash_detection_enabled` for servers.
+
+## v1.4.6
+### Fixed
+* Environment variable starting with the same prefix no longer get merged into a single environment variable value (skipping all but the first).
+* The `start_on_completion` flag for server installs will now properly start the server.
+* Fixes socket files unintentionally causing backups to be aborted.
+* Files extracted from a backup now have their preior mode properly set on the restored files, rather than defaulting to 0644.
+* Fixes logrotate issues due to a bad user configuration on some systems.
+
+### Updated
+* The minimum Go version required to compile Wings is now `go1.16`.
+
+### Deprecated
+> Both of these deprecations will be removed in `Wings@2.0.0`.
+
+* The `Server.Id()` method has been deprecated in favor of `Server.ID()`.
+* The `directory` field on the `/api/servers/:server/files/pull` endpoint is deprecated and should be updated to use `root` instead for consistency with other endpoints.
+
+## v1.4.5
+### Changed
+* Upped the process limit for a container from `256` to `512` in order to address edge-cases for some games that spawn a lot of processes.
+
+## v1.4.4
+### Added
+* **[security]** Adds support for limiting the total number of pids any one container can have active at once to prevent malicious users from impacting other instances on the same node.
+* Server install containers now use the limits assigned to the server, or a globally defined minimum amount of memory and CPU rather than having unlimited resources.
+
+## v1.4.3
+This build was created to address `CVE-2021-33196` in `Go` which requires a new binary
+be built on the latest `go1.15` version.
+
+## v1.4.2
+### Fixed
+* Fixes the `~` character not being properly trimmed from container image names when creating a new server.
+
+### Changed
+* Implemented exponential backoff for S3 uploads when working with backups. This should resolve many issues with external S3 compatiable systems that sometimes return 5xx level errors that should be re-attempted automatically.
+* Implements exponential backoff behavior for all API calls to the Panel that do not immediately return a 401, 403, or 429 error response. This should address fragiligty in some API calls and address random call failures due to connection drops or random DNS resolution errors.
+
+## 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.

Dockerfile

@@ -1,8 +1,8 @@
 # Stage 1 (Build)
-FROM golang:1.15-alpine3.12 AS builder
+FROM --platform=$BUILDPLATFORM golang:1.17-alpine AS builder
 
 ARG VERSION
-RUN apk add --update --no-cache git=2.26.2-r0 make=4.3-r0 upx=3.96-r0
+RUN apk add --update --no-cache git make upx
 WORKDIR /app/
 COPY go.mod go.sum /app/
 RUN go mod download
@@ -14,9 +14,13 @@ RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
     -o wings \
     wings.go
 RUN upx wings
+RUN echo "ID=\"distroless\"" > /etc/os-release
 
 # Stage 2 (Final)
-FROM busybox:1.33.0
-RUN echo "ID=\"busybox\"" > /etc/os-release
+FROM gcr.io/distroless/static:latest
+COPY --from=builder /etc/os-release /etc/os-release
+
 COPY --from=builder /app/wings /usr/bin/
-CMD [ "wings", "--config", "/etc/pterodactyl/config.yml" ]
+CMD [ "/usr/bin/wings", "--config", "/etc/pterodactyl/config.yml" ]
+
+EXPOSE 8080

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

@@ -5,8 +5,8 @@ build:
 	GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_arm64 -v wings.go
 
 debug:
-	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
-	sudo ./wings --debug --ignore-certificate-errors --config config.yml
+	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)"
+	sudo ./wings --debug --ignore-certificate-errors --config config.yml --pprof --pprof-block-rate 1
 
 # Runs a remotly debuggable session for Wings allowing an IDE to connect and target
 # different breakpoints.

README.md

@@ -19,14 +19,22 @@ 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. |
+| [**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://chs.gg/) | 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*! |
+| [**Aussie Server Hosts**](https://aussieserverhosts.com/) | No frills Australian Owned and operated High Performance Server hosting for some of the most demanding games serving Australia and New Zealand. |
+| [**VibeGAMES**](https://vibegames.net/) | VibeGAMES is a game server provider that specializes in DDOS protection for the games we offer. We have multiple locations in the US, Brazil, France, Germany, Singapore, Australia and South Africa.|
+| [**RocketNode**](https://rocketnode.net) | RocketNode is a VPS and Game Server provider that offers the best performing VPS and Game hosting Solutions at affordable prices! |
 
 ## Documentation
 * [Panel Documentation](https://pterodactyl.io/panel/1.0/getting_started.html)

cmd/configure.go

@@ -2,9 +2,8 @@ package cmd
 
 import (
 	"crypto/tls"
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -14,12 +13,13 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
-	"github.com/pterodactyl/wings/config"
+	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
+
+	"github.com/pterodactyl/wings/config"
 )
 
-var (
-	configureArgs struct {
+var configureArgs struct {
 	PanelURL      string
 	Token         string
 	ConfigPath    string
@@ -27,7 +27,6 @@ var (
 	Override      bool
 	AllowInsecure bool
 }
-)
 
 var nodeIdRegex = regexp.MustCompile(`^(\d+)$`)
 
@@ -139,13 +138,13 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 		fmt.Println("The authentication credentials provided were not valid.")
 		os.Exit(1)
 	} else if res.StatusCode != http.StatusOK {
-		b, _ := ioutil.ReadAll(res.Body)
+		b, _ := io.ReadAll(res.Body)
 
 		fmt.Println("An error occurred while processing this request.\n", string(b))
 		os.Exit(1)
 	}
 
-	b, err := ioutil.ReadAll(res.Body)
+	b, err := io.ReadAll(res.Body)
 
 	cfg, err := config.NewAtPath(configPath)
 	if err != nil {

cmd/diagnostics.go

@@ -2,11 +2,9 @@ package cmd
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os/exec"
@@ -21,25 +19,27 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/parsers/kernel"
 	"github.com/docker/docker/pkg/parsers/operatingsystem"
+	"github.com/goccy/go-json"
+	"github.com/spf13/cobra"
+
 	"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"
 )
 
-const DefaultHastebinUrl = "https://ptero.co"
-const DefaultLogLines = 200
+const (
+	DefaultHastebinUrl = "https://ptero.co"
+	DefaultLogLines    = 200
+)
 
-var (
-	diagnosticsArgs struct {
+var diagnosticsArgs struct {
 	IncludeEndpoints   bool
 	IncludeLogs        bool
 	ReviewBeforeUpload bool
 	HastebinURL        string
 	LogLines           int
 }
-)
 
 func newDiagnosticsCommand() *cobra.Command {
 	command := &cobra.Command{
@@ -78,7 +78,7 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		{
 			Name: "ReviewBeforeUpload",
 			Prompt: &survey.Confirm{
-				Message: "Do you want to review the collected data before uploading to hastebin.com?",
+				Message: "Do you want to review the collected data before uploading to " + diagnosticsArgs.HastebinURL + "?",
 				Help:    "The data, especially the logs, might contain sensitive information, so you should review it. You will be asked again if you want to upload.",
 				Default: true,
 			},
@@ -96,7 +96,7 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	output := &strings.Builder{}
 	fmt.Fprintln(output, "Pterodactyl Wings - Diagnostics Report")
 	printHeader(output, "Versions")
-	fmt.Fprintln(output, "         wings:", system.Version)
+	fmt.Fprintln(output, "               Wings:", system.Version)
 	if dockerErr == nil {
 		fmt.Fprintln(output, "              Docker:", dockerVersion.Version)
 	}
@@ -109,7 +109,6 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 
 	printHeader(output, "Wings Configuration")
 	if err := config.FromFile(config.DefaultLocation); err != nil {
-
 	}
 	cfg := config.Get()
 	fmt.Fprintln(output, "      Panel Location:", redact(cfg.PanelLocation))
@@ -180,6 +179,17 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		fmt.Fprintln(output, "Logs redacted.")
 	}
 
+	if !diagnosticsArgs.IncludeEndpoints {
+		s := output.String()
+		output.Reset()
+		s = strings.ReplaceAll(s, cfg.PanelLocation, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Host, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.CertificateFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.KeyFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.System.Sftp.Address, "{redacted}")
+		output.WriteString(s)
+	}
+
 	fmt.Println("\n---------------  generated report  ---------------")
 	fmt.Println(output.String())
 	fmt.Print("---------------   end of report    ---------------\n\n")
@@ -225,7 +235,7 @@ func uploadToHastebin(hbUrl, content string) (string, error) {
 		return "", err
 	}
 	pres := make(map[string]interface{})
-	body, err := ioutil.ReadAll(res.Body)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
 		fmt.Println("Failed to parse response.", err)
 		return "", err

cmd/root.go

@@ -1,16 +1,21 @@
 package cmd
 
 import (
+	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	log2 "log"
 	"net/http"
+	_ "net/http/pprof"
 	"os"
+	"os/signal"
 	"path"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"strings"
+	"syscall"
 	"time"
 
 	"github.com/NYTimes/logrotate"
@@ -19,18 +24,19 @@ import (
 	"github.com/docker/docker/client"
 	"github.com/gammazero/workerpool"
 	"github.com/mitchellh/colorstring"
-	"github.com/pkg/profile"
+	"github.com/spf13/cobra"
+	"golang.org/x/crypto/acme"
+	"golang.org/x/crypto/acme/autocert"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/internal/notify"
 	"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"
 	"github.com/pterodactyl/wings/system"
-	"github.com/spf13/cobra"
-	"golang.org/x/crypto/acme"
-	"golang.org/x/crypto/acme/autocert"
 )
 
 var (
@@ -40,7 +46,7 @@ var (
 
 var rootCommand = &cobra.Command{
 	Use:   "wings",
-	Short: "Runs the API server allowing programatic control of game servers for Pterodactyl Panel.",
+	Short: "Runs the API server allowing programmatic control of game servers for Pterodactyl Panel.",
 	PreRun: func(cmd *cobra.Command, args []string) {
 		initConfig()
 		initLogging()
@@ -58,7 +64,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())
 	},
 }
 
@@ -73,7 +79,9 @@ func init() {
 	rootCommand.PersistentFlags().BoolVar(&debug, "debug", false, "pass in order to run wings in debug mode")
 
 	// Flags specifically used when running the API.
-	rootCommand.Flags().String("profiler", "", "the profiler to run for this instance")
+	rootCommand.Flags().Bool("pprof", false, "if the pprof profiler should be enabled. The profiler will bind to localhost:6060 by default")
+	rootCommand.Flags().Int("pprof-block-rate", 0, "enables block profile support, may have performance impacts")
+	rootCommand.Flags().Int("pprof-port", 6060, "If provided with --pprof, the port it will run on")
 	rootCommand.Flags().Bool("auto-tls", false, "pass in order to have wings generate and manage it's own SSL certificates using Let's Encrypt")
 	rootCommand.Flags().String("tls-hostname", "", "required with --auto-tls, the FQDN for the generated SSL certificate")
 	rootCommand.Flags().Bool("ignore-certificate-errors", false, "ignore certificate verification errors when executing API calls")
@@ -84,25 +92,6 @@ func init() {
 }
 
 func rootCmdRun(cmd *cobra.Command, _ []string) {
-	switch cmd.Flag("profiler").Value.String() {
-	case "cpu":
-		defer profile.Start(profile.CPUProfile).Stop()
-	case "mem":
-		defer profile.Start(profile.MemProfile).Stop()
-	case "alloc":
-		defer profile.Start(profile.MemProfile, profile.MemProfileAllocs()).Stop()
-	case "heap":
-		defer profile.Start(profile.MemProfile, profile.MemProfileHeap()).Stop()
-	case "routines":
-		defer profile.Start(profile.GoroutineProfile).Stop()
-	case "mutex":
-		defer profile.Start(profile.MutexProfile).Stop()
-	case "threads":
-		defer profile.Start(profile.ThreadcreationProfile).Stop()
-	case "block":
-		defer profile.Start(profile.BlockProfile).Stop()
-	}
-
 	printLogo()
 	log.Debug("running in debug mode")
 	log.WithField("config_file", configPath).Info("loading configuration from file")
@@ -122,11 +111,6 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
 		return
 	}
-	if err := config.EnableLogRotation(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
-		return
-	}
-
 	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")
@@ -136,6 +120,10 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		"uid":      config.Get().System.User.Uid,
 		"gid":      config.Get().System.User.Gid,
 	}).Info("configured system user successfully")
+	if err := config.EnableLogRotation(); err != nil {
+		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
+		return
+	}
 
 	pclient := remote.New(
 		config.Get().PanelLocation,
@@ -160,7 +148,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	// Just for some nice log output.
 	for _, s := range manager.All() {
-		log.WithField("server", s.Id()).Info("finished loading configuration for server")
+		log.WithField("server", s.ID()).Info("finished loading configuration for server")
 	}
 
 	states, err := manager.ReadStates()
@@ -202,14 +190,24 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		pool.Submit(func() {
 			s.Log().Info("configuring server environment and restoring to previous state")
 			var st string
-			if state, exists := states[s.Id()]; exists {
+			if state, exists := states[s.ID()]; exists {
 				st = state
 			}
 
-			r, err := s.Environment.IsRunning()
+			// Use a timed context here to avoid booting issues where Docker hangs for a
+			// specific container that would cause Wings to be un-bootable until the entire
+			// machine is rebooted. It is much better for us to just have a single failed
+			// server instance than an entire offline node.
+			//
+			// @see https://github.com/pterodactyl/panel/issues/2475
+			// @see https://github.com/pterodactyl/panel/issues/3358
+			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*30)
+			defer cancel()
+
+			r, err := s.Environment.IsRunning(ctx)
 			// We ignore missing containers because we don't want to actually block booting of wings at this
-			// point. If we didn't do this and you pruned all of the images and then started wings you could
-			// end up waiting a long period of time for all of the images to be re-pulled on Wings boot rather
+			// point. If we didn't do this, and you pruned all the images and then started wings you could
+			// end up waiting a long period of time for all the images to be re-pulled on Wings boot rather
 			// than when the server itself is started.
 			if err != nil && !client.IsErrNotFound(err) {
 				s.Log().WithField("error", err).Error("error checking server environment status")
@@ -235,7 +233,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				s.Log().Info("detected server is running, re-attaching to process...")
 
 				s.Environment.SetState(environment.ProcessRunningState)
-				if err := s.Environment.Attach(); err != nil {
+				if err := s.Environment.Attach(ctx); err != nil {
 					s.Log().WithField("error", err).Warn("failed to attach to running server environment")
 				}
 			} else {
@@ -244,13 +242,20 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				// state being tracked.
 				s.Environment.SetState(environment.ProcessOfflineState)
 			}
+
+			if state := s.Environment.State(); state == environment.ProcessStartingState || state == environment.ProcessRunningState {
+				s.Log().Debug("re-syncing server configuration for already running server")
+				if err := s.Sync(); err != nil {
+					s.Log().WithError(err).Error("failed to re-sync server configuration")
+				}
+			}
 		})
 	}
 
-	// Wait until all of the servers are ready to go before we fire up the SFTP and HTTP servers.
+	// Wait until all 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
+		// Cancel the context on all the running servers at this point, even though the
 		// program is just shutting down.
 		for _, s := range manager.All() {
 			s.CtxCancel()
@@ -267,7 +272,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	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
+		// Update all 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")
@@ -276,12 +281,12 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(sys.ArchiveDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.ArchiveDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create archive directory")
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(sys.BackupDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.BackupDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create backup directory")
 	}
 
@@ -307,7 +312,22 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		TLSConfig: config.DefaultTLSConfig,
 	}
 
+	profile, _ := cmd.Flags().GetBool("pprof")
+	if profile {
+		if r, _ := cmd.Flags().GetInt("pprof-block-rate"); r > 0 {
+			runtime.SetBlockProfileRate(r)
+		}
+		// Catch at least 1% of mutex contention issues.
+		runtime.SetMutexProfileFraction(100)
+
+		profilePort, _ := cmd.Flags().GetInt("pprof-port")
+		go func() {
+			http.ListenAndServe(fmt.Sprintf("localhost:%d", profilePort), nil)
+		}()
+	}
+
 	// Check if the server should run with TLS but using autocert.
+	go func(s *http.Server, api config.ApiConfiguration, sys config.SystemConfiguration, autotls bool, tlshostname string) {
 		if autotls {
 			m := autocert.Manager{
 				Prompt:     autocert.AcceptTOS,
@@ -337,7 +357,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		// 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 {
+			if err := s.ListenAndServeTLS(api.Ssl.CertificateFile, api.Ssl.KeyFile); err != nil {
 				log.WithFields(log.Fields{"auto_tls": false, "error": err}).Fatal("failed to configure HTTPS server")
 			}
 			return
@@ -346,10 +366,23 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		if err := s.ListenAndServe(); err != nil {
 			log.WithField("error", err).Fatal("failed to configure HTTP server")
 		}
+	}(s, api, sys, autotls, tlshostname)
+
+	if err := notify.Readiness(); err != nil {
+		log.WithField("error", err).Error("failed to notify systemd of readiness state")
+	}
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
+	<-c
+
+	if err := notify.Stopping(); err != nil {
+		log.WithField("error", err).Error("failed to notify systemd of stopping state")
+	}
 }
 
 // Reads the configuration from the disk and then sets up the global singleton
-// with all of the configuration values.
+// with all the configuration values.
 func initConfig() {
 	if !strings.HasPrefix(configPath, "/") {
 		d, err := os.Getwd()
@@ -374,7 +407,7 @@ func initConfig() {
 // in the code without having to pass around a logger instance.
 func initLogging() {
 	dir := config.Get().System.LogDirectory
-	if err := os.MkdirAll(path.Join(dir, "/install"), 0700); err != nil {
+	if err := os.MkdirAll(path.Join(dir, "/install"), 0o700); err != nil {
 		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
 	}
 	p := filepath.Join(dir, "/wings.log")
@@ -400,7 +433,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
@@ -408,7 +441,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() {

config/config.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/user"
@@ -21,8 +20,9 @@ import (
 	"github.com/cobaugh/osrelease"
 	"github.com/creasty/defaults"
 	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/pterodactyl/wings/system"
 	"gopkg.in/yaml.v2"
+
+	"github.com/pterodactyl/wings/system"
 )
 
 const DefaultLocation = "/etc/pterodactyl/config.yml"
@@ -47,13 +47,15 @@ var DefaultTLSConfig = &tls.Config{
 	CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
 }
 
-var mu sync.RWMutex
-var _config *Configuration
-var _jwtAlgo *jwt.HMACSHA
-var _debugViaFlag bool
+var (
+	mu            sync.RWMutex
+	_config       *Configuration
+	_jwtAlgo      *jwt.HMACSHA
+	_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.
+// 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.
@@ -87,8 +89,8 @@ type ApiConfiguration struct {
 	// 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"`
+	// The maximum size for files uploaded through the Panel in MB.
+	UploadLimit int64 `default:"100" json:"upload_limit" yaml:"upload_limit"`
 }
 
 // RemoteQueryConfiguration defines the configuration settings for remote requests
@@ -130,6 +132,10 @@ type SystemConfiguration struct {
 	// Directory where local backups will be stored on the machine.
 	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`
 
+	// TmpDirectory specifies where temporary files for Pterodactyl installation processes
+	// should be created. This supports environments running docker-in-docker.
+	TmpDirectory string `default:"/tmp/pterodactyl" yaml:"tmp_directory"`
+
 	// The user that should own all of the server files, and be used for containers.
 	Username string `default:"pterodactyl" yaml:"username"`
 
@@ -180,6 +186,9 @@ type SystemConfiguration struct {
 }
 
 type CrashDetection struct {
+	// CrashDetectionEnabled sets if crash detection is enabled globally for all servers on this node.
+	CrashDetectionEnabled bool `default:"true" yaml:"enabled"`
+
 	// 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.
@@ -217,26 +226,14 @@ 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
+	// The total number of lines that can be output in a given Period 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"`
+	Period uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
 }
 
 type Configuration struct {
@@ -247,6 +244,8 @@ type Configuration struct {
 	// 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
 
@@ -279,6 +278,12 @@ type Configuration struct {
 	// The Panel URL is automatically allowed, this is only needed for adding
 	// additional origins.
 	AllowedOrigins []string `json:"allowed_origins" yaml:"allowed_origins"`
+
+	// AllowCORSPrivateNetwork sets the `Access-Control-Request-Private-Network` header which
+	// allows client browsers to make requests to internal IP addresses over HTTP.  This setting
+	// is only required by users running Wings without SSL certificates and using internal IP
+	// addresses in order to connect. Most users should NOT enable this setting.
+	AllowCORSPrivateNetwork bool `json:"allow_cors_private_network" yaml:"allow_cors_private_network"`
 }
 
 // NewAtPath creates a new struct and set the path where it should be stored.
@@ -372,7 +377,7 @@ func WriteToDisk(c *Configuration) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(c.path, b, 0600); err != nil {
+	if err := os.WriteFile(c.path, b, 0o600); err != nil {
 		return err
 	}
 	return nil
@@ -392,10 +397,10 @@ func EnsurePterodactylUser() error {
 	}
 
 	// Our way of detecting if wings is running inside of Docker.
-	if sysName == "busybox" {
+	if sysName == "distroless" {
 		_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_UID"), "988"))
+		_config.System.User.Gid = system.MustInt(system.FirstNotEmpty(os.Getenv("WINGS_GID"), "988"))
 		return nil
 	}
 
@@ -440,7 +445,7 @@ func EnsurePterodactylUser() error {
 // 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)
+	b, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -448,18 +453,17 @@ func FromFile(path string) error {
 	if err != nil {
 		return err
 	}
-	// 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
 }
 
-// ConfigureDirectories ensures that all of the system directories exist on the
+// ConfigureDirectories ensures that all the system directories exist on the
 // system. These directories are created so that only the owner can read the data,
 // and no other users.
 //
@@ -467,7 +471,7 @@ func FromFile(path string) error {
 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 {
+	if err := os.MkdirAll(root, 0o700); err != nil {
 		return err
 	}
 
@@ -488,17 +492,17 @@ func ConfigureDirectories() error {
 	}
 
 	log.WithField("path", _config.System.Data).Debug("ensuring server data directory exists")
-	if err := os.MkdirAll(_config.System.Data, 0700); err != nil {
+	if err := os.MkdirAll(_config.System.Data, 0o700); 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 {
+	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0o700); 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 {
+	if err := os.MkdirAll(_config.System.BackupDirectory, 0o700); err != nil {
 		return err
 	}
 
@@ -536,8 +540,7 @@ func EnableLogRotation() error {
 	}
 	defer f.Close()
 
-	t, err := template.New("logrotate").Parse(`
-{{.LogDirectory}}/wings.log {
+	t, err := template.New("logrotate").Parse(`{{.LogDirectory}}/wings.log {
     size 10M
     compress
     delaycompress
@@ -545,9 +548,8 @@ func EnableLogRotation() error {
     maxage 7
     missingok
     notifempty
-    create 0640 {{.User.Uid}} {{.User.Gid}}
     postrotate
-        killall -SIGHUP wings
+        /usr/bin/systemctl kill -s HUP wings.service >/dev/null 2>&1 || true
     endscript
 }`)
 	if err != nil {
@@ -573,7 +575,7 @@ func ConfigureTimezone() error {
 		_config.System.Timezone = tz
 	}
 	if _config.System.Timezone == "" {
-		b, err := ioutil.ReadFile("/etc/timezone")
+		b, err := os.ReadFile("/etc/timezone")
 		if err != nil {
 			if !os.IsNotExist(err) {
 				return errors.WithMessage(err, "config: failed to open timezone file")

config/config_docker.go

@@ -2,9 +2,10 @@ package config
 
 import (
 	"encoding/base64"
-	"encoding/json"
+	"sort"
 
 	"github.com/docker/docker/api/types"
+	"github.com/goccy/go-json"
 )
 
 type dockerNetworkInterfaces struct {
@@ -51,10 +52,31 @@ type DockerConfiguration struct {
 	// Registries .
 	Registries map[string]RegistryConfiguration `json:"registries" yaml:"registries"`
 
-	// The size of the /tmp directory when mounted into a container. Please be aware that Docker
-	// utilizes host memory for this value, and that we do not keep track of the space used here
-	// so avoid allocating too much to a server.
+	// TmpfsSize specifies the size for the /tmp directory mounted into containers. Please be
+	// aware that Docker utilizes the host's system memory for this value, and that we do not
+	// keep track of the space used there, so avoid allocating too much to a server.
 	TmpfsSize uint `default:"100" json:"tmpfs_size" yaml:"tmpfs_size"`
+
+	// ContainerPidLimit sets the total number of processes that can be active in a container
+	// at any given moment. This is a security concern in shared-hosting environments where a
+	// malicious process could create enough processes to cause the host node to run out of
+	// available pids and crash.
+	ContainerPidLimit int64 `default:"512" json:"container_pid_limit" yaml:"container_pid_limit"`
+
+	// InstallerLimits defines the limits on the installer containers that prevents a server's
+	// installation process from unintentionally consuming more resources than expected. This
+	// is used in conjunction with the server's defined limits. Whichever value is higher will
+	// take precedence in the installer containers.
+	InstallerLimits struct {
+		Memory int64 `default:"1024" json:"memory" yaml:"memory"`
+		Cpu    int64 `default:"100" json:"cpu" yaml:"cpu"`
+	} `json:"installer_limits" yaml:"installer_limits"`
+
+	// Overhead controls the memory overhead given to all containers to circumvent certain
+	// software such as the JVM not staying below the maximum memory limit.
+	Overhead Overhead `json:"overhead" yaml:"overhead"`
+
+	UsePerformantInspect bool `default:"true" json:"use_performant_inspect" yaml:"use_performant_inspect"`
 }
 
 // RegistryConfiguration defines the authentication credentials for a given
@@ -76,3 +98,62 @@ func (c RegistryConfiguration) Base64() (string, error) {
 	}
 	return base64.URLEncoding.EncodeToString(b), nil
 }
+
+// Overhead controls the memory overhead given to all containers to circumvent certain
+// software such as the JVM not staying below the maximum memory limit.
+type Overhead struct {
+	// Override controls if the overhead limits should be overridden by the values in the config file.
+	Override bool `default:"false" json:"override" yaml:"override"`
+
+	// DefaultMultiplier sets the default multiplier for if no Multipliers are able to be applied.
+	DefaultMultiplier float64 `default:"1.05" json:"default_multiplier" yaml:"default_multiplier"`
+
+	// Multipliers allows overriding DefaultMultiplier depending on the amount of memory
+	// configured for a server.
+	//
+	// Default values (used if Override is `false`)
+	// - Less than 2048 MB of memory, multiplier of 1.15 (15%)
+	// - Less than 4096 MB of memory, multiplier of 1.10 (10%)
+	// - Otherwise, multiplier of 1.05 (5%) - specified in DefaultMultiplier
+	//
+	// If the defaults were specified in the config they would look like:
+	// ```yaml
+	// multipliers:
+	//   2048: 1.15
+	//   4096: 1.10
+	// ```
+	Multipliers map[int]float64 `json:"multipliers" yaml:"multipliers"`
+}
+
+func (o Overhead) GetMultiplier(memoryLimit int64) float64 {
+	// Default multiplier values.
+	if !o.Override {
+		if memoryLimit <= 2048 {
+			return 1.15
+		} else if memoryLimit <= 4096 {
+			return 1.10
+		}
+		return 1.05
+	}
+
+	// This plucks the keys of the Multipliers map, so they can be sorted from
+	// smallest to largest in order to correctly apply the proper multiplier.
+	i := 0
+	multipliers := make([]int, len(o.Multipliers))
+	for k := range o.Multipliers {
+		multipliers[i] = k
+		i++
+	}
+	sort.Ints(multipliers)
+
+	// Loop through the memory values in order (smallest to largest)
+	for _, m := range multipliers {
+		// If the server's memory limit exceeds the modifier's limit, don't apply it.
+		if memoryLimit > int64(m) {
+			continue
+		}
+		return o.Multipliers[m]
+	}
+
+	return o.DefaultMultiplier
+}

environment/allocations.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 
 	"github.com/docker/go-connections/nat"
+
 	"github.com/pterodactyl/wings/config"
 )
 
@@ -19,7 +20,7 @@ type Allocations struct {
 		Port int    `json:"port"`
 	} `json:"default"`
 
-	// Mappings contains all of the ports that should be assigned to a given server
+	// Mappings contains all the ports that should be assigned to a given server
 	// attached to the IP they correspond to.
 	Mappings map[string][]int `json:"mappings"`
 }
@@ -30,7 +31,7 @@ type Allocations struct {
 //
 // You'll want to use DockerBindings() if you need to re-map 127.0.0.1 to the Docker interface.
 func (a *Allocations) Bindings() nat.PortMap {
-	var out = nat.PortMap{}
+	out := nat.PortMap{}
 
 	for ip, ports := range a.Mappings {
 		for _, port := range ports {
@@ -62,7 +63,7 @@ func (a *Allocations) DockerBindings() nat.PortMap {
 	iface := config.Get().Docker.Network.Interface
 
 	out := a.Bindings()
-	// Loop over all of the bindings for this container, and convert any that reference 127.0.0.1
+	// Loop over all the bindings for this container, and convert any that reference 127.0.0.1
 	// to use the pterodactyl0 network interface IP, as that is the true local for what people are
 	// trying to do when creating servers.
 	for p, binds := range out {
@@ -93,7 +94,7 @@ func (a *Allocations) DockerBindings() nat.PortMap {
 // To accomplish this, we'll just get the values from "DockerBindings" and then set them
 // to empty structs. Because why not.
 func (a *Allocations) Exposed() nat.PortSet {
-	var out = nat.PortSet{}
+	out := nat.PortSet{}
 
 	for port := range a.DockerBindings() {
 		out[port] = struct{}{}

environment/docker.go

@@ -10,11 +10,14 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/config"
 )
 
-var _conce sync.Once
-var _client *client.Client
+var (
+	_conce  sync.Once
+	_client *client.Client
+)
 
 // 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

environment/docker/api.go

@@ -0,0 +1,119 @@
+package docker
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+
+	"emperror.dev/errors"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/versions"
+	"github.com/docker/docker/client"
+	"github.com/docker/docker/errdefs"
+	"github.com/goccy/go-json"
+	"github.com/pterodactyl/wings/config"
+)
+
+var (
+	o           sync.Once
+	cli         cliSettings
+	fastEnabled bool
+)
+
+type cliSettings struct {
+	enabled bool
+	proto   string
+	host    string
+	scheme  string
+	version string
+}
+
+func configure(c *client.Client) {
+	o.Do(func() {
+		fastEnabled = config.Get().Docker.UsePerformantInspect
+
+		r := reflect.ValueOf(c).Elem()
+		cli.proto = r.FieldByName("proto").String()
+		cli.host = r.FieldByName("addr").String()
+		cli.scheme = r.FieldByName("scheme").String()
+		cli.version = r.FieldByName("version").String()
+	})
+}
+
+// ContainerInspect is a rough equivalent of Docker's client.ContainerInspect()
+// but re-written to use a more performant JSON decoder. This is important since
+// a large number of requests to this endpoint are spawned by Wings, and the
+// standard "encoding/json" shows its performance woes badly even with single
+// containers running.
+func (e *Environment) ContainerInspect(ctx context.Context) (types.ContainerJSON, error) {
+	configure(e.client)
+
+	// Support feature flagging of this functionality so that if something goes
+	// wrong for now it is easy enough for people to switch back to the older method
+	// of fetching stats.
+	if !fastEnabled {
+		return e.client.ContainerInspect(ctx, e.Id)
+	}
+
+	var st types.ContainerJSON
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "/containers/"+e.Id+"/json", nil)
+	if err != nil {
+		return st, errors.WithStack(err)
+	}
+
+	if cli.proto == "unix" || cli.proto == "npipe" {
+		req.Host = "docker"
+	}
+
+	req.URL.Host = cli.host
+	req.URL.Scheme = cli.scheme
+
+	res, err := e.client.HTTPClient().Do(req)
+	if err != nil {
+		if res == nil {
+			return st, errdefs.Unknown(err)
+		}
+		return st, errdefs.FromStatusCode(err, res.StatusCode)
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return st, errors.Wrap(err, "failed to read response body from Docker")
+	}
+	if err := parseErrorFromResponse(res, body); err != nil {
+		return st, errdefs.FromStatusCode(err, res.StatusCode)
+	}
+	if err := json.Unmarshal(body, &st); err != nil {
+		return st, errors.WithStack(err)
+	}
+	return st, nil
+}
+
+// parseErrorFromResponse is a re-implementation of Docker's
+// client.checkResponseErr() function.
+func parseErrorFromResponse(res *http.Response, body []byte) error {
+	if res.StatusCode >= 200 && res.StatusCode < 400 {
+		return nil
+	}
+
+	var ct string
+	if res.Header != nil {
+		ct = res.Header.Get("Content-Type")
+	}
+
+	var emsg string
+	if (cli.version == "" || versions.GreaterThan(cli.version, "1.23")) && ct == "application/json" {
+		var errResp types.ErrorResponse
+		if err := json.Unmarshal(body, &errResp); err != nil {
+			return errors.WithStack(err)
+		}
+		emsg = strings.TrimSpace(errResp.Message)
+	} else {
+		emsg = strings.TrimSpace(string(body))
+	}
+
+	return errors.Wrap(errors.New(emsg), "Error response from daemon")
+}

environment/docker/container.go

@@ -3,7 +3,6 @@ package docker
 import (
 	"bufio"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"strconv"
@@ -12,11 +11,13 @@ import (
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/buger/jsonparser"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
-	"github.com/docker/docker/daemon/logger/jsonfilelog"
+	"github.com/docker/docker/daemon/logger/local"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/system"
@@ -37,14 +38,14 @@ func (nw noopWriter) Write(b []byte) (int, error) {
 }
 
 // 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.
+// data in and out of the process stream. This should always be called before
+// you have started the container, but after you've ensured it exists.
 //
 // 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 {
+// until the container is stopped. The context provided to this function is used
+// for the purposes of attaching to the container, a seecond context is created
+// within the function for managing polling.
+func (e *Environment) Attach(ctx context.Context) error {
 	if e.IsAttached() {
 		return nil
 	}
@@ -61,14 +62,17 @@ func (e *Environment) Attach() error {
 	}
 
 	// Set the stream again with the container.
-	if st, err := e.client.ContainerAttach(context.Background(), e.Id, opts); err != nil {
+	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
 		return err
 	} else {
 		e.SetStream(&st)
 	}
 
 	go func() {
-		ctx, cancel := context.WithCancel(context.Background())
+		// Don't use the context provided to the function, that'll cause the polling to
+		// exit unexpectedly. We want a custom context for this, the one passed to the
+		// function is to avoid a hang situation when trying to attach to a container.
+		pollCtx, cancel := context.WithCancel(context.Background())
 		defer cancel()
 		defer e.stream.Close()
 		defer func() {
@@ -77,7 +81,7 @@ func (e *Environment) Attach() error {
 		}()
 
 		go func() {
-			if err := e.pollResources(ctx); err != nil {
+			if err := e.pollResources(pollCtx); err != nil {
 				if !errors.Is(err, context.Canceled) {
 					e.log().WithField("error", err).Error("error during environment resource polling")
 				} else {
@@ -114,7 +118,7 @@ func (e *Environment) InSituUpdate() error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
-	if _, err := e.client.ContainerInspect(ctx, e.Id); err != nil {
+	if _, err := e.ContainerInspect(ctx); 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
@@ -132,29 +136,29 @@ func (e *Environment) InSituUpdate() error {
 	//
 	// @see https://github.com/moby/moby/issues/41946
 	if _, err := e.client.ContainerUpdate(ctx, e.Id, container.UpdateConfig{
-		Resources: e.resources(),
+		Resources: e.Configuration.Limits().AsContainerResources(),
 	}); err != nil {
 		return errors.Wrap(err, "environment/docker: could not update container")
 	}
 	return nil
 }
 
-// Create creates a new container for the server using all of the data that is
+// Create creates a new container for the server using all 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
 	// container anyways.
-	if _, err := e.client.ContainerInspect(context.Background(), e.Id); err == nil {
+	if _, err := e.ContainerInspect(context.Background()); 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()
@@ -171,14 +175,14 @@ func (e *Environment) Create() error {
 	conf := &container.Config{
 		Hostname:     e.Id,
 		Domainname:   config.Get().Docker.Domainname,
-		User:         strconv.Itoa(config.Get().System.User.Uid),
+		User:         strconv.Itoa(config.Get().System.User.Uid) + ":" + strconv.Itoa(config.Get().System.User.Gid),
 		AttachStdin:  true,
 		AttachStdout: true,
 		AttachStderr: true,
 		OpenStdin:    true,
 		Tty:          true,
 		ExposedPorts: a.Exposed(),
-		Image:        e.meta.Image,
+		Image:        strings.TrimPrefix(e.meta.Image, "~"),
 		Env:          e.Configuration.EnvironmentVariables(),
 		Labels: map[string]string{
 			"Service":       "Pterodactyl",
@@ -192,7 +196,7 @@ func (e *Environment) Create() error {
 		PortBindings: a.DockerBindings(),
 
 		// Configure the mounts for this container. First mount the server data directory
-		// into the container as a r/w bind.
+		// into the container as an r/w bind.
 		Mounts: e.convertMounts(),
 
 		// Configure the /tmp folder mapping in containers. This is necessary for some
@@ -203,7 +207,7 @@ func (e *Environment) Create() error {
 
 		// Define resource limits for the container based on the data passed through
 		// from the Panel.
-		Resources: e.resources(),
+		Resources: e.Configuration.Limits().AsContainerResources(),
 
 		DNS: config.Get().Docker.Network.Dns,
 
@@ -212,11 +216,12 @@ func (e *Environment) Create() error {
 		// since we only need it for the last few hundred lines of output and don't care
 		// about anything else in it.
 		LogConfig: container.LogConfig{
-			Type: jsonfilelog.Name,
+			Type: local.Name,
 			Config: map[string]string{
 				"max-size": "5m",
 				"max-file": "1",
 				"compress": "false",
+				"mode":     "non-blocking",
 			},
 		},
 
@@ -230,7 +235,7 @@ 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
@@ -338,13 +343,11 @@ func (e *Environment) followOutput() error {
 func (e *Environment) scanOutput(reader io.ReadCloser) {
 	defer reader.Close()
 
-	events := e.Events()
-
-	err := system.ScanReader(reader, func(line string) {
-		events.Publish(environment.ConsoleOutputEvent, line)
-	})
-
-	if err != nil && err != io.EOF {
+	if err := system.ScanReader(reader, func(v []byte) {
+		e.logCallbackMx.Lock()
+		defer e.logCallbackMx.Unlock()
+		e.logCallback(v)
+	}); err != nil && err != io.EOF {
 		log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
 		return
 	}
@@ -354,7 +357,7 @@ func (e *Environment) scanOutput(reader io.ReadCloser) {
 		return
 	}
 
-	// Close the current reader before starting a new one, the defer will still run
+	// Close the current reader before starting a new one, the defer will still run,
 	// but it will do nothing if we already closed the stream.
 	_ = reader.Close()
 
@@ -362,17 +365,12 @@ func (e *Environment) scanOutput(reader io.ReadCloser) {
 	go e.followOutput()
 }
 
-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
+// late, and we don't need to block all 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 {
@@ -420,7 +418,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 {
@@ -441,7 +439,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()
 
@@ -452,12 +450,11 @@ func (e *Environment) ensureImageExists(image string) error {
 	scanner := bufio.NewScanner(out)
 
 	for scanner.Scan() {
-		s := imagePullStatus{}
-		fmt.Println(scanner.Text())
+		b := scanner.Bytes()
+		status, _ := jsonparser.GetString(b, "status")
+		progress, _ := jsonparser.GetString(b, "progress")
 
-		if err := json.Unmarshal(scanner.Bytes(), &s); err == nil {
-			e.Events().Publish(environment.DockerImagePullStatus, s.Status+" "+s.Progress)
-		}
+		e.Events().Publish(environment.DockerImagePullStatus, status+" "+progress)
 	}
 
 	if err := scanner.Err(); err != nil {
@@ -486,6 +483,7 @@ func (e *Environment) convertMounts() []mount.Mount {
 
 func (e *Environment) resources() container.Resources {
 	l := e.Configuration.Limits()
+	pids := l.ProcessLimit()
 
 	return container.Resources{
 		Memory:            l.BoundedMemoryLimit(),
@@ -497,5 +495,6 @@ func (e *Environment) resources() container.Resources {
 		BlkioWeight:       l.IoWeight,
 		OomKillDisable:    &l.OOMDisabled,
 		CpusetCpus:        l.Threads,
+		PidsLimit:         &pids,
 	}
 }

environment/docker/environment.go

@@ -21,13 +21,12 @@ type Metadata struct {
 	Stop  remote.ProcessStopConfiguration
 }
 
-// Ensure that the Docker environment is always implementing all of the methods
+// Ensure that the Docker environment is always implementing all the methods
 // from the base environment interface.
 var _ environment.ProcessEnvironment = (*Environment)(nil)
 
 type Environment struct {
 	mu sync.RWMutex
-	eventMu sync.Once
 
 	// The public identifier for this environment. In this case it is the Docker container
 	// name that will be used for all instances created under it.
@@ -48,7 +47,10 @@ type Environment struct {
 	// Holds the stats stream used by the polling commands so that we can easily close it out.
 	stats io.ReadCloser
 
-	emitter *events.EventBus
+	emitter *events.Bus
+
+	logCallbackMx sync.Mutex
+	logCallback   func([]byte)
 
 	// Tracks the environment state.
 	st *system.AtomicString
@@ -70,6 +72,7 @@ func New(id string, m *Metadata, c *environment.Configuration) (*Environment, er
 		meta:          m,
 		client:        cli,
 		st:            system.NewAtomicString(environment.ProcessOfflineState),
+		emitter:       events.NewBus(),
 	}
 
 	return e, nil
@@ -83,71 +86,67 @@ func (e *Environment) Type() string {
 	return "docker"
 }
 
-// Set if this process is currently attached to the process.
+// SetStream sets the current stream value from the Docker client. If a nil
+// value is provided we assume that the stream is no longer operational and the
+// instance is effectively offline.
 func (e *Environment) SetStream(s *types.HijackedResponse) {
 	e.mu.Lock()
-	defer e.mu.Unlock()
-
 	e.stream = s
+	e.mu.Unlock()
 }
 
-// Determine if the this process is currently attached to the container.
+// IsAttached determine if the this process is currently attached to the
+// container instance by checking if the stream is nil or not.
 func (e *Environment) IsAttached() bool {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
-
 	return e.stream != nil
 }
 
-func (e *Environment) Events() *events.EventBus {
-	e.eventMu.Do(func() {
-		e.emitter = events.New()
-	})
-
+// Events returns an event bus for the environment.
+func (e *Environment) Events() *events.Bus {
 	return e.emitter
 }
 
-// Determines if the container exists in this environment. The ID passed through should be the
-// server UUID since containers are created utilizing the server UUID as the name and docker
-// will work fine when using the container name as the lookup parameter in addition to the longer
-// ID auto-assigned when the container is created.
+// Exists determines if the container exists in this environment. The ID passed
+// through should be the server UUID since containers are created utilizing the
+// server UUID as the name and docker will work fine when using the container
+// name as the lookup parameter in addition to the longer ID auto-assigned when
+// the container is created.
 func (e *Environment) Exists() (bool, error) {
-	_, err := e.client.ContainerInspect(context.Background(), e.Id)
-
+	_, err := e.ContainerInspect(context.Background())
 	if err != nil {
 		// If this error is because the container instance wasn't found via Docker we
 		// can safely ignore the error and just return false.
 		if client.IsErrNotFound(err) {
 			return false, nil
 		}
-
 		return false, err
 	}
-
 	return true, nil
 }
 
-// Determines if the server's docker container is currently running. If there is no container
-// present, an error will be raised (since this shouldn't be a case that ever happens under
-// correctly developed circumstances).
+// IsRunning determines if the server's docker container is currently running.
+// If there is no container present, an error will be raised (since this
+// shouldn't be a case that ever happens under correctly developed
+// circumstances).
 //
-// You can confirm if the instance wasn't found by using client.IsErrNotFound from the Docker
-// API.
+// You can confirm if the instance wasn't found by using client.IsErrNotFound
+// from the Docker API.
 //
 // @see docker/client/errors.go
-func (e *Environment) IsRunning() (bool, error) {
-	c, err := e.client.ContainerInspect(context.Background(), e.Id)
+func (e *Environment) IsRunning(ctx context.Context) (bool, error) {
+	c, err := e.ContainerInspect(ctx)
 	if err != nil {
 		return false, err
 	}
-
 	return c.State.Running, nil
 }
 
-// Determine the container exit state and return the exit code and whether or not
+// ExitState returns the container exit state, the exit code and whether or not
 // the container was killed by the OOM killer.
 func (e *Environment) ExitState() (uint32, bool, error) {
-	c, err := e.client.ContainerInspect(context.Background(), e.Id)
+	c, err := e.ContainerInspect(context.Background())
 	if err != nil {
 		// I'm not entirely sure how this can happen to be honest. I tried deleting a
 		// container _while_ a server was running and wings gracefully saw the crash and
@@ -161,15 +160,13 @@ func (e *Environment) ExitState() (uint32, bool, error) {
 		if client.IsErrNotFound(err) {
 			return 1, false, nil
 		}
-
 		return 0, false, err
 	}
-
 	return uint32(c.State.ExitCode), c.State.OOMKilled, nil
 }
 
-// Returns the environment configuration allowing a process to make modifications of the
-// environment on the fly.
+// Config returns the environment configuration allowing a process to make
+// modifications of the environment on the fly.
 func (e *Environment) Config() *environment.Configuration {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
@@ -177,12 +174,11 @@ func (e *Environment) Config() *environment.Configuration {
 	return e.Configuration
 }
 
-// Sets the stop configuration for the environment.
+// SetStopConfiguration sets the stop configuration for the environment.
 func (e *Environment) SetStopConfiguration(c remote.ProcessStopConfiguration) {
 	e.mu.Lock()
-	defer e.mu.Unlock()
-
 	e.meta.Stop = c
+	e.mu.Unlock()
 }
 
 func (e *Environment) SetImage(i string) {
@@ -214,3 +210,10 @@ func (e *Environment) SetState(state string) {
 		e.Events().Publish(environment.StateChangeEvent, state)
 	}
 }
+
+func (e *Environment) SetLogCallback(f func([]byte)) {
+	e.logCallbackMx.Lock()
+	defer e.logCallbackMx.Unlock()
+
+	e.logCallback = f
+}

environment/docker/power.go

@@ -12,22 +12,24 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 )
 
-// Run before the container starts and get the process configuration from the Panel.
-// This is important since we use this to check configuration files as well as ensure
-// we always have the latest version of an egg available for server processes.
+// OnBeforeStart run before the container starts and get the process
+// configuration from the Panel. This is important since we use this to check
+// configuration files as well as ensure we always have the latest version of
+// an egg available for server processes.
 //
-// This process will also confirm that the server environment exists and is in a bootable
-// state. This ensures that unexpected container deletion while Wings is running does
-// not result in the server becoming un-bootable.
-func (e *Environment) OnBeforeStart() error {
+// This process will also confirm that the server environment exists and is in
+// a bootable state. This ensures that unexpected container deletion while Wings
+// is running does not result in the server becoming un-bootable.
+func (e *Environment) OnBeforeStart(ctx context.Context) 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 err := e.client.ContainerRemove(ctx, 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")
 		}
 	}
 
@@ -45,10 +47,10 @@ func (e *Environment) OnBeforeStart() error {
 	return nil
 }
 
-// Starts the server environment and begins piping output to the event listeners for the
-// console. If a container does not exist, or needs to be rebuilt that will happen in the
-// call to OnBeforeStart().
-func (e *Environment) Start() error {
+// Start will start the server environment and begins piping output to the event
+// listeners for the console. If a container does not exist, or needs to be
+// rebuilt that will happen in the call to OnBeforeStart().
+func (e *Environment) Start(ctx context.Context) error {
 	sawError := false
 
 	// If sawError is set to true there was an error somewhere in the pipeline that
@@ -64,29 +66,29 @@ func (e *Environment) Start() error {
 		}
 	}()
 
-	if c, err := e.client.ContainerInspect(context.Background(), e.Id); err != nil {
+	if c, err := e.ContainerInspect(ctx); err != nil {
 		// Do nothing if the container is not found, we just don't want to continue
 		// to the next block of code here. This check was inlined here to guard against
 		// a nil-pointer when checking c.State below.
 		//
 		// @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.
 		if c.State.Running {
 			e.SetState(environment.ProcessRunningState)
 
-			return e.Attach()
+			return e.Attach(ctx)
 		}
 
-		// Truncate the log file so we don't end up outputting a bunch of useless log information
+		// Truncate the log file, so we don't end up outputting a bunch of useless log information
 		// to the websocket and whatnot. Check first that the path and file exist before trying
 		// 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")
 			}
 		}
 	}
@@ -100,21 +102,33 @@ func (e *Environment) Start() error {
 	// Run the before start function and wait for it to finish. This will validate that the container
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
-	if err := e.OnBeforeStart(); err != nil {
+	if err := e.OnBeforeStart(ctx); err != nil {
+		return errors.WithStackIf(err)
+	}
+
+	// If we cannot start & attach to the container in 30 seconds something has gone
+	// quite sideways and we should stop trying to avoid a hanging situation.
+	actx, cancel := context.WithTimeout(ctx, time.Second*30)
+	defer cancel()
+
+	// You must attach to the instance _before_ you start the container. If you do this
+	// in the opposite order you'll enter a deadlock condition where we're attached to
+	// the instance successfully, but the container has already stopped and you'll get
+	// the entire program into a very confusing state.
+	//
+	// By explicitly attaching to the instance before we start it, we can immediately
+	// react to errors/output stopping/etc. when starting.
+	if err := e.Attach(actx); err != nil {
 		return 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
+	if err := e.client.ContainerStart(actx, e.Id, types.ContainerStartOptions{}); err != nil {
+		return errors.WrapIf(err, "environment/docker: failed to start container")
 	}
 
 	// No errors, good to continue through.
 	sawError = false
-
-	return e.Attach()
+	return nil
 }
 
 // Stop stops the container that the server is running in. This will allow up to
@@ -124,9 +138,7 @@ func (e *Environment) Start() error {
 // 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 {
+func (e *Environment) Stop(ctx context.Context) error {
 	e.mu.RLock()
 	s := e.meta.Stop
 	e.mu.RUnlock()
@@ -150,7 +162,7 @@ func (e *Environment) Stop() error {
 		case "SIGTERM":
 			signal = syscall.SIGTERM
 		}
-		return e.Terminate(signal)
+		return e.Terminate(ctx, signal)
 	}
 
 	// If the process is already offline don't switch it back to stopping. Just leave it how
@@ -165,8 +177,10 @@ func (e *Environment) Stop() error {
 		return e.SendCommand(s.Value)
 	}
 
-	t := time.Second * 30
-	if err := e.client.ContainerStop(context.Background(), e.Id, &t); err != nil {
+	// Allow the stop action to run for however long it takes, similar to executing a command
+	// and using a different logic pathway to wait for the container to stop successfully.
+	t := time.Duration(-1)
+	if err := e.client.ContainerStop(ctx, 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) {
@@ -184,45 +198,66 @@ func (e *Environment) Stop() error {
 // 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
+//
+// Calls to Environment.Terminate() in this function use the context passed
+// through since we don't want to prevent termination of the server instance
+// just because the context.WithTimeout() has expired.
+func (e *Environment) WaitForStop(ctx context.Context, duration time.Duration, terminate bool) error {
+	tctx, cancel := context.WithTimeout(context.Background(), duration)
+	defer cancel()
+
+	// If the parent context is canceled, abort the timed context for termination.
+	go func() {
+		select {
+		case <-ctx.Done():
+			cancel()
+		case <-tctx.Done():
+			// When the timed context is canceled, terminate this routine since we no longer
+			// need to worry about the parent routine being canceled.
+			break
+		}
+	}()
+
+	doTermination := func(s string) error {
+		e.log().WithField("step", s).WithField("duration", duration).Warn("container stop did not complete in time, terminating process...")
+		return e.Terminate(ctx, os.Kill)
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(seconds)*time.Second)
-	defer cancel()
+	// We pass through the timed context for this stop action so that if one of the
+	// internal docker calls fails to ever finish before we've exhausted the time limit
+	// the resources get cleaned up, and the exection is stopped.
+	if err := e.Stop(tctx); err != nil {
+		if terminate && errors.Is(err, context.DeadlineExceeded) {
+			return doTermination("stop")
+		}
+		return err
+	}
 
 	// Block the return of this function until the container as been marked as no
 	// longer running. If this wait does not end by the time seconds have passed,
 	// attempt to terminate the container, or return an error.
-	ok, errChan := e.client.ContainerWait(ctx, e.Id, container.WaitConditionNotRunning)
+	ok, errChan := e.client.ContainerWait(tctx, e.Id, container.WaitConditionNotRunning)
 	select {
 	case <-ctx.Done():
-		if ctxErr := ctx.Err(); ctxErr != nil {
+		if err := ctx.Err(); err != nil {
 			if terminate {
-				log.WithField("container_id", e.Id).Info("server did not stop in time, executing process termination")
-
-				return e.Terminate(os.Kill)
+				return doTermination("parent-context")
 			}
-
-			return ctxErr
+			return err
 		}
 	case err := <-errChan:
 		// 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) {
-					l.Warn("deadline exceeded for container stop; terminating process")
-				} else {
-					l.WithField("error", err).Warn("error while waiting for container stop; terminating process")
+		if err == nil || client.IsErrNotFound(err) {
+			return nil
 		}
-
-				return e.Terminate(os.Kill)
+		if terminate {
+			if !errors.Is(err, context.DeadlineExceeded) {
+				e.log().WithField("error", err).Warn("error while waiting for container stop; terminating process")
+			}
+			return doTermination("wait")
 		}
 		return errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
-		}
 	case <-ok:
 	}
 
@@ -230,8 +265,8 @@ func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 }
 
 // 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)
+func (e *Environment) Terminate(ctx context.Context, signal os.Signal) error {
+	c, err := e.ContainerInspect(ctx)
 	if err != nil {
 		// Treat missing containers as an okay error state, means it is obviously
 		// already terminated at this point.
@@ -242,7 +277,7 @@ func (e *Environment) Terminate(signal os.Signal) error {
 	}
 
 	if !c.State.Running {
-		// If the container is not running but we're not already in a stopped state go ahead
+		// If the container is not running, but we're not already in a stopped state go ahead
 		// and update things to indicate we should be completely stopped now. Set to stopping
 		// first so crash detection is not triggered.
 		if e.st.Load() != environment.ProcessOfflineState {
@@ -256,7 +291,7 @@ 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) {
+	if err := e.client.ContainerKill(ctx, e.Id, sig); err != nil && !client.IsErrNotFound(err) {
 		return errors.WithStack(err)
 	}
 	e.SetState(environment.ProcessOfflineState)

environment/docker/stats.go

@@ -2,14 +2,34 @@ package docker
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
-	"github.com/docker/docker/api/types"
-	"github.com/pterodactyl/wings/environment"
 	"io"
 	"math"
+	"time"
+
+	"emperror.dev/errors"
+	"github.com/docker/docker/api/types"
+	"github.com/goccy/go-json"
+
+	"github.com/pterodactyl/wings/environment"
 )
 
+// Uptime returns the current uptime of the container in milliseconds. If the
+// container is not currently running this will return 0.
+func (e *Environment) Uptime(ctx context.Context) (int64, error) {
+	ins, err := e.ContainerInspect(ctx)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: could not inspect container")
+	}
+	if !ins.State.Running {
+		return 0, nil
+	}
+	started, err := time.Parse(time.RFC3339, ins.State.StartedAt)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: failed to parse container start time")
+	}
+	return time.Since(started).Milliseconds(), nil
+}
+
 // Attach to the instance and then automatically emit an event whenever the resource usage for the
 // server process changes.
 func (e *Environment) pollResources(ctx context.Context) error {
@@ -26,6 +46,11 @@ func (e *Environment) pollResources(ctx context.Context) error {
 	}
 	defer stats.Body.Close()
 
+	uptime, err := e.Uptime(ctx)
+	if err != nil {
+		e.log().WithField("error", err).Warn("failed to calculate container uptime")
+	}
+
 	dec := json.NewDecoder(stats.Body)
 	for {
 		select {
@@ -48,7 +73,12 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				return nil
 			}
 
+			if !v.PreRead.IsZero() {
+				uptime = uptime + v.Read.Sub(v.PreRead).Milliseconds()
+			}
+
 			st := environment.Stats{
+				Uptime:      uptime,
 				Memory:      calculateDockerMemory(v.MemoryStats),
 				MemoryLimit: v.MemoryStats.Limit,
 				CpuAbsolute: calculateDockerAbsoluteCpu(v.PreCPUStats, v.CPUStats),
@@ -60,11 +90,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				st.Network.TxBytes += nw.TxBytes
 			}
 
-			if b, err := json.Marshal(st); err != nil {
-				e.log().WithField("error", err).Warn("error while marshaling stats object for environment")
-			} else {
-				e.Events().Publish(environment.ResourceEvent, string(b))
-			}
+			e.Events().Publish(environment.ResourceEvent, st)
 		}
 	}
 }
@@ -73,9 +99,8 @@ func (e *Environment) pollResources(ctx context.Context) error {
 // value which can be rather confusing to people trying to compare panel usage to
 // their stats output.
 //
-// This math is straight up lifted from their CLI repository in order to show the same
-// values to avoid people bothering me about it. It should also reflect a slightly more
-// correct memory value anyways.
+// This math is from their CLI repository in order to show the same values to avoid people
+// bothering me about it. It should also reflect a slightly more correct memory value anyways.
 //
 // @see https://github.com/docker/cli/blob/96e1d1d6/cli/command/container/stats_helpers.go#L227-L249
 func calculateDockerMemory(stats types.MemoryStats) uint64 {

environment/environment.go

@@ -1,13 +1,14 @@
 package environment
 
 import (
+	"context"
 	"os"
+	"time"
 
 	"github.com/pterodactyl/wings/events"
 )
 
 const (
-	ConsoleOutputEvent       = "console output"
 	StateChangeEvent         = "state change"
 	ResourceEvent            = "resources"
 	DockerImagePullStarted   = "docker image pull started"
@@ -34,16 +35,16 @@ type ProcessEnvironment interface {
 	// Returns an event emitter instance that can be hooked into to listen for different
 	// events that are fired by the environment. This should not allow someone to publish
 	// events, only subscribe to them.
-	Events() *events.EventBus
+	Events() *events.Bus
 
 	// Determines if the server instance exists. For example, in a docker environment
 	// this should confirm that the container is created and in a bootable state. In
 	// a basic CLI environment this can probably just return true right away.
 	Exists() (bool, error)
 
-	// Determines if the environment is currently active and running a server process
-	// for this specific server instance.
-	IsRunning() (bool, error)
+	// IsRunning determines if the environment is currently active and running
+	// a server process for this specific server instance.
+	IsRunning(ctx context.Context) (bool, error)
 
 	// Performs an update of server resource limits without actually stopping the server
 	// process. This only executes if the environment supports it, otherwise it is
@@ -52,24 +53,26 @@ type ProcessEnvironment interface {
 
 	// Runs before the environment is started. If an error is returned starting will
 	// not occur, otherwise proceeds as normal.
-	OnBeforeStart() error
+	OnBeforeStart(ctx context.Context) error
 
 	// Starts a server instance. If the server instance is not in a state where it
 	// can be started an error should be returned.
-	Start() error
+	Start(ctx context.Context) error
 
-	// Stops a server instance. If the server is already stopped an error should
-	// not be returned.
-	Stop() error
+	// Stop stops a server instance. If the server is already stopped an error will
+	// not be returned, this function will act as a no-op.
+	Stop(ctx context.Context) error
 
-	// Waits for a server instance to stop gracefully. If the server is still detected
-	// as running after seconds, an error will be returned, or the server will be terminated
-	// depending on the value of the second argument.
-	WaitForStop(seconds uint, terminate bool) error
+	// WaitForStop waits for a server instance to stop gracefully. If the server is
+	// still detected as running after "duration", an error will be returned, or the server
+	// will be terminated depending on the value of the second argument. If the context
+	// provided is canceled the underlying wait conditions will be stopped and the
+	// entire loop will be ended (potentially without stopping or terminating).
+	WaitForStop(ctx context.Context, duration time.Duration, terminate bool) error
 
-	// Terminates a running server instance using the provided signal. If the server
-	// is not running no error should be returned.
-	Terminate(signal os.Signal) error
+	// Terminate stops a running server instance using the provided signal. This function
+	// is a no-op if the server is already stopped.
+	Terminate(ctx context.Context, signal os.Signal) error
 
 	// Destroys the environment removing any containers that were created (in Docker
 	// environments at least).
@@ -84,10 +87,10 @@ type ProcessEnvironment interface {
 	// server.
 	Create() error
 
-	// Attaches to the server console environment and allows piping the output to a
-	// websocket or other internal tool to monitor output. Also allows you to later
+	// Attach attaches to the server console environment and allows piping the output
+	// to a websocket or other internal tool to monitor output. Also allows you to later
 	// send data into the environment's stdin.
-	Attach() error
+	Attach(ctx context.Context) error
 
 	// Sends the provided command to the running server instance.
 	SendCommand(string) error
@@ -103,4 +106,11 @@ type ProcessEnvironment interface {
 	// handle this itself, but there are some scenarios where it is helpful for the server
 	// to update the state externally (e.g. starting -> started).
 	SetState(string)
+
+	// Uptime returns the current environment uptime in milliseconds. This is
+	// the time that has passed since it was last started.
+	Uptime(ctx context.Context) (int64, error)
+
+	// SetLogCallback sets the callback that the container's log output will be passed to.
+	SetLogCallback(func([]byte))
 }

environment/settings.go

@@ -6,6 +6,9 @@ import (
 	"strconv"
 
 	"github.com/apex/log"
+	"github.com/docker/docker/api/types/container"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 type Mount struct {
@@ -23,13 +26,13 @@ type Mount struct {
 	// that we're mounting into the container at the Target location.
 	Source string `json:"source"`
 
-	// Whether or not the directory is being mounted as read-only. It is up to the environment to
+	// Whether the directory is being mounted as read-only. It is up to the environment to
 	// handle this value correctly and ensure security expectations are met with its usage.
 	ReadOnly bool `json:"read_only"`
 }
 
-// The build settings for a given server that impact docker container creation and
-// resource limits for a server instance.
+// Limits is the build settings for a given server that impact docker container
+// creation and resource limits for a server instance.
 type Limits struct {
 	// The total amount of memory in megabytes that this server is allowed to
 	// use on the host system.
@@ -56,51 +59,70 @@ type Limits struct {
 	OOMDisabled bool `json:"oom_disabled"`
 }
 
-// Converts the CPU limit for a server build into a number that can be better understood
-// by the Docker environment. If there is no limit set, return -1 which will indicate to
-// Docker that it has unlimited CPU quota.
-func (r *Limits) ConvertedCpuLimit() int64 {
-	if r.CpuLimit == 0 {
+// ConvertedCpuLimit converts the CPU limit for a server build into a number
+// that can be better understood by the Docker environment. If there is no limit
+// set, return -1 which will indicate to Docker that it has unlimited CPU quota.
+func (l Limits) ConvertedCpuLimit() int64 {
+	if l.CpuLimit == 0 {
 		return -1
 	}
 
-	return r.CpuLimit * 1000
+	return l.CpuLimit * 1000
 }
 
-// Set the hard limit for memory usage to be 5% more than the amount of memory assigned to
-// the server. If the memory limit for the server is < 4G, use 10%, if less than 2G use
-// 15%. This avoids unexpected crashes from processes like Java which run over the limit.
-func (r *Limits) MemoryOverheadMultiplier() float64 {
-	if r.MemoryLimit <= 2048 {
-		return 1.15
-	} else if r.MemoryLimit <= 4096 {
-		return 1.10
+// MemoryOverheadMultiplier sets the hard limit for memory usage to be 5% more
+// than the amount of memory assigned to the server. If the memory limit for the
+// server is < 4G, use 10%, if less than 2G use 15%. This avoids unexpected
+// crashes from processes like Java which run over the limit.
+func (l Limits) MemoryOverheadMultiplier() float64 {
+	return config.Get().Docker.Overhead.GetMultiplier(l.MemoryLimit)
 }
 
-	return 1.05
+func (l Limits) BoundedMemoryLimit() int64 {
+	return int64(math.Round(float64(l.MemoryLimit) * l.MemoryOverheadMultiplier() * 1_000_000))
 }
 
-func (r *Limits) BoundedMemoryLimit() int64 {
-	return int64(math.Round(float64(r.MemoryLimit) * r.MemoryOverheadMultiplier() * 1_000_000))
-}
-
-// Returns the amount of swap available as a total in bytes. This is returned as the amount
-// of memory available to the server initially, PLUS the amount of additional swap to include
-// which is the format used by Docker.
-func (r *Limits) ConvertedSwap() int64 {
-	if r.Swap < 0 {
+// ConvertedSwap returns the amount of swap available as a total in bytes. This
+// is returned as the amount of memory available to the server initially, PLUS
+// the amount of additional swap to include which is the format used by Docker.
+func (l Limits) ConvertedSwap() int64 {
+	if l.Swap < 0 {
 		return -1
 	}
 
-	return (r.Swap * 1_000_000) + r.BoundedMemoryLimit()
+	return (l.Swap * 1_000_000) + l.BoundedMemoryLimit()
+}
+
+// ProcessLimit returns the process limit for a container. This is currently
+// defined at a system level and not on a per-server basis.
+func (l Limits) ProcessLimit() int64 {
+	return config.Get().Docker.ContainerPidLimit
+}
+
+func (l Limits) AsContainerResources() container.Resources {
+	pids := l.ProcessLimit()
+
+	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,
+		PidsLimit:         &pids,
+	}
 }
 
 type Variables map[string]interface{}
 
-// Ugly hacky function to handle environment variables that get passed through as not-a-string
-// from the Panel. Ideally we'd just say only pass strings, but that is a fragile idea and if a
-// string wasn't passed through you'd cause a crash or the server to become unavailable. For now
-// try to handle the most likely values from the JSON and hope for the best.
+// Get is an ugly hacky function to handle environment variables that get passed
+// through as not-a-string from the Panel. Ideally we'd just say only pass
+// strings, but that is a fragile idea and if a string wasn't passed through
+// you'd cause a crash or the server to become unavailable. For now try to
+// handle the most likely values from the JSON and hope for the best.
 func (v Variables) Get(key string) string {
 	val, ok := v[key]
 	if !ok {

environment/stats.go

@@ -1,8 +1,6 @@
 package environment
 
-// Defines the current resource usage for a given server instance. If a server is offline you
-// should obviously expect memory and CPU usage to be 0. However, disk will always be returned
-// since that is not dependent on the server being running to collect that data.
+// Stats defines the current resource usage for a given server instance.
 type Stats struct {
 	// The total amount of memory, in bytes, that this server instance is consuming. This is
 	// calculated slightly differently than just using the raw Memory field that the stats
@@ -12,19 +10,18 @@ type Stats struct {
 
 	// The total amount of memory this container or resource can use. Inside Docker this is
 	// going to be higher than you'd expect because we're automatically allocating overhead
-	// abilities for the container, so its not going to be a perfect match.
+	// abilities for the container, so it's not going to be a perfect match.
 	MemoryLimit uint64 `json:"memory_limit_bytes"`
 
 	// The absolute CPU usage is the amount of CPU used in relation to the entire system and
 	// does not take into account any limits on the server process itself.
 	CpuAbsolute float64 `json:"cpu_absolute"`
 
-	// The current disk space being used by the server. This is cached to prevent slow lookup
-	// issues on frequent refreshes.
-	// Disk int64 `json:"disk_bytes"`
-
 	// Current network transmit in & out for a container.
 	Network NetworkStats `json:"network"`
+
+	// The current uptime of the container, in milliseconds.
+	Uptime int64 `json:"uptime"`
 }
 
 type NetworkStats struct {

events/events.go

@@ -1,122 +1,70 @@
 package events
 
 import (
-	"encoding/json"
 	"strings"
-	"sync"
 
-	"github.com/gammazero/workerpool"
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+	"github.com/pterodactyl/wings/system"
 )
 
+// Event represents an Event sent over a Bus.
 type Event struct {
-	Data  string
 	Topic string
+	Data  interface{}
 }
 
-type EventBus struct {
-	mu    sync.RWMutex
-	pools map[string]*CallbackPool
+// Bus represents an Event Bus.
+type Bus struct {
+	*system.SinkPool
 }
 
-func New() *EventBus {
-	return &EventBus{
-		pools: make(map[string]*CallbackPool),
+// NewBus returns a new empty Bus. This is simply a nicer wrapper around the
+// system.SinkPool implementation that allows for more simplistic usage within
+// the codebase.
+//
+// All of the events emitted out of this bus are byte slices that can be decoded
+// back into an events.Event interface.
+func NewBus() *Bus {
+	return &Bus{
+		system.NewSinkPool(),
 	}
 }
 
-// Publish data to a given topic.
-func (e *EventBus) Publish(topic string, data string) {
-	t := topic
-	// Some of our topics for the socket support passing a more specific namespace,
+// Publish publishes a message to the Bus.
+func (b *Bus) Publish(topic string, data interface{}) {
+	// Some of our actions for the socket support passing a more specific namespace,
 	// such as "backup completed:1234" to indicate which specific backup was completed.
 	//
-	// In these cases, we still need to the send the event using the standard listener
+	// In these cases, we still need to send the event using the standard listener
 	// name of "backup completed".
 	if strings.Contains(topic, ":") {
 		parts := strings.SplitN(topic, ":", 2)
-
 		if len(parts) == 2 {
-			t = parts[0]
+			topic = parts[0]
 		}
 	}
 
-	e.mu.RLock()
-	defer e.mu.RUnlock()
-
-	// Acquire a read lock and loop over all of the channels registered for the topic. This
-	// avoids a panic crash if the process tries to unregister the channel while this routine
-	// is running.
-	if cp, ok := e.pools[t]; ok {
-		for _, callback := range cp.callbacks {
-			c := *callback
-			evt := Event{Data: data, Topic: topic}
-			// Using the workerpool with one worker allows us to execute events in a FIFO manner. Running
-			// this using goroutines would cause things such as console output to just output in random order
-			// if more than one event is fired at the same time.
-			//
-			// However, the pool submission does not block the execution of this function itself, allowing
-			// us to call publish without blocking any of the other pathways.
-			//
-			// @see https://github.com/pterodactyl/panel/issues/2303
-			cp.pool.Submit(func() {
-				c(evt)
-			})
-		}
-	}
-}
-
-// Publishes a JSON message to a given topic.
-func (e *EventBus) PublishJson(topic string, data interface{}) error {
-	b, err := json.Marshal(data)
+	enc, err := json.Marshal(Event{Topic: topic, Data: data})
 	if err != nil {
-		return err
+		panic(errors.WithStack(err))
+	}
+	b.Push(enc)
 }
 
-	e.Publish(topic, string(b))
+// MustDecode decodes the event byte slice back into an events.Event struct or
+// panics if an error is encountered during this process.
+func MustDecode(data []byte) (e Event) {
+	if err := DecodeTo(data, &e); err != nil {
+		panic(err)
+	}
+	return
+}
 
+// DecodeTo decodes a byte slice of event data into the given interface.
+func DecodeTo(data []byte, v interface{}) error {
+	if err := json.Unmarshal(data, &v); err != nil {
+		return errors.Wrap(err, "events: failed to decode byte slice")
+	}
 	return nil
 }
-
-// Register a callback function that will be executed each time one of the events using the topic
-// name is called.
-func (e *EventBus) On(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Check if this topic has been registered at least once for the event listener, and if
-	// not create an empty struct for the topic.
-	if _, exists := e.pools[topic]; !exists {
-		e.pools[topic] = &CallbackPool{
-			callbacks: make([]*func(Event), 0),
-			pool:      workerpool.New(1),
-		}
-	}
-
-	// If this callback is not already registered as an event listener, go ahead and append
-	// it to the array of callbacks for this topic.
-	e.pools[topic].Add(callback)
-}
-
-// Removes an event listener from the bus.
-func (e *EventBus) Off(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if cp, ok := e.pools[topic]; ok {
-		cp.Remove(callback)
-	}
-}
-
-// Removes all of the event listeners that have been registered for any topic. Also stops the worker
-// pool to close that routine.
-func (e *EventBus) Destroy() {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Stop every pool that exists for a given callback topic.
-	for _, cp := range e.pools {
-		cp.pool.Stop()
-	}
-
-	e.pools = make(map[string]*CallbackPool)
-}

events/events_test.go

@@ -0,0 +1,98 @@
+package events
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/franela/goblin"
+)
+
+func TestNewBus(t *testing.T) {
+	g := Goblin(t)
+
+	g.Describe("Events", func() {
+		var bus *Bus
+		g.BeforeEach(func() {
+			bus = NewBus()
+		})
+
+		g.Describe("NewBus", func() {
+			g.It("is not nil", func() {
+				g.Assert(bus).IsNotNil("Bus expected to not be nil")
+			})
+		})
+
+		g.Describe("Publish", func() {
+			const topic = "test"
+			const message = "this is a test message!"
+
+			g.It("publishes message", func() {
+				bus := NewBus()
+
+				listener := make(chan []byte)
+				bus.On(listener)
+
+				done := make(chan struct{}, 1)
+				go func() {
+					select {
+					case v := <-listener:
+						m := MustDecode(v)
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case <-time.After(1 * time.Second):
+						g.Fail("listener did not receive message in time")
+					}
+					done <- struct{}{}
+				}()
+				bus.Publish(topic, message)
+				<-done
+
+				// Cleanup
+				bus.Off(listener)
+			})
+
+			g.It("publishes message to all listeners", func() {
+				bus := NewBus()
+
+				listener := make(chan []byte)
+				listener2 := make(chan []byte)
+				listener3 := make(chan []byte)
+				bus.On(listener)
+				bus.On(listener2)
+				bus.On(listener3)
+
+				done := make(chan struct{}, 1)
+				go func() {
+					for i := 0; i < 3; i++ {
+						select {
+						case v := <-listener:
+							m := MustDecode(v)
+							g.Assert(m.Topic).Equal(topic)
+							g.Assert(m.Data).Equal(message)
+						case v := <-listener2:
+							m := MustDecode(v)
+							g.Assert(m.Topic).Equal(topic)
+							g.Assert(m.Data).Equal(message)
+						case v := <-listener3:
+							m := MustDecode(v)
+							g.Assert(m.Topic).Equal(topic)
+							g.Assert(m.Data).Equal(message)
+						case <-time.After(1 * time.Second):
+							g.Fail("all listeners did not receive the message in time")
+							i = 3
+						}
+					}
+
+					done <- struct{}{}
+				}()
+				bus.Publish(topic, message)
+				<-done
+
+				// Cleanup
+				bus.Off(listener)
+				bus.Off(listener2)
+				bus.Off(listener3)
+			})
+		})
+	})
+}

events/pool.go

@@ -1,50 +0,0 @@
-package events
-
-import (
-	"reflect"
-
-	"github.com/gammazero/workerpool"
-)
-
-type CallbackPool struct {
-	callbacks []*func(Event)
-	pool      *workerpool.WorkerPool
-}
-
-// Pushes a new callback into the array of listeners for the pool.
-func (cp *CallbackPool) Add(callback *func(Event)) {
-	if cp.index(reflect.ValueOf(callback)) < 0 {
-		cp.callbacks = append(cp.callbacks, callback)
-	}
-}
-
-// Removes a callback from the array of registered callbacks if it exists.
-func (cp *CallbackPool) Remove(callback *func(Event)) {
-	i := cp.index(reflect.ValueOf(callback))
-
-	// If i < 0 it means there was no index found for the given callback, meaning it was
-	// never registered or was already unregistered from the listeners. Also double check
-	// that we didn't somehow escape the length of the topic callback (not sure how that
-	// would happen, but lets avoid a panic condition).
-	if i < 0 || i >= len(cp.callbacks) {
-		return
-	}
-
-	// We can assume that the topic still exists at this point since we acquire an exclusive
-	// lock on the process, and the "e.index" function cannot return a value >= 0 if there is
-	// no topic already existing.
-	cp.callbacks = append(cp.callbacks[:i], cp.callbacks[i+1:]...)
-}
-
-// Finds the index of a given callback in the topic by comparing all of the registered callback
-// pointers to the passed function. This function does not aquire a lock as it should only be called
-// within the confines of a function that has already acquired a lock for the duration of the lookup.
-func (cp *CallbackPool) index(v reflect.Value) int {
-	for i, handler := range cp.callbacks {
-		if reflect.ValueOf(handler).Pointer() == v.Pointer() {
-			return i
-		}
-	}
-
-	return -1
-}

go.mod

@@ -1,82 +1,115 @@
 module github.com/pterodactyl/wings
 
-go 1.14
+go 1.17
 
 require (
-	emperror.dev/errors v0.8.0
-	github.com/AlecAivazis/survey/v2 v2.2.7
-	github.com/Jeffail/gabs/v2 v2.6.0
-	github.com/Microsoft/go-winio v0.4.16 // indirect
-	github.com/Microsoft/hcsshim v0.8.14 // indirect
+	emperror.dev/errors v0.8.1
+	github.com/AlecAivazis/survey/v2 v2.3.4
+	github.com/Jeffail/gabs/v2 v2.6.1
 	github.com/NYTimes/logrotate v1.0.0
-	github.com/andybalholm/brotli v1.0.1 // indirect
 	github.com/apex/log v1.9.0
-	github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef
+	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
 	github.com/beevik/etree v1.1.0
-	github.com/buger/jsonparser v1.1.0
+	github.com/buger/jsonparser v1.1.1
+	github.com/cenkalti/backoff/v4 v4.1.2
 	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
-	github.com/containerd/containerd v1.4.3 // indirect
-	github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c // indirect
-	github.com/creasty/defaults v1.5.1
-	github.com/docker/distribution v2.7.1+incompatible // indirect
-	github.com/docker/docker v20.10.1+incompatible
+	github.com/creasty/defaults v1.5.2
+	github.com/docker/docker v20.10.14+incompatible
 	github.com/docker/go-connections v0.4.0
-	github.com/docker/go-metrics v0.0.1 // indirect
-	github.com/fatih/color v1.10.0
+	github.com/fatih/color v1.13.0
 	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
-	github.com/fsnotify/fsnotify v1.4.9 // indirect
-	github.com/gabriel-vasile/mimetype v1.1.2
-	github.com/gammazero/deque v0.0.0-20201010052221-3932da5530cc // indirect
-	github.com/gammazero/workerpool v1.1.1
-	github.com/gbrlsnchs/jwt/v3 v3.0.0
-	github.com/gin-gonic/gin v1.6.3
-	github.com/go-playground/validator/v10 v10.4.1 // indirect
-	github.com/golang/snappy v0.0.2 // indirect
-	github.com/google/go-cmp v0.5.2 // indirect
-	github.com/google/uuid v1.1.2
-	github.com/gorilla/mux v1.7.4 // indirect
-	github.com/gorilla/websocket v1.4.2
-	github.com/iancoleman/strcase v0.1.2
-	github.com/icza/dyno v0.0.0-20200205103839-49cb13720835
-	github.com/imdario/mergo v0.3.9
+	github.com/gabriel-vasile/mimetype v1.4.0
+	github.com/gammazero/workerpool v1.1.2
+	github.com/gbrlsnchs/jwt/v3 v3.0.1
+	github.com/gin-gonic/gin v1.7.7
+	github.com/google/uuid v1.3.0
+	github.com/gorilla/websocket v1.5.0
+	github.com/iancoleman/strcase v0.2.0
+	github.com/icza/dyno v0.0.0-20210726202311-f1bafe5d9996
 	github.com/juju/ratelimit v1.0.1
 	github.com/karrick/godirwalk v1.16.1
-	github.com/klauspost/compress v1.11.4 // indirect
 	github.com/klauspost/pgzip v1.2.5
-	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/magefile/mage v1.10.0 // indirect
-	github.com/magiconair/properties v1.8.4
-	github.com/mattn/go-colorable v0.1.8
-	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/mholt/archiver/v3 v3.5.0
+	github.com/magiconair/properties v1.8.6
+	github.com/mattn/go-colorable v0.1.12
+	github.com/mholt/archiver/v3 v3.5.1
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
-	github.com/moby/term v0.0.0-20201216013528-df9cb8a40635 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.1 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pierrec/lz4/v4 v4.1.2 // indirect
-	github.com/pkg/profile v1.5.0
-	github.com/pkg/sftp v1.12.0
-	github.com/prometheus/client_golang v1.9.0 // indirect
-	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/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
-	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
-	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
-	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
-	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
-	golang.org/x/text v0.3.4 // indirect
-	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d // indirect
-	google.golang.org/grpc v1.34.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
-	gopkg.in/ini.v1 v1.62.0
+	github.com/pkg/sftp v1.13.4
+	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
+	github.com/spf13/cobra v1.4.0
+	github.com/stretchr/testify v1.7.0
+	golang.org/x/crypto v0.0.0-20220321153916-2c7772ba3064
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	gopkg.in/ini.v1 v1.66.4
 	gopkg.in/yaml.v2 v2.4.0
 )
+
+require github.com/goccy/go-json v0.9.6
+
+require golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8 // indirect
+
+require (
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
+	github.com/Microsoft/go-winio v0.5.2 // indirect
+	github.com/Microsoft/hcsshim v0.9.2 // indirect
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/containerd/containerd v1.6.2 // indirect
+	github.com/containerd/fifo v1.0.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
+	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
+	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
+	github.com/fsnotify/fsnotify v1.5.1 // indirect
+	github.com/gammazero/deque v0.1.1 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.0 // indirect
+	github.com/go-playground/universal-translator v0.18.0 // indirect
+	github.com/go-playground/validator/v10 v10.10.1 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/gorilla/mux v1.7.4 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/klauspost/compress v1.15.1 // indirect
+	github.com/kr/fs v0.1.0 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magefile/mage v1.13.0 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
+	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
+	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/nwaples/rardecode v1.1.3 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.0.2 // indirect
+	github.com/pierrec/lz4/v4 v4.1.14 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.12.1 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.32.1 // indirect
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/sirupsen/logrus v1.8.1 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/ugorji/go/codec v1.2.7 // indirect
+	github.com/ulikunitz/xz v0.5.10 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
+	golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect
+	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
+	golang.org/x/text v0.3.7 // indirect
+	golang.org/x/time v0.0.0-20220224211638-0e9765cccd65 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb // indirect
+	google.golang.org/grpc v1.45.0 // indirect
+	google.golang.org/protobuf v1.28.0 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
+)

installer/installer.go

@@ -2,70 +2,32 @@ package installer
 
 import (
 	"context"
-	"encoding/json"
 
 	"emperror.dev/errors"
 	"github.com/asaskevich/govalidator"
-	"github.com/buger/jsonparser"
-	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
 )
 
 type Installer struct {
 	server            *server.Server
+	StartOnCompletion bool
 }
 
-// New validates the received data to ensure that all of the required fields
+type ServerDetails struct {
+	UUID              string `json:"uuid"`
+	StartOnCompletion bool   `json:"start_on_completion"`
+}
+
+// New validates the received data to ensure that all the required fields
 // have been passed along in the request. This should be manually run before
 // calling Execute().
-func New(ctx context.Context, manager *server.Manager, data []byte) (*Installer, error) {
-	if !govalidator.IsUUIDv4(getString(data, "uuid")) {
+func New(ctx context.Context, manager *server.Manager, details ServerDetails) (*Installer, error) {
+	if !govalidator.IsUUIDv4(details.UUID) {
 		return nil, NewValidationError("uuid provided was not in a valid format")
 	}
 
-	cfg := &server.Configuration{
-		Uuid:           getString(data, "uuid"),
-		Suspended:      false,
-		Invocation:     getString(data, "invocation"),
-		SkipEggScripts: getBoolean(data, "skip_egg_scripts"),
-		Build: environment.Limits{
-			MemoryLimit: getInt(data, "build", "memory"),
-			Swap:        getInt(data, "build", "swap"),
-			IoWeight:    uint16(getInt(data, "build", "io")),
-			CpuLimit:    getInt(data, "build", "cpu"),
-			DiskSpace:   getInt(data, "build", "disk"),
-			Threads:     getString(data, "build", "threads"),
-		},
-		CrashDetectionEnabled: true,
-	}
-
-	cfg.Allocations.DefaultMapping.Ip = getString(data, "allocations", "default", "ip")
-	cfg.Allocations.DefaultMapping.Port = int(getInt(data, "allocations", "default", "port"))
-
-	// Unmarshal the environment variables from the request into the server struct.
-	if b, _, _, err := jsonparser.Get(data, "environment"); err != nil {
-		return nil, errors.WithStackIf(err)
-	} else {
-		cfg.EnvVars = make(environment.Variables)
-		if err := json.Unmarshal(b, &cfg.EnvVars); err != nil {
-			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, errors.WithStackIf(err)
-	} else {
-		cfg.Allocations.Mappings = make(map[string][]int)
-		if err := json.Unmarshal(b, &cfg.Allocations.Mappings); err != nil {
-			return nil, errors.Wrap(err, "installer: could not unmarshal allocation mappings")
-		}
-	}
-
-	cfg.Container.Image = getString(data, "container", "image")
-
-	c, err := manager.Client().GetServerConfiguration(ctx, cfg.Uuid)
+	c, err := manager.Client().GetServerConfiguration(ctx, details.UUID)
 	if err != nil {
 		if !remote.IsRequestError(err) {
 			return nil, errors.WithStackIf(err)
@@ -79,35 +41,11 @@ func New(ctx context.Context, manager *server.Manager, data []byte) (*Installer,
 	if err != nil {
 		return nil, errors.WrapIf(err, "installer: could not init server instance")
 	}
-	return &Installer{server: s}, nil
-}
-
-// Uuid returns the UUID associated with this installer instance.
-func (i *Installer) Uuid() string {
-	return i.server.Id()
+	i := Installer{server: s, StartOnCompletion: details.StartOnCompletion}
+	return &i, nil
 }
 
 // Server returns the server instance.
 func (i *Installer) Server() *server.Server {
 	return i.server
 }
-
-// Returns a string value from the JSON data provided.
-func getString(data []byte, key ...string) string {
-	value, _ := jsonparser.GetString(data, key...)
-
-	return value
-}
-
-// Returns an int value from the JSON data provided.
-func getInt(data []byte, key ...string) int64 {
-	value, _ := jsonparser.GetInt(data, key...)
-
-	return value
-}
-
-func getBoolean(data []byte, key ...string) bool {
-	value, _ := jsonparser.GetBoolean(data, key...)
-
-	return value
-}

internal/notify/notify.go

@@ -0,0 +1,19 @@
+// Package notify handles notifying the operating system of the program's state.
+//
+// For linux based operating systems, this is done through the systemd socket
+// set by "NOTIFY_SOCKET" environment variable.
+//
+// Currently, no other operating systems are supported.
+package notify
+
+func Readiness() error {
+	return readiness()
+}
+
+func Reloading() error {
+	return reloading()
+}
+
+func Stopping() error {
+	return stopping()
+}

internal/notify/notify_linux.go

@@ -0,0 +1,48 @@
+package notify
+
+import (
+	"io"
+	"net"
+	"os"
+	"strings"
+)
+
+func notify(path string, r io.Reader) error {
+	s := &net.UnixAddr{
+		Name: path,
+		Net:  "unixgram",
+	}
+	c, err := net.DialUnix(s.Net, nil, s)
+	if err != nil {
+		return err
+	}
+	defer c.Close()
+
+	if _, err := io.Copy(c, r); err != nil {
+		return err
+	}
+	return nil
+}
+
+func socketNotify(payload string) error {
+	v, ok := os.LookupEnv("NOTIFY_SOCKET")
+	if !ok || v == "" {
+		return nil
+	}
+	if err := notify(v, strings.NewReader(payload)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func readiness() error {
+	return socketNotify("READY=1")
+}
+
+func reloading() error {
+	return socketNotify("RELOADING=1")
+}
+
+func stopping() error {
+	return socketNotify("STOPPING=1")
+}

internal/notify/notify_other.go

@@ -0,0 +1,16 @@
+//go:build !linux
+// +build !linux
+
+package notify
+
+func readiness() error {
+	return nil
+}
+
+func reloading() error {
+	return nil
+}
+
+func stopping() error {
+	return nil
+}

loggers/cli/cli.go

@@ -1,22 +1,25 @@
 package cli
 
 import (
-	"emperror.dev/errors"
 	"fmt"
-	"github.com/apex/log"
-	"github.com/apex/log/handlers/cli"
-	color2 "github.com/fatih/color"
-	"github.com/mattn/go-colorable"
 	"io"
 	"os"
 	"strings"
 	"sync"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/apex/log/handlers/cli"
+	color2 "github.com/fatih/color"
+	"github.com/mattn/go-colorable"
 )
 
-var Default = New(os.Stderr, true)
-var bold = color2.New(color2.Bold)
-var boldred = color2.New(color2.Bold, color2.FgRed)
+var (
+	Default = New(os.Stderr, true)
+	bold    = color2.New(color2.Bold)
+	boldred = color2.New(color2.Bold, color2.FgRed)
+)
 
 var Strings = [...]string{
 	log.DebugLevel: "DEBUG",

parser/helpers.go

@@ -2,7 +2,7 @@ package parser
 
 import (
 	"bytes"
-	"io/ioutil"
+	"io"
 	"os"
 	"regexp"
 	"strconv"
@@ -38,29 +38,29 @@ var xmlValueMatchRegex = regexp.MustCompile(`^\[([\w]+)='(.*)'\]$`)
 // Gets the []byte representation of a configuration file to be passed through to other
 // handler functions. If the file does not currently exist, it will be created.
 func readFileBytes(path string) ([]byte, error) {
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 
-	return ioutil.ReadAll(file)
+	return io.ReadAll(file)
 }
 
 // Gets the value of a key based on the value type defined.
-func (cfr *ConfigurationFileReplacement) getKeyValue(value []byte) interface{} {
+func (cfr *ConfigurationFileReplacement) getKeyValue(value string) interface{} {
 	if cfr.ReplaceWith.Type() == jsonparser.Boolean {
-		v, _ := strconv.ParseBool(string(value))
+		v, _ := strconv.ParseBool(value)
 		return v
 	}
 
 	// Try to parse into an int, if this fails just ignore the error and continue
 	// through, returning the string.
-	if v, err := strconv.Atoi(string(value)); err == nil {
+	if v, err := strconv.Atoi(value); err == nil {
 		return v
 	}
 
-	return string(value)
+	return value
 }
 
 // Iterate over an unstructured JSON/YAML/etc. interface and set all of the required
@@ -97,22 +97,21 @@ func (f *ConfigurationFile) IterateOverJson(data []byte) (*gabs.Container, error
 			// If the child is a null value, nothing will happen. Seems reasonable as of the
 			// time this code is being written.
 			for _, child := range parsed.Path(strings.Trim(parts[0], ".")).Children() {
-				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), []byte(value)); err != nil {
+				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), value); err != nil {
 					if errors.Is(err, gabs.ErrNotFound) {
 						continue
 					}
-
 					return nil, errors.WithMessage(err, "failed to set config value of array child")
 				}
 			}
-		} else {
-			if err = v.SetAtPathway(parsed, v.Match, []byte(value)); err != nil {
-				if errors.Is(err, gabs.ErrNotFound) {
 			continue
 		}
 
-				return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
+		if err := v.SetAtPathway(parsed, v.Match, value); err != nil {
+			if errors.Is(err, gabs.ErrNotFound) {
+				continue
 			}
+			return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
 		}
 	}
 
@@ -132,13 +131,10 @@ func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
 	var err error
 
 	matches := checkForArrayElement.FindStringSubmatch(path)
-	if len(matches) < 3 {
-		// Only update the value if the pathway actually exists in the configuration, otherwise
-		// do nothing.
-		if c.ExistsP(path) {
-			_, err = c.SetP(value, path)
-		}
 
+	// Check if we are **NOT** updating an array element.
+	if len(matches) < 3 {
+		_, err = c.SetP(value, path)
 		return err
 	}
 
@@ -196,32 +192,34 @@ func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
 
 // Sets the value at a specific pathway, but checks if we were looking for a specific
 // value or not before doing it.
-func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value []byte) error {
+func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value string) error {
 	if cfr.IfValue == "" {
 		return setValueAtPath(c, path, cfr.getKeyValue(value))
 	}
 
-	// If this is a regex based matching, we need to get a little more creative since
-	// we're only going to replacing part of the string, and not the whole thing.
-	if c.ExistsP(path) && strings.HasPrefix(cfr.IfValue, "regex:") {
-		// We're doing some regex here.
+	// Check if we are replacing instead of overwriting.
+	if strings.HasPrefix(cfr.IfValue, "regex:") {
+		// Doing a regex replacement requires an existing value.
+		// TODO: Do we try passing an empty string to the regex?
+		if c.ExistsP(path) {
+			return gabs.ErrNotFound
+		}
+
 		r, err := regexp.Compile(strings.TrimPrefix(cfr.IfValue, "regex:"))
 		if err != nil {
 			log.WithFields(log.Fields{"if_value": strings.TrimPrefix(cfr.IfValue, "regex:"), "error": err}).
 				Warn("configuration if_value using invalid regexp, cannot perform replacement")
-
 			return nil
 		}
 
-		// If the path exists and there is a regex match, go ahead and attempt the replacement
-		// using the value we got from the key. This will only replace the one match.
-		v := strings.Trim(string(c.Path(path).Bytes()), "\"")
+		v := strings.Trim(c.Path(path).String(), "\"")
 		if r.Match([]byte(v)) {
-			return setValueAtPath(c, path, r.ReplaceAllString(v, string(value)))
+			return setValueAtPath(c, path, r.ReplaceAllString(v, value))
+		}
+		return nil
 	}
 
-		return nil
-	} else if !c.ExistsP(path) || (c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue))) {
+	if c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue)) {
 		return nil
 	}
 

parser/parser.go

@@ -2,8 +2,6 @@ package parser
 
 import (
 	"bufio"
-	"encoding/json"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -13,11 +11,13 @@ import (
 	"github.com/apex/log"
 	"github.com/beevik/etree"
 	"github.com/buger/jsonparser"
+	"github.com/goccy/go-json"
 	"github.com/icza/dyno"
 	"github.com/magiconair/properties"
-	"github.com/pterodactyl/wings/config"
 	"gopkg.in/ini.v1"
 	"gopkg.in/yaml.v2"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 // The file parsing options that are available for a server configuration file.
@@ -30,14 +30,58 @@ 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 {
+	switch cv.Type() {
+	case jsonparser.String:
+		str, err := jsonparser.ParseString(cv.value)
+		if err != nil {
+			panic(errors.Wrap(err, "parser: could not parse value"))
+		}
+		return str
+	case jsonparser.Null:
+		return "<nil>"
+	case jsonparser.Boolean:
+		return string(cv.value)
+	case jsonparser.Number:
+		return string(cv.value)
+	default:
+		return "<invalid>"
+	}
+}
+
 type ConfigurationParser string
 
 func (cp ConfigurationParser) String() string {
 	return string(cp)
 }
 
-// Defines a configuration file for the server startup. These will be looped over
-// and modified before the server finishes booting.
+// ConfigurationFile defines a configuration file for the server startup. These
+// will be looped over and modified before the server finishes booting.
 type ConfigurationFile struct {
 	FileName string                         `json:"file"`
 	Parser   ConfigurationParser            `json:"parser"`
@@ -48,12 +92,10 @@ type ConfigurationFile struct {
 	configuration []byte
 }
 
-// Custom unmarshaler for configuration files. If there is an error while parsing out the
-// replacements, don't fail the entire operation, just log a global warning so someone can
-// find the issue, and return an empty array of replacements.
-//
-// I imagine people will notice configuration replacement isn't working correctly and then
-// the logs should help better expose that issue.
+// UnmarshalJSON is a custom unmarshaler for configuration files. If there is an
+// error while parsing out the replacements, don't fail the entire operation,
+// just log a global warning so someone can find the issue, and return an empty
+// array of replacements.
 func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	var m map[string]*json.RawMessage
 	if err := json.Unmarshal(data, &m); err != nil {
@@ -77,15 +119,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 {
@@ -166,7 +209,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 		}
 
 		b := strings.TrimSuffix(path, filepath.Base(path))
-		if err := os.MkdirAll(b, 0755); err != nil {
+		if err := os.MkdirAll(b, 0o755); err != nil {
 			return errors.WithMessage(err, "failed to create base directory for missing configuration file")
 		} else {
 			if _, err := os.Create(path); err != nil {
@@ -183,7 +226,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 // Parses an xml file.
 func (f *ConfigurationFile) parseXmlFile(path string) error {
 	doc := etree.NewDocument()
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -276,7 +319,7 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	// Ini package can't handle a non-existent file, so handle that automatically here
 	// by creating it if not exists. Then, immediately close the file since we will use
 	// other methods to write the new contents.
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -288,7 +331,29 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	}
 
 	for _, replacement := range f.Replace {
-		path := strings.SplitN(replacement.Match, ".", 2)
+		var (
+			path         []string
+			bracketDepth int
+			v            []int32
+		)
+		for _, c := range replacement.Match {
+			switch c {
+			case '[':
+				bracketDepth++
+			case ']':
+				bracketDepth--
+			case '.':
+				if bracketDepth > 0 || len(path) == 1 {
+					v = append(v, c)
+					continue
+				}
+				path = append(path, string(v))
+				v = v[:0]
+			default:
+				v = append(v, c)
+			}
+		}
+		path = append(path, string(v))
 
 		value, err := f.LookupConfigurationValue(replacement)
 		if err != nil {
@@ -341,7 +406,7 @@ func (f *ConfigurationFile) parseJsonFile(path string) error {
 	}
 
 	output := []byte(data.StringIndent("", "    "))
-	return ioutil.WriteFile(path, output, 0644)
+	return os.WriteFile(path, output, 0o644)
 }
 
 // Parses a yaml file and updates any matching key/value pairs before persisting
@@ -378,14 +443,14 @@ func (f *ConfigurationFile) parseYamlFile(path string) error {
 		return err
 	}
 
-	return ioutil.WriteFile(path, marshaled, 0644)
+	return os.WriteFile(path, marshaled, 0o644)
 }
 
 // Parses a text file using basic find and replace. This is a highly inefficient method of
 // scanning a file and performing a replacement. You should attempt to use anything other
 // than this function where possible.
 func (f *ConfigurationFile) parseTextFile(path string) error {
-	input, err := ioutil.ReadFile(path)
+	input, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -403,55 +468,73 @@ func (f *ConfigurationFile) parseTextFile(path string) error {
 		}
 	}
 
-	if err := ioutil.WriteFile(path, []byte(strings.Join(lines, "\n")), 0644); err != nil {
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
 		return err
 	}
 
 	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)
+	// 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)
-		s.WriteString("\n")
+			s.WriteString(text + "\n")
 		}
-
-	// Close the file.
-	_ = f2.Close()
-
-	// Handle any scanner errors.
+		_ = fd.Close()
 		if err := scanner.Err(); err != nil {
-		return err
+			return errors.WithStackIf(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 +546,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,15 +556,15 @@ 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.
-	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
 	if err != nil {
 		return err
 	}
@@ -489,7 +572,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

@@ -3,6 +3,8 @@ package remote
 import (
 	"fmt"
 	"net/http"
+
+	"emperror.dev/errors"
 )
 
 type RequestErrors struct {
@@ -16,13 +18,31 @@ type RequestError struct {
 	Detail   string `json:"detail"`
 }
 
+// IsRequestError checks if the given error is of the RequestError type.
 func IsRequestError(err error) bool {
-	_, ok := err.(*RequestError)
-
-	return ok
+	var rerr *RequestError
+	if err == nil {
+		return false
+	}
+	return errors.As(err, &rerr)
 }
 
-// Returns the error response in a string form that can be more easily consumed.
+// AsRequestError transforms the error into a RequestError if it is currently
+// one, checking the wrap status from the other error handlers. If the error
+// is not a RequestError nil is returned.
+func AsRequestError(err error) *RequestError {
+	if err == nil {
+		return nil
+	}
+	var rerr *RequestError
+	if errors.As(err, &rerr) {
+		return rerr
+	}
+	return nil
+}
+
+// Error returns the error response in a string form that can be more easily
+// consumed.
 func (re *RequestError) Error() string {
 	c := 0
 	if re.response != nil {
@@ -32,9 +52,13 @@ func (re *RequestError) Error() string {
 	return fmt.Sprintf("Error response from Panel: %s: %s (HTTP/%d)", re.Code, re.Detail, c)
 }
 
-type SftpInvalidCredentialsError struct {
+// StatusCode returns the status code of the response.
+func (re *RequestError) StatusCode() int {
+	return re.response.StatusCode
 }
 
+type SftpInvalidCredentialsError struct{}
+
 func (ice SftpInvalidCredentialsError) Error() string {
 	return "the credentials provided were invalid"
 }

remote/http.go

@@ -3,16 +3,18 @@ package remote
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
+	"strconv"
 	"strings"
 	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/cenkalti/backoff/v4"
+	"github.com/goccy/go-json"
+
 	"github.com/pterodactyl/wings/system"
 )
 
@@ -35,7 +37,7 @@ type client struct {
 	baseUrl     string
 	tokenId     string
 	token       string
-	attempts   int
+	maxAttempts int
 }
 
 // New returns a new HTTP request client that is used for making authenticated
@@ -46,7 +48,7 @@ func New(base string, opts ...ClientOption) Client {
 		httpClient: &http.Client{
 			Timeout: time.Second * 15,
 		},
-		attempts: 1,
+		maxAttempts: 0,
 	}
 	for _, opt := range opts {
 		opt(&c)
@@ -71,11 +73,31 @@ func WithHttpClient(httpClient *http.Client) ClientOption {
 	}
 }
 
+// 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))
+}
+
 // 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)
+	req, err := http.NewRequestWithContext(ctx, method, c.baseUrl+path, body)
 	if err != nil {
 		return nil, err
 	}
@@ -92,45 +114,86 @@ func (c *client) requestOnce(ctx context.Context, method, path string, body io.R
 
 	debugLogRequest(req)
 
-	res, err := c.httpClient.Do(req.WithContext(ctx))
+	res, err := c.httpClient.Do(req)
 	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
-		}
-	}
+// request executes an HTTP request against the Panel API. If there is an error
+// encountered with the request it will be retried using an exponential backoff.
+// If the error returned from the Panel is due to API throttling or because there
+// are invalid authentication credentials provided the request will _not_ be
+// retried by the backoff.
+//
+// This function automatically appends the path to the current client endpoint
+// and adds the required authentication headers to the request that is being
+// created. Errors returned will be of the RequestError type if there was some
+// type of response from the API that can be parsed.
+func (c *client) request(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (*Response, error) {
+	var res *Response
+	err := backoff.Retry(func() error {
+		r, err := c.requestOnce(ctx, method, path, body, opts...)
 		if err != nil {
-		return nil, errors.WithStack(err)
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+				return backoff.Permanent(err)
 			}
-	return
+			return errors.WrapIf(err, "http: request creation failed")
 		}
-
-// 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)
+		res = r
+		if r.HasError() {
+			// Close the request body after returning the error to free up resources.
+			defer r.Body.Close()
+			// Don't keep spamming the endpoint if we've already made too many requests or
+			// if we're not even authenticated correctly. Retrying generally won't fix either
+			// of these issues.
+			if r.StatusCode == http.StatusForbidden ||
+				r.StatusCode == http.StatusTooManyRequests ||
+				r.StatusCode == http.StatusUnauthorized {
+				return backoff.Permanent(r.Error())
 			}
-		r.URL.RawQuery = q.Encode()
-	})
+			return r.Error()
 		}
-
-// post executes a http post request.
-func (c *client) post(ctx context.Context, path string, data interface{}) (*Response, error) {
-	b, err := json.Marshal(data)
+		return nil
+	}, c.backoff(ctx))
 	if err != nil {
+		if v, ok := err.(*backoff.PermanentError); ok {
+			return nil, v.Unwrap()
+		}
 		return nil, err
 	}
-	return c.request(ctx, http.MethodPost, path, bytes.NewBuffer(b))
+	return res, nil
+}
+
+// backoff returns an exponential backoff function for use with remote API
+// requests. This will allow an API call to be executed approximately 10 times
+// before it is finally reported back as an error.
+//
+// This allows for issues with DNS resolution, or rare race conditions due to
+// slower SQL queries on the Panel to potentially self-resolve without just
+// immediately failing the first request. The example below shows the amount of
+// time that has elapsed between each call to the handler when an error is
+// returned. You can tweak these values as needed to get the effect you desire.
+//
+// If maxAttempts is a value greater than 0 the backoff will be capped at a total
+// number of executions, or the MaxElapsedTime, whichever comes first.
+//
+// call(): 0s
+// call(): 552.330144ms
+// call(): 1.63271196s
+// call(): 2.94284202s
+// call(): 4.525234711s
+// call(): 6.865723375s
+// call(): 11.37194223s
+// call(): 14.593421816s
+// call(): 20.202045293s
+// call(): 27.36567952s <-- Stops here as MaxElapsedTime is 30 seconds
+func (c *client) backoff(ctx context.Context) backoff.BackOffContext {
+	b := backoff.NewExponentialBackOff()
+	b.MaxInterval = time.Second * 12
+	b.MaxElapsedTime = time.Second * 30
+	if c.maxAttempts > 0 {
+		return backoff.WithContext(backoff.WithMaxRetries(b, uint64(c.maxAttempts)), ctx)
+	}
+	return backoff.WithContext(b, ctx)
 }
 
 // Response is a custom response type that allows for commonly used error
@@ -157,15 +220,12 @@ func (r *Response) HasError() bool {
 func (r *Response) Read() ([]byte, error) {
 	var b []byte
 	if r.Response == nil {
-		return nil, errors.New("http: attempting to read missing response")
+		return nil, errors.New("remote: attempting to read missing response")
 	}
-
 	if r.Response.Body != nil {
-		b, _ = ioutil.ReadAll(r.Response.Body)
+		b, _ = io.ReadAll(r.Response.Body)
 	}
-
-	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
-
+	r.Response.Body = io.NopCloser(bytes.NewBuffer(b))
 	return b, nil
 }
 
@@ -177,15 +237,16 @@ func (r *Response) BindJSON(v interface{}) error {
 	if err != nil {
 		return err
 	}
-
 	if err := json.Unmarshal(b, &v); err != nil {
-		return errors.Wrap(err, "http: could not unmarshal response")
+		return errors.Wrap(err, "remote: 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:
+// message will be formatted similar to the below example. If there is no error
+// that can be parsed out of the API you'll still get a RequestError returned
+// but the RequestError.Code will be "_MissingResponseCode".
 //
 // HttpNotFoundException: The requested resource does not exist. (HTTP/404)
 func (r *Response) Error() error {
@@ -196,14 +257,18 @@ func (r *Response) Error() error {
 	var errs RequestErrors
 	_ = r.BindJSON(&errs)
 
-	e := &RequestError{}
+	e := &RequestError{
+		Code:   "_MissingResponseCode",
+		Status: strconv.Itoa(r.StatusCode),
+		Detail: "No error response returned from API endpoint.",
+	}
 	if len(errs.Errors) > 0 {
 		e = &errs.Errors[0]
 	}
 
 	e.response = r.Response
 
-	return e
+	return errors.WithStackDepth(e, 1)
 }
 
 // Logs the request into the debug log with all of the important request bits.

remote/http_test.go

@@ -14,8 +14,7 @@ func createTestClient(h http.HandlerFunc) (*client, *httptest.Server) {
 	c := &client{
 		httpClient:  s.Client(),
 		baseUrl:     s.URL,
-
-		attempts: 1,
+		maxAttempts: 1,
 		tokenId:     "testid",
 		token:       "testtoken",
 	}
@@ -47,7 +46,7 @@ func TestRequestRetry(t *testing.T) {
 		}
 		i++
 	})
-	c.attempts = 2
+	c.maxAttempts = 2
 	r, err := c.request(context.Background(), "", "", nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
@@ -60,12 +59,15 @@ func TestRequestRetry(t *testing.T) {
 		rw.WriteHeader(http.StatusInternalServerError)
 		i++
 	})
-	c.attempts = 2
+	c.maxAttempts = 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)
+	assert.Error(t, err)
+	assert.Nil(t, r)
+
+	v := AsRequestError(err)
+	assert.NotNil(t, v)
+	assert.Equal(t, http.StatusInternalServerError, v.StatusCode())
+	assert.Equal(t, 3, i)
 }
 
 func TestGet(t *testing.T) {
@@ -74,7 +76,7 @@ func TestGet(t *testing.T) {
 		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"})
+	r, err := c.Get(context.Background(), "/test", q{"hello": "world"})
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
 }
@@ -85,9 +87,8 @@ func TestPost(t *testing.T) {
 	}
 	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
 		assert.Equal(t, http.MethodPost, r.Method)
-
 	})
-	r, err := c.post(context.Background(), "/test", test)
+	r, err := c.Post(context.Background(), "/test", test)
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
 }

remote/servers.go

@@ -58,62 +58,54 @@ func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, er
 // 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)
+	res, err := c.Post(ctx, "/servers/reset", nil)
 	if err != nil {
-		return errors.WrapIf(err, "remote/servers: failed to reset server state on Panel")
+		return errors.WrapIf(err, "remote: failed to reset server state on Panel")
 	}
-	res.Body.Close()
+	_ = 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)
+	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)
+	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})
+	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()
+	_ = resp.Body.Close()
+	return nil
 }
 
 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})
+	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()
+	_ = resp.Body.Close()
+	return nil
 }
 
 func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful bool) error {
@@ -121,12 +113,12 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 	if successful {
 		state = "success"
 	}
-	resp, err := c.get(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
+	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()
+	_ = resp.Body.Close()
+	return nil
 }
 
 // ValidateSftpCredentials makes a request to determine if the username and
@@ -136,66 +128,54 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 // 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)
+	res, err := c.Post(ctx, "/sftp/auth", request)
 	if err != nil {
+		if err := AsRequestError(err); err != nil && (err.StatusCode() >= 400 && err.StatusCode() < 500) {
+			log.WithFields(log.Fields{"subsystem": "sftp", "username": request.User, "ip": request.IP}).Warn(err.Error())
+			return auth, &SftpInvalidCredentialsError{}
+		}
 		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)
+	if err := res.BindJSON(&auth); err != nil {
 		return auth, err
 	}
+	return auth, nil
+}
 
 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)})
+	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)
+	if err := res.BindJSON(&data); err != nil {
 		return data, err
 	}
+	return data, nil
+}
 
 func (c *client) SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error {
-	resp, err := c.post(ctx, fmt.Sprintf("/backups/%s", backup), data)
+	resp, err := c.Post(ctx, fmt.Sprintf("/backups/%s", backup), data)
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
-	return resp.Error()
+	_ = resp.Body.Close()
+	return nil
 }
 
 // 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})
+	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()
+	_ = resp.Body.Close()
+	return nil
 }
 
 // getServersPaged returns a subset of servers from the Panel API using the
@@ -206,7 +186,7 @@ func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawSer
 		Meta Pagination      `json:"meta"`
 	}
 
-	res, err := c.get(ctx, "/servers", q{
+	res, err := c.Get(ctx, "/servers", q{
 		"page":     strconv.Itoa(page),
 		"per_page": strconv.Itoa(limit),
 	})
@@ -214,10 +194,6 @@ func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawSer
 		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
 	}

remote/types.go

@@ -1,11 +1,13 @@
 package remote
 
 import (
-	"encoding/json"
+	"bytes"
 	"regexp"
 	"strings"
 
 	"github.com/apex/log"
+	"github.com/goccy/go-json"
+
 	"github.com/pterodactyl/wings/parser"
 )
 
@@ -32,7 +34,7 @@ type Pagination struct {
 
 // 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
+// Panel to fetch the latest build information as well as get all the details
 // needed to parse the given Egg.
 //
 // This means we do not need to hit Wings each time part of the server is
@@ -69,6 +71,7 @@ type SftpAuthRequest struct {
 	IP            string `json:"ip"`
 	SessionID     []byte `json:"session_id"`
 	ClientVersion []byte `json:"client_version"`
+	Type          string `json:"type"`
 }
 
 // SftpAuthResponse is returned by the Panel when a pair of SFTP credentials
@@ -76,45 +79,46 @@ type SftpAuthRequest struct {
 // matched as well as the permissions that are assigned to the authenticated
 // user for the SFTP subsystem.
 type SftpAuthResponse struct {
+	SSHKeys     []string `json:"ssh_keys"`
 	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
+	raw []byte
 	reg *regexp.Regexp
 }
 
-// Matches determines if a given string "s" matches the given line.
-func (olm *OutputLineMatcher) Matches(s string) bool {
+// Matches determines if the provided byte string matches the given regex or
+// raw string provided to the matcher.
+func (olm *OutputLineMatcher) Matches(s []byte) bool {
 	if olm.reg == nil {
-		return strings.Contains(s, olm.raw)
+		return bytes.Contains(s, olm.raw)
 	}
-
-	return olm.reg.MatchString(s)
+	return olm.reg.Match(s)
 }
 
 // String returns the matcher's raw comparison string.
 func (olm *OutputLineMatcher) String() string {
-	return olm.raw
+	return string(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 {
+	var r string
+	if err := json.Unmarshal(data, &r); err != nil {
 		return err
 	}
 
-	if strings.HasPrefix(olm.raw, "regex:") && len(olm.raw) > 6 {
-		r, err := regexp.Compile(strings.TrimPrefix(olm.raw, "regex:"))
+	olm.raw = []byte(r)
+	if bytes.HasPrefix(olm.raw, []byte("regex:")) && len(olm.raw) > 6 {
+		r, err := regexp.Compile(strings.TrimPrefix(string(olm.raw), "regex:"))
 		if err != nil {
-			log.WithField("error", err).WithField("raw", olm.raw).Warn("failed to compile output line marked as being regex")
+			log.WithField("error", err).WithField("raw", string(olm.raw)).Warn("failed to compile output line marked as being regex")
 		}
-
 		olm.reg = r
 	}
 

router/downloader/downloader.go

@@ -2,26 +2,27 @@ package downloader
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
 	"fmt"
-	"github.com/google/uuid"
-	"github.com/pterodactyl/wings/server"
 	"io"
+	"mime"
 	"net"
 	"net/http"
 	"net/url"
 	"path/filepath"
-	"regexp"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+	"github.com/google/uuid"
+
+	"github.com/pterodactyl/wings/server"
 )
 
 var client = &http.Client{
 	Timeout: time.Hour * 12,
-	// Disallow any redirect on a HTTP call. This is a security requirement: do not modify
+	// Disallow any redirect on an HTTP call. This is a security requirement: do not modify
 	// this logic without first ensuring that the new target location IS NOT within the current
 	// instance's local network.
 	//
@@ -36,18 +37,14 @@ var client = &http.Client{
 }
 
 var instance = &Downloader{
-	// Tracks all of the active downloads.
+	// Tracks all the active downloads.
 	downloadCache: make(map[string]*Download),
-	// Tracks all of the downloads active for a given server instance. This is
+	// Tracks all the downloads active for a given server instance. This is
 	// primarily used to make things quicker and keep the code a little more
 	// legible throughout here.
 	serverCache: make(map[string][]string),
 }
 
-// Regex to match the end of an IPv4/IPv6 address. This allows the port to be removed
-// so that we are just working with the raw IP address in question.
-var ipMatchRegex = regexp.MustCompile(`(:\d+)$`)
-
 // Internal IP ranges that should be blocked if the resource requested resolves within.
 var internalRanges = []*net.IPNet{
 	mustParseCIDR("127.0.0.1/8"),
@@ -60,9 +57,11 @@ var internalRanges = []*net.IPNet{
 	mustParseCIDR("fc00::/7"),
 }
 
-const ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
-const ErrInvalidIPAddress = errors.Sentinel("downloader: invalid IP address")
-const ErrDownloadFailed = errors.Sentinel("downloader: download request failed")
+const (
+	ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
+	ErrInvalidIPAddress   = errors.Sentinel("downloader: invalid IP address")
+	ErrDownloadFailed     = errors.Sentinel("downloader: download request failed")
+)
 
 type Counter struct {
 	total   int
@@ -77,12 +76,15 @@ func (c *Counter) Write(p []byte) (int, error) {
 }
 
 type DownloadRequest struct {
-	URL       *url.URL
 	Directory string
+	URL       *url.URL
+	FileName  string
+	UseHeader bool
 }
 
 type Download struct {
 	Identifier string
+	path       string
 	mu         sync.RWMutex
 	req        DownloadRequest
 	server     *server.Server
@@ -90,7 +92,7 @@ type Download struct {
 	cancelFunc *context.CancelFunc
 }
 
-// Starts a new tracked download which allows for cancellation later on by calling
+// New 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{
@@ -102,14 +104,14 @@ func New(s *server.Server, r DownloadRequest) *Download {
 	return &dl
 }
 
-// Returns all of the tracked downloads for a given server instance.
+// ByServer returns all the tracked downloads for a given server instance.
 func ByServer(sid string) []*Download {
 	instance.mu.Lock()
 	defer instance.mu.Unlock()
 	var downloads []*Download
 	if v, ok := instance.serverCache[sid]; ok {
 		for _, id := range v {
-			if dl, dlok := instance.downloadCache[id]; dlok {
+			if dl, ok := instance.downloadCache[id]; ok {
 				downloads = append(downloads, dl)
 			}
 		}
@@ -117,7 +119,7 @@ func ByServer(sid string) []*Download {
 	return downloads
 }
 
-// Returns a single Download matching a given identifier. If no download is found
+// ByID returns a single Download matching a given identifier. If no download is found
 // the second argument in the response will be false.
 func ByID(dlid string) *Download {
 	return instance.find(dlid)
@@ -134,7 +136,7 @@ func (dl Download) MarshalJSON() ([]byte, error) {
 	})
 }
 
-// Executes a given download for the server and begins writing the file to the disk. Once
+// Execute executes a given download for the server and begins writing the file to the disk. Once
 // completed the download will be removed from the cache.
 func (dl *Download) Execute() error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Hour*12)
@@ -174,8 +176,28 @@ func (dl *Download) Execute() error {
 		}
 	}
 
-	fnameparts := strings.Split(dl.req.URL.Path, "/")
-	p := filepath.Join(dl.req.Directory, fnameparts[len(fnameparts)-1])
+	if dl.req.UseHeader {
+		if contentDisposition := res.Header.Get("Content-Disposition"); contentDisposition != "" {
+			_, params, err := mime.ParseMediaType(contentDisposition)
+			if err != nil {
+				return errors.WrapIf(err, "downloader: invalid \"Content-Disposition\" header")
+			}
+
+			if v, ok := params["filename"]; ok {
+				dl.path = v
+			}
+		}
+	}
+	if dl.path == "" {
+		if dl.req.FileName != "" {
+			dl.path = dl.req.FileName
+		} else {
+			parts := strings.Split(dl.req.URL.Path, "/")
+			dl.path = parts[len(parts)-1]
+		}
+	}
+
+	p := dl.Path()
 	dl.server.Log().WithField("path", p).Debug("writing remote file to disk")
 
 	r := io.TeeReader(res.Body, dl.counter(res.ContentLength))
@@ -185,7 +207,7 @@ func (dl *Download) Execute() error {
 	return nil
 }
 
-// Cancels a running download and frees up the associated resources. If a file is being
+// Cancel cancels a running download and frees up the associated resources. If a file is being
 // written a partial file will remain present on the disk.
 func (dl *Download) Cancel() {
 	if dl.cancelFunc != nil {
@@ -194,12 +216,12 @@ func (dl *Download) Cancel() {
 	instance.remove(dl.Identifier)
 }
 
-// Checks if the given download belongs to the provided server.
+// BelongsTo checks if the given download belongs to the provided server.
 func (dl *Download) BelongsTo(s *server.Server) bool {
-	return dl.server.Id() == s.Id()
+	return dl.server.ID() == s.ID()
 }
 
-// Returns the current progress of the download as a float value between 0 and 1 where
+// Progress returns the current progress of the download as a float value between 0 and 1 where
 // 1 indicates that the download is completed.
 func (dl *Download) Progress() float64 {
 	dl.mu.RLock()
@@ -207,6 +229,10 @@ func (dl *Download) Progress() float64 {
 	return dl.progress
 }
 
+func (dl *Download) Path() string {
+	return filepath.Join(dl.req.Directory, dl.path)
+}
+
 // Handles a write event by updating the progress completed percentage and firing off
 // events to the server websocket as needed.
 func (dl *Download) counter(contentLength int64) *Counter {
@@ -232,15 +258,19 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 
 	// 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 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"
-		} else {
-			host = host + ":80"
+	if _, _, err := net.SplitHostPort(host); err != nil {
+		if !strings.Contains(err.Error(), "missing port in address") {
+			return errors.WithStack(err)
+		}
+		switch dl.req.URL.Scheme {
+		case "http":
+			host += ":80"
+		case "https":
+			host += ":443"
 		}
 	}
 
@@ -250,7 +280,11 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	}
 	_ = c.Close()
 
-	ip := net.ParseIP(ipMatchRegex.ReplaceAllString(c.RemoteAddr().String(), ""))
+	ipStr, _, err := net.SplitHostPort(c.RemoteAddr().String())
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	ip := net.ParseIP(ipStr)
 	if ip == nil {
 		return errors.WithStack(ErrInvalidIPAddress)
 	}
@@ -265,7 +299,7 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	return nil
 }
 
-// Defines a global downloader struct that keeps track of all currently processing downloads
+// Downloader represents a global downloader that keeps track of all currently processing downloads
 // for the machine.
 type Downloader struct {
 	mu            sync.RWMutex
@@ -273,11 +307,11 @@ type Downloader struct {
 	serverCache   map[string][]string
 }
 
-// Tracks a download in the internal cache for this instance.
+// track tracks a download in the internal cache for this instance.
 func (d *Downloader) track(dl *Download) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	sid := dl.server.Id()
+	sid := dl.server.ID()
 	if _, ok := d.downloadCache[dl.Identifier]; !ok {
 		d.downloadCache[dl.Identifier] = dl
 		if _, ok := d.serverCache[sid]; !ok {
@@ -287,7 +321,7 @@ func (d *Downloader) track(dl *Download) {
 	}
 }
 
-// Finds a given download entry using the provided ID and returns it.
+// find finds a given download entry using the provided ID and returns it.
 func (d *Downloader) find(dlid string) *Download {
 	d.mu.RLock()
 	defer d.mu.RUnlock()
@@ -297,24 +331,24 @@ func (d *Downloader) find(dlid string) *Download {
 	return nil
 }
 
-// Remove the given download reference from the cache storing them. This also updates
+// remove removes the given download reference from the cache storing them. This also updates
 // the slice of active downloads for a given server to not include this download.
-func (d *Downloader) remove(dlid string) {
+func (d *Downloader) remove(dlID string) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	if _, ok := d.downloadCache[dlid]; !ok {
+	if _, ok := d.downloadCache[dlID]; !ok {
 		return
 	}
-	sid := d.downloadCache[dlid].server.Id()
-	delete(d.downloadCache, dlid)
-	if tracked, ok := d.serverCache[sid]; ok {
+	sID := d.downloadCache[dlID].server.ID()
+	delete(d.downloadCache, dlID)
+	if tracked, ok := d.serverCache[sID]; ok {
 		var out []string
 		for _, k := range tracked {
-			if k != dlid {
+			if k != dlID {
 				out = append(out, k)
 			}
 		}
-		d.serverCache[sid] = out
+		d.serverCache[sID] = out
 	}
 }
 

router/error.go

@@ -10,6 +10,7 @@ import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
+
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
 )
@@ -134,7 +135,7 @@ func (e *RequestError) getAsFilesystemError() (int, string) {
 		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
 	}
 	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDiskSpace) || strings.Contains(e.err.Error(), "filesystem: not enough disk space") {
-		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
+		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."

router/middleware.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"github.com/gin-gonic/gin"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 )

router/middleware/middleware.go

@@ -12,6 +12,7 @@ import (
 	"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"
@@ -62,7 +63,7 @@ func (re *RequestError) Abort(c *gin.Context, status int) {
 	// 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())
+			event = event.WithField("server_id", s.ID())
 		}
 	}
 
@@ -217,19 +218,29 @@ func CaptureErrors() gin.HandlerFunc {
 // SetAccessControlHeaders sets the access request control headers on all of
 // the requests.
 func SetAccessControlHeaders() gin.HandlerFunc {
-	origins := config.Get().AllowedOrigins
-	location := config.Get().PanelLocation
+	cfg := config.Get()
+	origins := cfg.AllowedOrigins
+	location := cfg.PanelLocation
+	allowPrivateNetwork := cfg.AllowCORSPrivateNetwork
 
 	return func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", location)
 		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")
+
+		// CORS for Private Networks (RFC1918)
+		// @see https://developer.chrome.com/blog/private-network-access-update/?utm_source=devtools
+		if allowPrivateNetwork {
+			c.Header("Access-Control-Request-Private-Network", "true")
+		}
+
 		// 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
@@ -262,14 +273,14 @@ func ServerExists() gin.HandlerFunc {
 		if c.Param("server") != "" {
 			manager := ExtractManager(c)
 			s = manager.Find(func(s *server.Server) bool {
-				return c.Param("server") == s.Id()
+				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("logger", ExtractLogger(c).WithField("server_id", s.ID()))
 		c.Set("server", s)
 		c.Next()
 	}

router/router.go

@@ -3,13 +3,14 @@ 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"
+	wserver "github.com/pterodactyl/wings/server"
 )
 
 // Configure configures the routing infrastructure for this daemon instance.
-func Configure(m *server.Manager, client remote.Client) *gin.Engine {
+func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	gin.SetMode("release")
 
 	router := gin.New()
@@ -62,7 +63,6 @@ func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 	server.Use(middleware.RequireAuthorization(), middleware.ServerExists())
 	{
 		server.GET("", getServer)
-		server.PATCH("", patchServer)
 		server.DELETE("", deleteServer)
 
 		server.GET("/logs", getServerLogs)
@@ -70,6 +70,7 @@ func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 		server.POST("/commands", postServerCommands)
 		server.POST("/install", postServerInstall)
 		server.POST("/reinstall", postServerReinstall)
+		server.POST("/sync", postServerSync)
 		server.POST("/ws/deny", postServerDenyWSTokens)
 
 		// This archive request causes the archive to start being created

router/router_download.go

@@ -8,6 +8,7 @@ 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"

router/router_server.go

@@ -1,7 +1,6 @@
 package router
 
 import (
-	"bytes"
 	"context"
 	"net/http"
 	"os"
@@ -16,19 +15,9 @@ import (
 	"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 := ExtractServer(c)
-
-	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.
@@ -64,6 +53,7 @@ func postServerPower(c *gin.Context) {
 
 	var data struct {
 		Action      server.PowerAction `json:"action"`
+		WaitSeconds int                `json:"wait_seconds"`
 	}
 
 	if err := c.BindJSON(&data); err != nil {
@@ -94,12 +84,16 @@ func postServerPower(c *gin.Context) {
 	// we can immediately return a response from the server. Some of these actions
 	// can take quite some time, especially stopping or restarting.
 	go func(s *server.Server) {
-		if err := s.HandlePowerAction(data.Action, 30); err != nil {
+		if data.WaitSeconds < 0 || data.WaitSeconds > 300 {
+			data.WaitSeconds = 30
+		}
+		if err := s.HandlePowerAction(data.Action, data.WaitSeconds); err != nil {
 			if errors.Is(err, context.DeadlineExceeded) {
-				s.Log().WithField("action", data.Action).
-					Warn("could not acquire a lock while attempting to perform a power action")
+				s.Log().WithField("action", data.Action).WithField("error", err).Warn("could not process server power action")
+			} else if errors.Is(err, server.ErrIsRunning) {
+				// Do nothing, this isn't something we care about for logging,
 			} else {
-				s.Log().WithFields(log.Fields{"action": data, "error": err}).
+				s.Log().WithFields(log.Fields{"action": data.Action, "wait_seconds": data.WaitSeconds, "error": err}).
 					Error("encountered error processing a server power action in the background")
 			}
 		}
@@ -112,7 +106,7 @@ func postServerPower(c *gin.Context) {
 func postServerCommands(c *gin.Context) {
 	s := ExtractServer(c)
 
-	if running, err := s.Environment.IsRunning(); err != nil {
+	if running, err := s.Environment.IsRunning(c.Request.Context()); err != nil {
 		NewServerError(err, s).Abort(c)
 		return
 	} else if !running {
@@ -139,22 +133,19 @@ func postServerCommands(c *gin.Context) {
 	c.Status(http.StatusNoContent)
 }
 
-// Updates information about a server internally.
-func patchServer(c *gin.Context) {
+// postServerSync will accept a POST request and trigger a re-sync of the given
+// server against the Panel. This can be manually triggered when needed by an
+// external system, or triggered by the Panel itself when modifications are made
+// to the build of a server internally.
+func postServerSync(c *gin.Context) {
 	s := ExtractServer(c)
 
-	buf := bytes.Buffer{}
-	buf.ReadFrom(c.Request.Body)
-
-	if err := s.UpdateDataStructure(buf.Bytes()); err != nil {
-		NewServerError(err, s).Abort(c)
-		return
-	}
-
-	s.SyncWithEnvironment()
-
+	if err := s.Sync(); err != nil {
+		WithError(c, err)
+	} else {
 		c.Status(http.StatusNoContent)
 	}
+}
 
 // Performs a server installation in a background thread.
 func postServerInstall(c *gin.Context) {
@@ -196,16 +187,10 @@ func deleteServer(c *gin.Context) {
 	// Immediately suspend the server to prevent a user from attempting
 	// to start it while this process is running.
 	s.Config().SetSuspended(true)
-
-	// Stop all running background tasks for this server that are using the context on
-	// the server struct. This will cancel any running install processes for the server
-	// as well.
-	s.CtxCancel()
-	s.Events().Destroy()
-	s.Websockets().CancelAll()
+	s.CleanupForDestroy()
 
 	// Remove any pending remote file downloads for the server.
-	for _, dl := range downloader.ByServer(s.Id()) {
+	for _, dl := range downloader.ByServer(s.ID()) {
 		dl.Cancel()
 	}
 
@@ -230,7 +215,7 @@ func deleteServer(c *gin.Context) {
 	}(s.Filesystem().Path())
 
 	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
-		return server.Id() == s.Id()
+		return server.ID() == s.ID()
 	})
 
 	// Deallocate the reference to this server.

router/router_server_backup.go

@@ -8,6 +8,7 @@ import (
 	"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"
@@ -42,7 +43,7 @@ func postServerBackup(c *gin.Context) {
 	// 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"),
 	})
 

router/router_server_files.go

@@ -3,6 +3,7 @@ package router
 import (
 	"bufio"
 	"context"
+	"io"
 	"mime/multipart"
 	"net/http"
 	"net/url"
@@ -12,15 +13,18 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/pterodactyl/wings/config"
+
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
+	"golang.org/x/sync/errgroup"
+
 	"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"
 )
 
 // getServerFileContents returns the contents of a file on the server.
@@ -43,8 +47,16 @@ func getServerFileContents(c *gin.Context) {
 		c.Header("Content-Type", "application/octet-stream")
 	}
 	defer c.Writer.Flush()
-	_, err = bufio.NewReader(f).WriteTo(c.Writer)
-	if err != nil {
+	// 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.
+	//
+	// "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?
@@ -236,7 +248,7 @@ func postServerWriteFile(c *gin.Context) {
 func getServerPullingFiles(c *gin.Context) {
 	s := ExtractServer(c)
 	c.JSON(http.StatusOK, gin.H{
-		"downloads": downloader.ByServer(s.Id()),
+		"downloads": downloader.ByServer(s.ID()),
 	})
 }
 
@@ -244,13 +256,23 @@ func getServerPullingFiles(c *gin.Context) {
 func postServerPullRemoteFile(c *gin.Context) {
 	s := ExtractServer(c)
 	var data struct {
+		// Deprecated
+		Directory  string `binding:"required_without=RootPath,omitempty" json:"directory"`
+		RootPath   string `binding:"required_without=Directory,omitempty" json:"root"`
 		URL        string `binding:"required" json:"url"`
-		Directory string `binding:"required,omitempty" json:"directory"`
+		FileName   string `json:"file_name"`
+		UseHeader  bool   `json:"use_header"`
+		Foreground bool   `json:"foreground"`
 	}
 	if err := c.BindJSON(&data); err != nil {
 		return
 	}
 
+	// Handle the deprecated Directory field in the struct until it is removed.
+	if data.Directory != "" && data.RootPath == "" {
+		data.RootPath = data.Directory
+	}
+
 	u, err := url.Parse(data.URL)
 	if err != nil {
 		if e, ok := err.(*url.Error); ok {
@@ -268,7 +290,7 @@ func postServerPullRemoteFile(c *gin.Context) {
 		return
 	}
 	// Do not allow more than three simultaneous remote file downloads at one time.
-	if len(downloader.ByServer(s.Id())) >= 3 {
+	if len(downloader.ByServer(s.ID())) >= 3 {
 		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 			"error": "This server has reached its limit of 3 simultaneous remote file downloads at once. Please wait for one to complete before trying again.",
 		})
@@ -276,23 +298,43 @@ func postServerPullRemoteFile(c *gin.Context) {
 	}
 
 	dl := downloader.New(s, downloader.DownloadRequest{
+		Directory: data.RootPath,
 		URL:       u,
-		Directory: data.Directory,
+		FileName:  data.FileName,
+		UseHeader: data.UseHeader,
 	})
 
-	// Execute this pull in a seperate thread since it may take a long time to complete.
-	go func() {
+	download := func() error {
 		s.Log().WithField("download_id", dl.Identifier).WithField("url", u.String()).Info("starting pull of remote file to disk")
 		if err := dl.Execute(); err != nil {
 			s.Log().WithField("download_id", dl.Identifier).WithField("error", err).Error("failed to pull remote file")
+			return err
 		} else {
 			s.Log().WithField("download_id", dl.Identifier).Info("completed pull of remote file")
 		}
+		return nil
+	}
+	if !data.Foreground {
+		go func() {
+			_ = download()
 		}()
-
 		c.JSON(http.StatusAccepted, gin.H{
 			"identifier": dl.Identifier,
 		})
+		return
+	}
+
+	if err := download(); err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	}
+
+	st, err := s.Filesystem().Stat(dl.Path())
+	if err != nil {
+		NewServerError(err, s).AbortFilesystemError(c)
+		return
+	}
+	c.JSON(http.StatusOK, &st)
 }
 
 // Stops a remote file download if it exists and belongs to this server.
@@ -374,8 +416,6 @@ func postServerCompressFiles(c *gin.Context) {
 // of unpacking an archive that exists on the server into the provided RootPath
 // for the server.
 func postServerDecompressFiles(c *gin.Context) {
-	s := middleware.ExtractServer(c)
-	lg := middleware.ExtractLogger(c)
 	var data struct {
 		RootPath string `json:"root"`
 		File     string `json:"file"`
@@ -384,7 +424,8 @@ func postServerDecompressFiles(c *gin.Context) {
 		return
 	}
 
-	lg = lg.WithFields(log.Fields{"root_path": data.RootPath, "file": 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 {
@@ -403,7 +444,7 @@ func postServerDecompressFiles(c *gin.Context) {
 		// 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") {
-			lg.WithField("error", err).Warn("failed to decompress file: text file busy")
+			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.",
 			})
@@ -521,8 +562,16 @@ func postServerUploadFiles(c *gin.Context) {
 
 	directory := c.Query("directory")
 
+	maxFileSize := config.Get().Api.UploadLimit
+	maxFileSizeBytes := maxFileSize * 1024 * 1024
 	var totalSize int64
 	for _, header := range headers {
+		if header.Size > maxFileSizeBytes {
+			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+				"error": "File " + header.Filename + " is larger than the maximum file upload size of " + strconv.FormatInt(maxFileSize, 10) + " MB.",
+			})
+			return
+		}
 		totalSize += header.Size
 	}
 

router/router_server_ws.go

@@ -2,19 +2,36 @@ package router
 
 import (
 	"context"
-	"encoding/json"
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"github.com/goccy/go-json"
 	ws "github.com/gorilla/websocket"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/websocket"
 )
 
+var expectedCloseCodes = []int{
+	ws.CloseGoingAway,
+	ws.CloseAbnormalClosure,
+	ws.CloseNormalClosure,
+	ws.CloseNoStatusReceived,
+	ws.CloseServiceRestart,
+}
+
 // Upgrades a connection to a websocket and passes events along between.
 func getServerWebsocket(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 	s, _ := manager.Get(c.Param("server"))
+
+	// Create a context that can be canceled when the user disconnects from this
+	// socket that will also cancel listeners running in separate threads. If the
+	// connection itself is terminated listeners using this context will also be
+	// closed.
+	ctx, cancel := context.WithCancel(c.Request.Context())
+	defer cancel()
+
 	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
 	if err != nil {
 		NewServerError(err, s).Abort(c)
@@ -22,50 +39,37 @@ func getServerWebsocket(c *gin.Context) {
 	}
 	defer handler.Connection.Close()
 
-	// Create a context that can be canceled when the user disconnects from this
-	// socket that will also cancel listeners running in separate threads.
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	// Track this open connection on the server so that we can close them all programmatically
 	// if the server is deleted.
 	s.Websockets().Push(handler.Uuid(), &cancel)
-	defer s.Websockets().Remove(handler.Uuid())
+	handler.Logger().Debug("opening connection to server websocket")
 
-	// Listen for the context being canceled and then close the websocket connection. This normally
-	// just happens because you're disconnecting from the socket in the browser, however in some
-	// cases we close the connections programmatically (e.g. deleting the server) and need to send
-	// a close message to the websocket so it disconnects.
-	go func(ctx context.Context, c *ws.Conn) {
-	ListenerLoop:
-		for {
+	defer func() {
+		s.Websockets().Remove(handler.Uuid())
+		handler.Logger().Debug("closing connection to server websocket")
+	}()
+
+	// If the server is deleted we need to send a close message to the connected client
+	// so that they disconnect since there will be no more events sent along. Listen for
+	// the request context being closed to break this loop, otherwise this routine will
+	// be left hanging in the background.
+	go func() {
 		select {
 		case <-ctx.Done():
+			break
+		case <-s.Context().Done():
 			handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
-				// A break right here without defining the specific loop would only break the select
-				// and not actually break the for loop, thus causing this routine to stick around forever.
-				break ListenerLoop
+			break
 		}
-		}
-	}(ctx, handler.Connection)
-
-	go handler.ListenForServerEvents(ctx)
-	go handler.ListenForExpiration(ctx)
+	}()
 
 	for {
 		j := websocket.Message{}
 
 		_, p, err := handler.Connection.ReadMessage()
 		if err != nil {
-			if !ws.IsCloseError(
-				err,
-				ws.CloseNormalClosure,
-				ws.CloseGoingAway,
-				ws.CloseNoStatusReceived,
-				ws.CloseServiceRestart,
-				ws.CloseAbnormalClosure,
-			) {
-				s.Log().WithField("error", err).Warn("error handling websocket message for server")
+			if ws.IsUnexpectedCloseError(err, expectedCloseCodes...) {
+				handler.Logger().WithField("error", err).Warn("error handling websocket message for server")
 			}
 			break
 		}
@@ -78,7 +82,7 @@ func getServerWebsocket(c *gin.Context) {
 		}
 
 		go func(msg websocket.Message) {
-			if err := handler.HandleInbound(msg); err != nil {
+			if err := handler.HandleInbound(ctx, msg); err != nil {
 				handler.SendErrorJson(msg, err)
 			}
 		}(j)

router/router_system.go

@@ -1,15 +1,18 @@
 package router
 
 import (
-	"bytes"
+	"context"
+	"errors"
 	"net/http"
 	"strings"
 
 	"github.com/apex/log"
 	"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,17 +31,25 @@ 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, middleware.ExtractManager(c).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(c.Request.Context(), manager, buf.Bytes())
+	details := installer.ServerDetails{}
+	if err := c.BindJSON(&details); err != nil {
+		return
+	}
+
+	install, err := installer.New(c.Request.Context(), manager, details)
 	if err != nil {
 		if installer.IsValidationError(err) {
 			c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
@@ -59,14 +70,27 @@ func postCreateServer(c *gin.Context) {
 	// cycle. If there are any errors they will be logged and communicated back
 	// to the Panel where a reinstall may take place.
 	go func(i *installer.Installer) {
-		err := i.Server().CreateEnvironment()
-		if err != nil {
+		if err := i.Server().CreateEnvironment(); err != nil {
 			i.Server().Log().WithField("error", err).Error("failed to create server environment during install process")
 			return
 		}
 
 		if err := i.Server().Install(false); err != nil {
-			log.WithFields(log.Fields{"server": i.Uuid(), "error": err}).Error("failed to run install process for server")
+			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
+			return
+		}
+
+		if i.StartOnCompletion {
+			log.WithField("server_id", i.Server().ID()).Debug("starting server after successful installation")
+			if err := i.Server().HandlePowerAction(server.PowerActionStart, 30); err != nil {
+				if errors.Is(err, context.DeadlineExceeded) {
+					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start"}).Warn("could not acquire a lock while attempting to perform a power action")
+				} else {
+					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start", "error": err}).Error("encountered error processing a server power action in the background")
+				}
+			}
+		} else {
+			log.WithField("server_id", i.Server().ID()).Debug("skipping automatic start after successful server installation")
 		}
 	}(install)
 
@@ -79,15 +103,17 @@ func postUpdateConfiguration(c *gin.Context) {
 	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(config.Get().Api.Ssl.KeyFile)
-		cfg.Api.Ssl.CertificateFile = strings.ToLower(config.Get().Api.Ssl.CertificateFile)
+		cfg.Api.Ssl.KeyFile = config.Get().Api.Ssl.KeyFile
+		cfg.Api.Ssl.CertificateFile = config.Get().Api.Ssl.CertificateFile
 	}
+
 	// Try to write this new configuration to the disk before updating our global
 	// state with it.
 	if err := config.WriteToDisk(cfg); err != nil {

router/router_transfer.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -23,6 +22,7 @@ import (
 	"github.com/juju/ratelimit"
 	"github.com/mholt/archiver/v3"
 	"github.com/mitchellh/colorstring"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/installer"
 	"github.com/pterodactyl/wings/remote"
@@ -49,7 +49,7 @@ type serverTransferRequest struct {
 	ServerID string                  `binding:"required" json:"server_id"`
 	URL      string                  `binding:"required" json:"url"`
 	Token    string                  `binding:"required" json:"token"`
-	Server   json.RawMessage `json:"server"`
+	Server   installer.ServerDetails `json:"server"`
 }
 
 func getArchivePath(sID string) string {
@@ -75,14 +75,14 @@ func getServerArchive(c *gin.Context) {
 	}
 
 	s := ExtractServer(c)
-	if token.Subject != s.Id() {
+	if token.Subject != s.ID() {
 		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
 			"error": "Missing required token subject, or subject is not valid for the requested server.",
 		})
 		return
 	}
 
-	archivePath := getArchivePath(s.Id())
+	archivePath := getArchivePath(s.ID())
 
 	// Stat the archive file.
 	st, err := os.Lstat(archivePath)
@@ -123,7 +123,7 @@ func getServerArchive(c *gin.Context) {
 	c.Header("X-Checksum", checksum)
 	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-Disposition", "attachment; filename="+strconv.Quote(s.ID()+".tar.gz"))
 	c.Header("Content-Type", "application/octet-stream")
 
 	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
@@ -134,7 +134,7 @@ func postServerArchive(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 
 	go func(s *server.Server) {
-		l := log.WithField("server", s.Id())
+		l := log.WithField("server", s.ID())
 
 		// This function automatically adds the Source Node prefix and Timestamp to the log
 		// output before sending it over the websocket.
@@ -157,7 +157,7 @@ func postServerArchive(c *gin.Context) {
 			s.Events().Publish(server.TransferStatusEvent, "failure")
 
 			sendTransferLog("Attempting to notify panel of archive failure..")
-			if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), false); err != nil {
+			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")
@@ -178,7 +178,7 @@ func postServerArchive(c *gin.Context) {
 
 		// Ensure the server is offline. Sometimes a "No such container" error gets through
 		// which means the server is already stopped. We can ignore that.
-		if err := s.Environment.WaitForStop(60, false); err != nil && !strings.Contains(strings.ToLower(err.Error()), "no such container") {
+		if err := s.Environment.WaitForStop(s.Context(), time.Minute, false); err != nil && !strings.Contains(strings.ToLower(err.Error()), "no such container") {
 			sendTransferLog("Failed to stop server, aborting transfer..")
 			l.WithField("error", err).Error("failed to stop server")
 			return
@@ -190,7 +190,7 @@ func postServerArchive(c *gin.Context) {
 		}
 
 		// Attempt to get an archive of the server.
-		if err := a.Create(getArchivePath(s.Id())); 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
@@ -199,7 +199,7 @@ func postServerArchive(c *gin.Context) {
 		sendTransferLog("Successfully created archive, attempting to notify panel..")
 		l.Info("successfully created server transfer archive, notifying panel..")
 
-		if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), true); err != nil {
+		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")
@@ -360,7 +360,7 @@ func postTransfer(c *gin.Context) {
 				sendTransferLog("Server transfer failed, check Wings logs for additional information.")
 				s.Events().Publish(server.TransferStatusEvent, "failure")
 				manager.Remove(func(match *server.Server) bool {
-					return match.Id() == s.Id()
+					return match.ID() == s.ID()
 				})
 
 				// If the transfer status was successful but the request failed, act like the transfer failed.

router/tokens/parser.go

@@ -1,9 +1,11 @@
 package tokens
 
 import (
-	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/pterodactyl/wings/config"
 	"time"
+
+	"github.com/gbrlsnchs/jwt/v3"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 type TokenData interface {

router/tokens/token_store.go

@@ -1,9 +1,10 @@
 package tokens
 
 import (
-	"github.com/patrickmn/go-cache"
 	"sync"
 	"time"
+
+	"github.com/patrickmn/go-cache"
 )
 
 type TokenStore struct {

router/tokens/websocket.go

@@ -1,12 +1,13 @@
 package tokens
 
 import (
-	"encoding/json"
-	"github.com/apex/log"
-	"github.com/gbrlsnchs/jwt/v3"
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/apex/log"
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/goccy/go-json"
 )
 
 // The time at which Wings was booted. No JWT's created before this time are allowed to

router/websocket/listeners.go

@@ -2,21 +2,50 @@ package websocket
 
 import (
 	"context"
-	"github.com/pterodactyl/wings/events"
-	"github.com/pterodactyl/wings/server"
+	"sync"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/system"
+
+	"github.com/pterodactyl/wings/server"
 )
 
-// Checks the time to expiration on the JWT every 30 seconds until the token has
-// expired. If we are within 3 minutes of the token expiring, send a notice over
-// the socket that it is expiring soon. If it has expired, send that notice as well.
-func (h *Handler) ListenForExpiration(ctx context.Context) {
+// RegisterListenerEvents will setup the server event listeners and expiration
+// timers. This is only triggered on first authentication with the websocket,
+// reconnections will not call it.
+//
+// This needs to be called once the socket is properly authenticated otherwise
+// you'll get a flood of error spam in the output that doesn't make sense because
+// Docker events being output to the socket will fail when it hasn't been
+// properly initialized yet.
+//
+// @see https://github.com/pterodactyl/panel/issues/3295
+func (h *Handler) registerListenerEvents(ctx context.Context) {
+	h.Logger().Debug("registering event listeners for connection")
+
+	go func() {
+		if err := h.listenForServerEvents(ctx); err != nil {
+			h.Logger().Warn("error while processing server event; closing websocket connection")
+			if err := h.Connection.Close(); err != nil {
+				h.Logger().WithField("error", errors.WithStack(err)).Error("error closing websocket connection")
+			}
+		}
+	}()
+
+	go h.listenForExpiration(ctx)
+}
+
+// ListenForExpiration checks the time to expiration on the JWT every 30 seconds
+// until the token has expired. If we are within 3 minutes of the token expiring,
+// send a notice over the socket that it is expiring soon. If it has expired,
+// send that notice as well.
+func (h *Handler) listenForExpiration(ctx context.Context) {
 	// Make a ticker and completion channel that is used to continuously poll the
 	// JWT stored in the session to send events to the socket when it is expiring.
 	ticker := time.NewTicker(time.Second * 30)
-
-	// Whenever this function is complete, end the ticker, close out the channel,
-	// and then close the websocket connection.
 	defer ticker.Stop()
 
 	for {
@@ -27,9 +56,9 @@ func (h *Handler) ListenForExpiration(ctx context.Context) {
 			jwt := h.GetJwt()
 			if jwt != nil {
 				if jwt.ExpirationTime.Unix()-time.Now().Unix() <= 0 {
-					_ = h.SendJson(&Message{Event: TokenExpiredEvent})
+					_ = h.SendJson(Message{Event: TokenExpiredEvent})
 				} else if jwt.ExpirationTime.Unix()-time.Now().Unix() <= 60 {
-					_ = h.SendJson(&Message{Event: TokenExpiringEvent})
+					_ = h.SendJson(Message{Event: TokenExpiringEvent})
 				}
 			}
 		}
@@ -50,29 +79,90 @@ var e = []string{
 	server.TransferStatusEvent,
 }
 
-// Listens for different events happening on a server and sends them along
-// to the connected websocket.
-func (h *Handler) ListenForServerEvents(ctx context.Context) {
-	h.server.Log().Debug("listening for server events over websocket")
-	callback := func(e events.Event) {
-		if err := h.SendJson(&Message{Event: e.Topic, Args: []string{e.Data}}); err != nil {
-			h.server.Log().WithField("error", err).Warn("error while sending server data over websocket")
-		}
+// ListenForServerEvents will listen for different events happening on a server
+// and send them along to the connected websocket client. This function will
+// block until the context provided to it is canceled.
+func (h *Handler) listenForServerEvents(ctx context.Context) error {
+	var o sync.Once
+	var err error
+
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	eventChan := make(chan []byte)
+	logOutput := make(chan []byte, 8)
+	installOutput := make(chan []byte, 4)
+
+	h.server.Events().On(eventChan) // TODO: make a sinky
+	h.server.Sink(system.LogSink).On(logOutput)
+	h.server.Sink(system.InstallSink).On(installOutput)
+
+	onError := func(evt string, err2 error) {
+		h.Logger().WithField("event", evt).WithField("error", err2).Error("failed to send event over server websocket")
+		// Avoid race conditions by only setting the error once and then canceling
+		// the context. This way if additional processing errors come through due
+		// to a massive flood of things you still only report and stop at the first.
+		o.Do(func() {
+			err = err2
+		})
+		cancel()
 	}
 
-	// Subscribe to all of the events with the same callback that will push the data out over the
-	// websocket for the server.
-	for _, evt := range e {
-		h.server.Events().On(evt, &callback)
-	}
-
-	go func(ctx context.Context) {
+	for {
 		select {
 		case <-ctx.Done():
-			// Once this context is stopped, de-register all of the listeners that have been registered.
-			for _, evt := range e {
-				h.server.Events().Off(evt, &callback)
+			break
+		case b := <-logOutput:
+			sendErr := h.SendJson(Message{Event: server.ConsoleOutputEvent, Args: []string{string(b)}})
+			if sendErr == nil {
+				continue
+			}
+			onError(server.ConsoleOutputEvent, sendErr)
+		case b := <-installOutput:
+			sendErr := h.SendJson(Message{Event: server.InstallOutputEvent, Args: []string{string(b)}})
+			if sendErr == nil {
+				continue
+			}
+			onError(server.InstallOutputEvent, sendErr)
+		case b := <-eventChan:
+			var e events.Event
+			if err := events.DecodeTo(b, &e); err != nil {
+				continue
+			}
+			var sendErr error
+			message := Message{Event: e.Topic}
+			if str, ok := e.Data.(string); ok {
+				message.Args = []string{str}
+			} else if b, ok := e.Data.([]byte); ok {
+				message.Args = []string{string(b)}
+			} else {
+				b, sendErr = json.Marshal(e.Data)
+				if sendErr == nil {
+					message.Args = []string{string(b)}
 				}
 			}
-	}(ctx)
+
+			if sendErr == nil {
+				sendErr = h.SendJson(message)
+				if sendErr == nil {
+					continue
+				}
+			}
+			onError(message.Event, sendErr)
+		}
+		break
+	}
+
+	// These functions will automatically close the channel if it hasn't been already.
+	h.server.Events().Off(eventChan)
+	h.server.Sink(system.LogSink).Off(logOutput)
+	h.server.Sink(system.InstallSink).Off(installOutput)
+
+	// If the internal context is stopped it is either because the parent context
+	// got canceled or because we ran into an error. If the "err" variable is nil
+	// we can assume the parent was canceled and need not perform any actions.
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
 }

router/websocket/websocket.go

@@ -2,22 +2,25 @@ package websocket
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
 	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/goccy/go-json"
 	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
+	"github.com/pterodactyl/wings/system"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
 )
 
 const (
@@ -55,11 +58,10 @@ func IsJwtError(err error) bool {
 		errors.Is(err, jwt.ErrExpValidation)
 }
 
-// Parses a JWT into a websocket token payload.
+// NewTokenPayload parses a JWT into a websocket token payload.
 func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
-	payload := tokens.WebsocketPayload{}
-	err := tokens.ParseToken(token, &payload)
-	if err != nil {
+	var payload tokens.WebsocketPayload
+	if err := tokens.ParseToken(token, &payload); err != nil {
 		return nil, err
 	}
 
@@ -74,7 +76,7 @@ func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
 	return &payload, nil
 }
 
-// Returns a new websocket handler using the context provided.
+// GetHandler returns a new websocket handler using the context provided.
 func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request) (*Handler, error) {
 	upgrader := websocket.Upgrader{
 		// Ensure that the websocket request is originating from the Panel itself,
@@ -115,18 +117,23 @@ func (h *Handler) Uuid() uuid.UUID {
 	return h.uuid
 }
 
-func (h *Handler) SendJson(v *Message) error {
+func (h *Handler) Logger() *log.Entry {
+	return log.WithField("subsystem", "websocket").
+		WithField("connection", h.Uuid().String()).
+		WithField("server", h.server.ID())
+}
+
+func (h *Handler) SendJson(v Message) error {
 	// Do not send JSON down the line if the JWT on the connection is not valid!
 	if err := h.TokenValid(); err != nil {
-		h.unsafeSendJson(Message{
+		_ = h.unsafeSendJson(Message{
 			Event: JwtErrorEvent,
 			Args:  []string{err.Error()},
 		})
 		return nil
 	}
 
-	j := h.GetJwt()
-	if j != nil {
+	if j := h.GetJwt(); j != nil {
 		// If we're sending installation output but the user does not have the required
 		// permissions to see the output, don't send it down the line.
 		if v.Event == server.InstallOutputEvent {
@@ -180,7 +187,7 @@ func (h *Handler) unsafeSendJson(v interface{}) error {
 	return h.Connection.WriteJSON(v)
 }
 
-// Checks if the JWT is still valid.
+// TokenValid checks if the JWT is still valid.
 func (h *Handler) TokenValid() error {
 	j := h.GetJwt()
 	if j == nil {
@@ -199,14 +206,14 @@ func (h *Handler) TokenValid() error {
 		return ErrJwtNoConnectPerm
 	}
 
-	if h.server.Id() != j.GetServerUuid() {
+	if h.server.ID() != j.GetServerUuid() {
 		return ErrJwtUuidMismatch
 	}
 
 	return nil
 }
 
-// Sends an error back to the connected websocket instance by checking the permissions
+// SendErrorJson sends an error back to the connected websocket instance by checking the permissions
 // of the token. If the user has the "receive-errors" grant we will send back the actual
 // error message, otherwise we just send back a standard error message.
 func (h *Handler) SendErrorJson(msg Message, err error, shouldLog ...bool) error {
@@ -236,7 +243,7 @@ func (h *Handler) SendErrorJson(msg Message, err error, shouldLog ...bool) error
 	return h.unsafeSendJson(wsm)
 }
 
-// Converts an error message into a more readable representation and returns a UUID
+// GetErrorMessage converts an error message into a more readable representation and returns a UUID
 // that can be cross-referenced to find the specific error that triggered.
 func (h *Handler) GetErrorMessage(msg string) (string, uuid.UUID) {
 	u := uuid.Must(uuid.NewRandom())
@@ -246,13 +253,7 @@ func (h *Handler) GetErrorMessage(msg string) (string, uuid.UUID) {
 	return m, u
 }
 
-// Sets the JWT for the websocket in a race-safe manner.
-func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
-	h.Lock()
-	h.jwt = token
-	h.Unlock()
-}
-
+// GetJwt returns the JWT for the websocket in a race-safe manner.
 func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	h.RLock()
 	defer h.RUnlock()
@@ -260,8 +261,15 @@ func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	return h.jwt
 }
 
-// Handle the inbound socket request and route it to the proper server action.
-func (h *Handler) HandleInbound(m Message) error {
+// setJwt sets the JWT for the websocket in a race-safe manner.
+func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
+	h.Lock()
+	h.jwt = token
+	h.Unlock()
+}
+
+// HandleInbound handles an inbound socket request and route it to the proper action.
+func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 	if m.Event != AuthenticationEvent {
 		if err := h.TokenValid(); err != nil {
 			h.unsafeSendJson(Message{
@@ -277,13 +285,6 @@ func (h *Handler) HandleInbound(m Message) error {
 		{
 			token, err := NewTokenPayload([]byte(strings.Join(m.Args, "")))
 			if err != nil {
-				// If the error says the JWT expired, send a token expired
-				// event and hopefully the client renews the token.
-				if err == jwt.ErrExpValidation {
-					h.SendJson(&Message{Event: TokenExpiredEvent})
-					return nil
-				}
-
 				return err
 			}
 
@@ -296,10 +297,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			h.setJwt(token)
 
 			// Tell the client they authenticated successfully.
-			h.unsafeSendJson(Message{
-				Event: AuthenticationSuccessEvent,
-				Args:  []string{},
-			})
+			_ = h.unsafeSendJson(Message{Event: AuthenticationSuccessEvent})
 
 			// Check if the client was refreshing their authentication token
 			// instead of authenticating for the first time.
@@ -309,10 +307,15 @@ func (h *Handler) HandleInbound(m Message) error {
 				return nil
 			}
 
+			// Now that we've authenticated with the token and confirmed that we're not
+			// reconnecting to the socket, register the event listeners for the server and
+			// the token expiration.
+			h.registerListenerEvents(ctx)
+
 			// On every authentication event, send the current server status back
 			// to the client. :)
 			state := h.server.Environment.State()
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatusEvent,
 				Args:  []string{state},
 			})
@@ -324,7 +327,7 @@ func (h *Handler) HandleInbound(m Message) error {
 					_ = h.server.Filesystem().HasSpaceAvailable(false)
 
 					b, _ := json.Marshal(h.server.Proc())
-					h.SendJson(&Message{
+					_ = h.SendJson(Message{
 						Event: server.StatsEvent,
 						Args:  []string{string(b)},
 					})
@@ -351,10 +354,10 @@ func (h *Handler) HandleInbound(m Message) error {
 			}
 
 			err := h.server.HandlePowerAction(action)
-			if errors.Is(err, context.DeadlineExceeded) {
+			if errors.Is(err, system.ErrLockerLocked) {
 				m, _ := h.GetErrorMessage("another power action is currently being processed for this server, please try again later")
 
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: ErrorEvent,
 					Args:  []string{m},
 				})
@@ -366,7 +369,9 @@ func (h *Handler) HandleInbound(m Message) error {
 		}
 	case SendServerLogsEvent:
 		{
-			if running, _ := h.server.Environment.IsRunning(); !running {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			defer cancel()
+			if running, _ := h.server.Environment.IsRunning(ctx); !running {
 				return nil
 			}
 
@@ -376,7 +381,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			}
 
 			for _, line := range logs {
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: server.ConsoleOutputEvent,
 					Args:  []string{line},
 				})
@@ -387,7 +392,7 @@ func (h *Handler) HandleInbound(m Message) error {
 	case SendStatsEvent:
 		{
 			b, _ := json.Marshal(h.server.Proc())
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatsEvent,
 				Args:  []string{string(b)},
 			})

rpm/ptero-wings.spec

@@ -0,0 +1,121 @@
+Name:       ptero-wings
+Version:    1.5.3
+Release:    1%{?dist}
+Summary:    The server control plane for Pterodactyl Panel. Written from the ground-up with security, speed, and stability in mind.
+BuildArch:  x86_64
+License:    MIT
+URL:        https://github.com/pterodactyl/wings
+Source0:    https://github.com/pterodactyl/wings/releases/download/v%{version}/wings_linux_amd64
+
+%if 0%{?rhel} && 0%{?rhel} <= 8
+BuildRequires:  systemd
+%else
+BuildRequires:  systemd-rpm-macros
+%endif
+
+
+%description
+Wings is Pterodactyl's server control plane, built for the rapidly
+changing gaming industry and designed to be highly performant and
+secure. Wings provides an HTTP API allowing you to interface directly
+with running server instances, fetch server logs, generate backups,
+and control all aspects of the server lifecycle.
+
+In addition, Wings ships with a built-in SFTP server allowing your
+system to remain free of Pterodactyl specific dependencies, and
+allowing users to authenticate with the same credentials they would
+normally use to access the Panel.
+
+%prep
+
+%build
+#nothing required
+
+%install
+mkdir -p %{buildroot}%{_bindir}
+mkdir -p %{buildroot}%{_unitdir}
+cp %{_sourcedir}/wings_linux_amd64 %{buildroot}%{_bindir}/wings
+
+cat > %{buildroot}%{_unitdir}/wings.service << EOF
+[Unit]
+Description=Pterodactyl Wings Daemon
+After=docker.service
+Requires=docker.service
+PartOf=docker.service
+StartLimitIntervalSec=600
+
+[Service]
+WorkingDirectory=/etc/pterodactyl
+ExecStart=/usr/bin/wings
+ExecReload=/bin/kill -HUP $MAINPID
+Restart=on-failure
+StartLimitInterval=180
+StartLimitBurst=30
+RestartSec=5s
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+%files
+%attr(0755, root, root) %{_prefix}/bin/wings
+%attr(0644, root, root) %{_unitdir}/wings.service
+
+%post
+
+# Reload systemd
+systemctl daemon-reload
+
+# Create the required directory structure
+mkdir -p /etc/pterodactyl
+mkdir -p /var/lib/pterodactyl/{archives,backups,volumes}
+mkdir -p /var/log/pterodactyl/install
+
+%preun
+
+systemctl is-active %{name} >/dev/null 2>&1
+if [ $? -eq 0 ]; then
+    systemctl stop %{name}
+fi
+
+systemctl is-enabled %{name} >/dev/null 2>&1
+if [ $? -eq 0 ]; then
+    systemctl disable %{name}
+fi
+
+%postun
+rm -rf /var/log/pterodactyl
+
+%verifyscript
+
+wings --version
+
+%changelog
+* Wed Oct 27 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.3-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.3
+- Fixes improper event registration and error handling during socket authentication that would cause the incorrect error message to be returned to the client, or no error in some scenarios. Event registration is now delayed until the socket is fully authenticated to ensure needless listeners are not registed.
+- Fixes dollar signs always being evaluated as environment variables with no way to escape them. They can now be escaped as $$ which will transform into a single dollar sign.
+- A websocket connection to a server will be closed by Wings if there is a send error encountered and the client will be left to handle reconnections, rather than simply logging the error and continuing to listen for new events.
+
+* Sun Sep 12 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.0-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.0
+- Fixes a race condition when setting the application name in the console output for a server.
+- Fixes a server being reinstalled causing the file_denylist parameter for an Egg to be ignored until Wings is restarted.
+- Fixes YAML file parser not correctly setting boolean values.
+- Fixes potential issue where the underlying websocket connection is closed but the parent request context is not yet canceled causing a write over a closed connection.
+- Fixes race condition when closing all active websocket connections when a server is deleted.
+- Fixes logic to determine if a server's context is closed out and send a websocket close message to connected clients. Previously this fired off whenever the request itself was closed, and not when the server context was closed.
+- Exposes 8080 in the wings Dockerfile to better support reverse proxy tools.
+- Releases are now built using Go 1.17 — the minimum version required to build Wings remains Go 1.16.
+- Simplifed the logic powering server updates to only pull information from the Panel rather than trying to accept updated values. All parts of Wings needing the most up-to-date server details should call Server#Sync() to fetch the latest stored build information.
+- Installer#New() no longer requires passing all of the server data as a byte slice, rather a new Installer#ServerDetails struct is exposed which can be passed and accepts a UUID and if the server should be started after the installer finishes.
+- Removes complicated (and unused) logic during the server installation process that was a hold-over from legacy Wings architectures.
+- Removes the PATCH /api/servers/:server endpoint — if you were previously using this API call it should be replaced with POST /api/servers/:server/sync.
+
+* Wed Aug 25 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.4.7-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.4.7
+- SFTP access is now properly denied if a server is suspended.
+- Correctly uses start_on_completion and crash_detection_enabled for servers.

server/backup.go

@@ -2,12 +2,14 @@ package server
 
 import (
 	"io"
-	"io/ioutil"
+	"io/fs"
 	"os"
+	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/backup"
@@ -46,7 +48,7 @@ func (s *Server) getServerwideIgnoredFiles() (string, error) {
 		// Don't read a symlinked ignore file, or a file larger than 32KiB in size.
 		return "", nil
 	}
-	b, err := ioutil.ReadAll(f)
+	b, err := io.ReadAll(f)
 	if err != nil {
 		return "", err
 	}
@@ -60,13 +62,13 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 	ignored := b.Ignored()
 	if b.Ignored() == "" {
 		if i, err := s.getServerwideIgnoredFiles(); err != nil {
-			log.WithField("server", s.Id()).WithField("error", err).Warn("failed to get server-wide ignored files")
+			log.WithField("server", s.ID()).WithField("error", err).Warn("failed to get server-wide ignored files")
 		} else {
 			ignored = i
 		}
 	}
 
-	ad, err := b.Generate(s.Filesystem().Path(), ignored)
+	ad, err := b.Generate(s.Context(), s.Filesystem().Path(), ignored)
 	if err != nil {
 		if err := s.notifyPanelOfBackup(b.Identifier(), &backup.ArchiveDetails{}, false); err != nil {
 			s.Log().WithFields(log.Fields{
@@ -77,7 +79,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 			s.Log().WithField("backup", b.Identifier()).Info("notified panel of failed backup state")
 		}
 
-		_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+		s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 			"uuid":          b.Identifier(),
 			"is_successful": false,
 			"checksum":      "",
@@ -101,7 +103,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 
 	// Emit an event over the socket so we can update the backup in realtime on
 	// the frontend for the server.
-	_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+	s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 		"uuid":          b.Identifier(),
 		"is_successful": true,
 		"checksum":      ad.Checksum,
@@ -140,7 +142,7 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	// 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 err = s.Environment.WaitForStop(s.Context(), time.Minute*2, false); err != nil {
 			if !client.IsErrNotFound(err) {
 				return errors.WrapIf(err, "server/backup: restore: failed to wait for container stop")
 			}
@@ -150,9 +152,15 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	// 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 {
+	err = b.Restore(s.Context(), reader, func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error {
 		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
-		return s.Filesystem().Writefile(file, r)
+		if err := s.Filesystem().Writefile(file, r); err != nil {
+			return err
+		}
+		if err := s.Filesystem().Chmod(file, mode); err != nil {
+			return err
+		}
+		return s.Filesystem().Chtimes(file, atime, mtime)
 	})
 
 	return errors.WithStackIf(err)

server/backup/backup.go

@@ -1,14 +1,19 @@
 package backup
 
 import (
+	"context"
 	"crypto/sha1"
 	"encoding/hex"
 	"io"
+	"io/fs"
 	"os"
 	"path"
-	"sync"
+	"time"
 
+	"emperror.dev/errors"
 	"github.com/apex/log"
+	"golang.org/x/sync/errgroup"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 )
@@ -22,22 +27,39 @@ const (
 
 // 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 RestoreCallback func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error
 
-type ArchiveDetails struct {
-	Checksum     string `json:"checksum"`
-	ChecksumType string `json:"checksum_type"`
-	Size         int64  `json:"size"`
-}
-
-// 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,
-		Successful:   successful,
-	}
+// noinspection GoNameStartsWithPackageName
+type BackupInterface interface {
+	// 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
+	// WithLogContext attaches additional context to the log output for this
+	// backup.
+	WithLogContext(map[string]interface{})
+	// Generate creates a backup in whatever the configured source for the
+	// specific implementation is.
+	Generate(ctx context.Context, basePath string, ignore string) (*ArchiveDetails, error)
+	// Ignored returns the ignored files for this backup instance.
+	Ignored() string
+	// Checksum returns a SHA1 checksum for the generated backup.
+	Checksum() ([]byte, error)
+	// Size returns the size of the generated backup.
+	Size() (int64, error)
+	// 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
+	// Details returns details about the archive.
+	Details(ctx context.Context) (*ArchiveDetails, error)
+	// 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(ctx context.Context, reader io.Reader, callback RestoreCallback) error
 }
 
 type Backup struct {
@@ -54,39 +76,6 @@ type Backup struct {
 	logContext map[string]interface{}
 }
 
-// noinspection GoNameStartsWithPackageName
-type BackupInterface interface {
-	// 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
-	// WithLogContext attaches additional context to the log output for this
-	// backup.
-	WithLogContext(map[string]interface{})
-	// Generate creates a backup in whatever the configured source for the
-	// specific implementation is.
-	Generate(string, string) (*ArchiveDetails, error)
-	// Ignored returns the ignored files for this backup instance.
-	Ignored() string
-	// Checksum returns a SHA1 checksum for the generated backup.
-	Checksum() ([]byte, error)
-	// Size returns the size of the generated backup.
-	Size() (int64, error)
-	// 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
-	// Details returns details about the archive.
-	Details() *ArchiveDetails
-	// 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
 }
@@ -95,12 +84,12 @@ func (b *Backup) Identifier() string {
 	return b.Uuid
 }
 
-// Returns the path for this specific backup.
+// Path returns the path for this specific backup.
 func (b *Backup) Path() string {
 	return path.Join(config.Get().System.BackupDirectory, b.Identifier()+".tar.gz")
 }
 
-// Return the size of the generated backup.
+// Size returns the size of the generated backup.
 func (b *Backup) Size() (int64, error) {
 	st, err := os.Stat(b.Path())
 	if err != nil {
@@ -110,7 +99,7 @@ func (b *Backup) Size() (int64, error) {
 	return st.Size(), nil
 }
 
-// Returns the SHA256 checksum of a backup.
+// Checksum returns the SHA256 checksum of a backup.
 func (b *Backup) Checksum() ([]byte, error) {
 	h := sha1.New()
 
@@ -128,51 +117,34 @@ func (b *Backup) Checksum() ([]byte, error) {
 	return h.Sum(nil), nil
 }
 
-// Returns details of the archive by utilizing two go-routines to get the checksum and
-// the size of the archive.
-func (b *Backup) Details() *ArchiveDetails {
-	wg := sync.WaitGroup{}
-	wg.Add(2)
+// Details returns both the checksum and size of the archive currently stored on
+// the disk to the caller.
+func (b *Backup) Details(ctx context.Context) (*ArchiveDetails, error) {
+	ad := ArchiveDetails{ChecksumType: "sha1"}
+	g, ctx := errgroup.WithContext(ctx)
 
-	l := log.WithField("backup_id", b.Uuid)
-
-	var checksum string
-	// Calculate the checksum for the file.
-	go func() {
-		defer wg.Done()
-
-		l.Info("computing checksum for backup...")
+	g.Go(func() error {
 		resp, err := b.Checksum()
 		if err != nil {
-			log.WithFields(log.Fields{
-				"backup": b.Identifier(),
-				"error":  err,
-			}).Error("failed to calculate checksum for backup")
-			return
+			return err
 		}
+		ad.Checksum = hex.EncodeToString(resp)
+		return nil
+	})
 
-		checksum = hex.EncodeToString(resp)
-		l.WithField("checksum", checksum).Info("computed checksum for backup")
-	}()
-
-	var sz int64
-	go func() {
-		defer wg.Done()
-
-		if s, err := b.Size(); err != nil {
-			return
-		} else {
-			sz = s
+	g.Go(func() error {
+		s, err := b.Size()
+		if err != nil {
+			return err
 		}
-	}()
+		ad.Size = s
+		return nil
+	})
 
-	wg.Wait()
-
-	return &ArchiveDetails{
-		Checksum:     checksum,
-		ChecksumType: "sha1",
-		Size:         sz,
+	if err := g.Wait(); err != nil {
+		return nil, errors.WithStackDepth(err, 1)
 	}
+	return &ad, nil
 }
 
 func (b *Backup) Ignored() string {
@@ -188,3 +160,19 @@ func (b *Backup) log() *log.Entry {
 	}
 	return l
 }
+
+type ArchiveDetails struct {
+	Checksum     string `json:"checksum"`
+	ChecksumType string `json:"checksum_type"`
+	Size         int64  `json:"size"`
+}
+
+// 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,
+		Successful:   successful,
+	}
+}

server/backup/backup_local.go

@@ -1,14 +1,15 @@
 package backup
 
 import (
-	"errors"
-	"github.com/pterodactyl/wings/server/filesystem"
+	"context"
 	"io"
 	"os"
 
+	"emperror.dev/errors"
 	"github.com/mholt/archiver/v3"
+
 	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/system"
+	"github.com/pterodactyl/wings/server/filesystem"
 )
 
 type LocalBackup struct {
@@ -56,32 +57,38 @@ func (b *LocalBackup) WithLogContext(c map[string]interface{}) {
 
 // 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) {
+func (b *LocalBackup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
 	a := &filesystem.Archive{
 		BasePath: basePath,
 		Ignore:   ignore,
 	}
 
-	b.log().Info("creating backup for server...")
+	b.log().WithField("path", b.Path()).Info("creating backup for server")
 	if err := a.Create(b.Path()); err != nil {
 		return nil, err
 	}
 	b.log().Info("created backup successfully")
 
-	return b.Details(), nil
+	ad, err := b.Details(ctx)
+	if err != nil {
+		return nil, errors.WrapIf(err, "backup: failed to get archive details for local backup")
+	}
+	return ad, 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 {
+func (b *LocalBackup) Restore(ctx context.Context, _ io.Reader, callback RestoreCallback) error {
 	return archiver.Walk(b.Path(), func(f archiver.File) error {
+		select {
+		case <-ctx.Done():
+			// Stop walking if the context is canceled.
+			return archiver.ErrStopWalk
+		default:
 			if f.IsDir() {
 				return nil
 			}
-		name, err := system.ExtractArchiveSourceName(f, "/")
-		if err != nil {
-			return err
+			return callback(filesystem.ExtractNameFromArchive(f), f, f.Mode(), f.ModTime(), f.ModTime())
 		}
-		return callback(name, f)
 	})
 }

server/backup/backup_s3.go

@@ -5,13 +5,19 @@ import (
 	"compress/gzip"
 	"context"
 	"fmt"
-	"github.com/pterodactyl/wings/server/filesystem"
 	"io"
 	"net/http"
 	"os"
 	"strconv"
+	"time"
+
+	"emperror.dev/errors"
+	"github.com/cenkalti/backoff/v4"
+
+	"github.com/pterodactyl/wings/server/filesystem"
 
 	"github.com/juju/ratelimit"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 )
@@ -45,7 +51,7 @@ func (s *S3Backup) WithLogContext(c map[string]interface{}) {
 
 // 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) {
+func (s *S3Backup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
 	defer s.Remove()
 
 	a := &filesystem.Archive{
@@ -53,7 +59,7 @@ func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
 		Ignore:   ignore,
 	}
 
-	s.log().Info("creating backup for server...")
+	s.log().WithField("path", s.Path()).Info("creating backup for server")
 	if err := a.Create(s.Path()); err != nil {
 		return nil, err
 	}
@@ -61,29 +67,65 @@ func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
 
 	rc, err := os.Open(s.Path())
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "backup: could not read archive from disk")
 	}
 	defer rc.Close()
 
-	if err := s.generateRemoteRequest(rc); err != nil {
+	if err := s.generateRemoteRequest(ctx, rc); err != nil {
 		return nil, err
 	}
-
-	return s.Details(), nil
+	ad, err := s.Details(ctx)
+	if err != nil {
+		return nil, errors.WrapIf(err, "backup: failed to get archive details after upload")
+	}
+	return ad, nil
 }
 
-// Reader provides a wrapper around an existing io.Reader
-// but implements io.Closer in order to satisfy an io.ReadCloser.
-type Reader struct {
-	io.Reader
+// 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(ctx context.Context, 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 {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			// Do nothing, fall through to the next block of code in this loop.
+		}
+		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, header.FileInfo().Mode(), header.AccessTime, header.ModTime); err != nil {
+				return err
+			}
+		}
 	}
-
-func (Reader) Close() error {
 	return nil
 }
 
 // Generates the remote S3 request and begins the upload.
-func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
+func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser) error {
 	defer rc.Close()
 
 	s.log().Debug("attempting to get size of backup...")
@@ -101,37 +143,7 @@ func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
 	s.log().Debug("got S3 upload urls from the Panel")
 	s.log().WithField("parts", len(urls.Parts)).Info("attempting to upload backup to s3 endpoint...")
 
-	handlePart := func(part string, size int64) (string, error) {
-		r, err := http.NewRequest(http.MethodPut, part, nil)
-		if err != nil {
-			return "", err
-		}
-
-		r.ContentLength = size
-		r.Header.Add("Content-Length", strconv.Itoa(int(size)))
-		r.Header.Add("Content-Type", "application/x-gzip")
-
-		// Limit the reader to the size of the part.
-		r.Body = Reader{Reader: io.LimitReader(rc, size)}
-
-		// This http request can block forever due to it not having a timeout,
-		// but we are uploading up to 5GB of data, so there is not really
-		// a good way to handle a timeout on this.
-		res, err := http.DefaultClient.Do(r)
-		if err != nil {
-			return "", err
-		}
-		defer res.Body.Close()
-
-		// Handle non-200 status codes.
-		if res.StatusCode != http.StatusOK {
-			return "", fmt.Errorf("failed to put S3 object part, %d:%s", res.StatusCode, res.Status)
-		}
-
-		// Get the ETag from the uploaded part, this should be sent with the CompleteMultipartUpload request.
-		return res.Header.Get("ETag"), nil
-	}
-
+	uploader := newS3FileUploader(rc)
 	for i, part := range urls.Parts {
 		// Get the size for the current part.
 		var partSize int64
@@ -144,7 +156,7 @@ func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
 		}
 
 		// Attempt to upload the part.
-		if _, err := handlePart(part, partSize); err != nil {
+		if _, err := uploader.uploadPart(ctx, part, partSize); err != nil {
 			s.log().WithField("part_id", i+1).WithError(err).Warn("failed to upload part")
 			return err
 		}
@@ -157,39 +169,97 @@ 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.
+type s3FileUploader struct {
+	io.ReadCloser
+	client *http.Client
+}
+
+// newS3FileUploader returns a new file uploader instance.
+func newS3FileUploader(file io.ReadCloser) *s3FileUploader {
+	return &s3FileUploader{
+		ReadCloser: file,
+		// We purposefully use a super high timeout on this request since we need to upload
+		// a 5GB file. This assumes at worst a 10Mbps connection for uploading. While technically
+		// you could go slower we're targeting mostly hosted servers that should have 100Mbps
+		// connections anyways.
+		client: &http.Client{Timeout: time.Hour * 2},
+	}
+}
+
+// backoff returns a new expoential backoff implementation using a context that
+// will also stop the backoff if it is canceled.
+func (fu *s3FileUploader) backoff(ctx context.Context) backoff.BackOffContext {
+	b := backoff.NewExponentialBackOff()
+	b.Multiplier = 2
+	b.MaxElapsedTime = time.Minute
+
+	return backoff.WithContext(b, ctx)
+}
+
+// uploadPart attempts to upload a given S3 file part to the S3 system. If a
+// 5xx error is returned from the endpoint this will continue with an exponential
+// backoff to try and successfully upload the part.
 //
-// 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)
+// Once uploaded the ETag is returned to the caller.
+func (fu *s3FileUploader) uploadPart(ctx context.Context, part string, size int64) (string, error) {
+	r, err := http.NewRequestWithContext(ctx, http.MethodPut, part, nil)
 	if err != nil {
-		return err
+		return "", errors.Wrap(err, "backup: could not create request for S3")
 	}
-	defer gr.Close()
-	tr := tar.NewReader(gr)
-	for {
-		header, err := tr.Next()
+
+	r.ContentLength = size
+	r.Header.Add("Content-Length", strconv.Itoa(int(size)))
+	r.Header.Add("Content-Type", "application/x-gzip")
+
+	// Limit the reader to the size of the part.
+	r.Body = Reader{Reader: io.LimitReader(fu.ReadCloser, size)}
+
+	var etag string
+	err = backoff.Retry(func() error {
+		res, err := fu.client.Do(r)
 		if err != nil {
-			if err == io.EOF {
-				break
+			if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+				return backoff.Permanent(err)
 			}
+			// Don't use a permanent error here, if there is a temporary resolution error with
+			// the URL due to DNS issues we want to keep re-trying.
+			return errors.Wrap(err, "backup: S3 HTTP request failed")
+		}
+		_ = res.Body.Close()
+
+		if res.StatusCode != http.StatusOK {
+			err := errors.New(fmt.Sprintf("backup: failed to put S3 object: [HTTP/%d] %s", res.StatusCode, res.Status))
+			// Only attempt a backoff retry if this error is because of a 5xx error from
+			// the S3 endpoint. Any 4xx error should be treated as an error that a retry
+			// would not fix.
+			if res.StatusCode >= http.StatusInternalServerError {
 				return err
 			}
-		if header.Typeflag == tar.TypeReg {
-			if err := callback(header.Name, tr); err != nil {
-				return err
+			return backoff.Permanent(err)
 		}
+
+		// Get the ETag from the uploaded part, this should be sent with the
+		// CompleteMultipartUpload request.
+		etag = res.Header.Get("ETag")
+
+		return nil
+	}, fu.backoff(ctx))
+
+	if err != nil {
+		if v, ok := err.(*backoff.PermanentError); ok {
+			return "", v.Unwrap()
 		}
+		return "", err
 	}
+	return etag, nil
+}
+
+// Reader provides a wrapper around an existing io.Reader
+// but implements io.Closer in order to satisfy an io.ReadCloser.
+type Reader struct {
+	io.Reader
+}
+
+func (Reader) Close() error {
 	return nil
 }

server/config_parser.go

@@ -6,12 +6,14 @@ import (
 	"github.com/gammazero/workerpool"
 )
 
-// Parent function that will update all of the defined configuration files for a server
-// automatically to ensure that they always use the specified values.
+// UpdateConfigurationFiles updates all of the defined configuration files for
+// a server automatically to ensure that they always use the specified values.
 func (s *Server) UpdateConfigurationFiles() {
 	pool := workerpool.New(runtime.NumCPU())
 
+	s.Log().Debug("acquiring process configuration files...")
 	files := s.ProcessConfiguration().ConfigurationFiles
+	s.Log().Debug("acquired process configuration files")
 	for _, cf := range files {
 		f := cf
 
@@ -26,6 +28,8 @@ func (s *Server) UpdateConfigurationFiles() {
 			if err := f.Parse(p, false); err != nil {
 				s.Log().WithField("error", err).Error("failed to parse and update server configuration file")
 			}
+
+			s.Log().WithField("path", f.FileName).Debug("finished processing server configuration file")
 		})
 	}
 

server/configuration.go

@@ -8,7 +8,7 @@ import (
 
 type EggConfiguration struct {
 	// The internal UUID of the Egg on the Panel.
-	ID string
+	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
@@ -33,7 +33,7 @@ type Configuration struct {
 
 	// By default this is false, however if selected within the Panel while installing or re-installing a
 	// server, specific installation scripts will be skipped for the server process.
-	SkipEggScripts bool `default:"false" json:"skip_egg_scripts"`
+	SkipEggScripts bool `json:"skip_egg_scripts"`
 
 	// An array of environment variables that should be passed along to the running
 	// server process.
@@ -41,9 +41,8 @@ type Configuration struct {
 
 	Allocations           environment.Allocations `json:"allocations"`
 	Build                 environment.Limits      `json:"build"`
-	CrashDetectionEnabled bool                    `default:"true" json:"enabled" yaml:"enabled"`
+	CrashDetectionEnabled bool                    `json:"crash_detection_enabled"`
 	Mounts                []Mount                 `json:"mounts"`
-	Resources             ResourceUsage           `json:"resources"`
 	Egg                   EggConfiguration        `json:"egg,omitempty"`
 
 	Container struct {
@@ -55,34 +54,30 @@ type Configuration struct {
 func (s *Server) Config() *Configuration {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return &s.cfg
 }
 
-// Returns the amount of disk space available to a server in bytes.
+// DiskSpace returns the amount of disk space available to a server in bytes.
 func (s *Server) DiskSpace() int64 {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return s.cfg.Build.DiskSpace * 1024.0 * 1024.0
 }
 
 func (s *Server) MemoryLimit() int64 {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return s.cfg.Build.MemoryLimit
 }
 
 func (c *Configuration) GetUuid() string {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-
 	return c.Uuid
 }
 
 func (c *Configuration) SetSuspended(s bool) {
 	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.Suspended = s
-	c.mu.Unlock()
 }

server/console.go

@@ -1,132 +1,81 @@
 package server
 
 import (
-	"context"
 	"fmt"
 	"sync"
-	"sync/atomic"
 	"time"
 
-	"emperror.dev/errors"
 	"github.com/mitchellh/colorstring"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
 )
 
-var ErrTooMuchConsoleData = errors.New("console is outputting too much data")
+// 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 appNameSync sync.Once
 
-type ConsoleThrottler struct {
-	mu sync.Mutex
-	config.ConsoleThrottles
-
-	// The total number of activations that have occurred thus far.
-	activations uint64
-
-	// The total number of lines that have been sent since the last reset timer period.
-	count uint64
-
-	// Wether or not the console output is being throttled. It is up to calling code to
-	// determine what to do if it is.
-	isThrottled *system.AtomicBool
-
-	// The total number of lines processed so far during the given time period.
-	timerCancel *context.CancelFunc
-}
-
-// Resets the state of the throttler.
-func (ct *ConsoleThrottler) Reset() {
-	atomic.StoreUint64(&ct.count, 0)
-	atomic.StoreUint64(&ct.activations, 0)
-	ct.isThrottled.Store(false)
-}
-
-// Triggers an activation for a server. You can also decrement the number of activations
-// by passing a negative number.
-func (ct *ConsoleThrottler) markActivation(increment bool) uint64 {
-	if !increment {
-		if atomic.LoadUint64(&ct.activations) == 0 {
-			return 0
-		}
-
-		// This weird dohicky subtracts 1 from the activation count.
-		return atomic.AddUint64(&ct.activations, ^uint64(0))
-	}
-
-	return atomic.AddUint64(&ct.activations, 1)
-}
-
-// Determines if the console is currently being throttled. Calls to this function can be used to
-// determine if output should be funneled along to the websocket processes.
-func (ct *ConsoleThrottler) Throttled() bool {
-	return ct.isThrottled.Load()
-}
-
-// Starts a timer that runs in a seperate thread and will continually decrement the lines processed
-// and number of activations, regardless of the current console message volume. All of the timers
-// are canceled if the context passed through is canceled.
-func (ct *ConsoleThrottler) StartTimer(ctx context.Context) {
-	system.Every(ctx, time.Duration(int64(ct.LineResetInterval))*time.Millisecond, func(_ time.Time) {
-		ct.isThrottled.Store(false)
-		atomic.StoreUint64(&ct.count, 0)
-	})
-
-	system.Every(ctx, time.Duration(int64(ct.DecayInterval))*time.Millisecond, func(_ time.Time) {
-		ct.markActivation(false)
+// PublishConsoleOutputFromDaemon sends output to the server console formatted
+// to appear correctly as being sent from Wings.
+func (s *Server) PublishConsoleOutputFromDaemon(data string) {
+	appNameSync.Do(func() {
+		appName = config.Get().AppName
 	})
+	s.Events().Publish(
+		ConsoleOutputEvent,
+		colorstring.Color(fmt.Sprintf("[yellow][bold][%s Daemon]:[default] %s", appName, data)),
+	)
 }
 
-// Handles output from a server's console. This code ensures that a server is not outputting
-// an excessive amount of data to the console that could indicate a malicious or run-away process
-// and lead to performance issues for other users.
-//
-// This was much more of a problem for the NodeJS version of the daemon which struggled to handle
-// large volumes of output. However, this code is much more performant so I generally feel a lot
-// better about it's abilities.
-//
-// However, extreme output is still somewhat of a DoS attack vector against this software since we
-// are still logging it to the disk temporarily and will want to avoid dumping a huge amount of
-// data all at once. These values are all configurable via the wings configuration file, however the
-// defaults have been in the wild for almost two years at the time of this writing, so I feel quite
-// confident in them.
-//
-// This function returns an error if the server should be stopped due to violating throttle constraints
-// and a boolean value indicating if a throttle is being violated when it is checked.
-func (ct *ConsoleThrottler) Increment(onTrigger func()) error {
-	if !ct.Enabled {
-		return nil
-	}
-
-	// Increment the line count and if we have now output more lines than are allowed, trigger a throttle
-	// activation. Once the throttle is triggered and has passed the kill at value we will trigger a server
-	// stop automatically.
-	if atomic.AddUint64(&ct.count, 1) >= ct.Lines && !ct.Throttled() {
-		ct.isThrottled.Store(true)
-		if ct.markActivation(true) >= ct.MaximumTriggerCount {
-			return ErrTooMuchConsoleData
-		}
-
-		onTrigger()
-	}
-
-	return nil
-}
-
-// Returns the throttler instance for the server or creates a new one.
-func (s *Server) Throttler() *ConsoleThrottler {
+// Throttler returns the throttler instance for the server or creates a new one.
+func (s *Server) Throttler() *ConsoleThrottle {
 	s.throttleOnce.Do(func() {
-		s.throttler = &ConsoleThrottler{
-			isThrottled:      system.NewAtomicBool(false),
-			ConsoleThrottles: config.Get().Throttles,
+		throttles := config.Get().Throttles
+		period := time.Duration(throttles.Period) * time.Millisecond
+
+		s.throttler = newConsoleThrottle(throttles.Lines, period)
+		s.throttler.strike = func() {
+			s.PublishConsoleOutputFromDaemon(fmt.Sprintf("Server is outputting console data too quickly -- throttling..."))
 		}
 	})
 	return s.throttler
 }
 
-// Sends output to the server console formatted to appear correctly as being sent
-// from Wings.
-func (s *Server) PublishConsoleOutputFromDaemon(data string) {
-	s.Events().Publish(
-		ConsoleOutputEvent,
-		colorstring.Color(fmt.Sprintf("[yellow][bold][Pterodactyl Daemon]:[default] %s", data)),
-	)
+type ConsoleThrottle struct {
+	limit  *system.Rate
+	lock   *system.Locker
+	strike func()
+}
+
+func newConsoleThrottle(lines uint64, period time.Duration) *ConsoleThrottle {
+	return &ConsoleThrottle{
+		limit: system.NewRate(lines, period),
+		lock:  system.NewLocker(),
+	}
+}
+
+// Allow checks if the console is allowed to process more output data, or if too
+// much has already been sent over the line. If there is too much output the
+// strike callback function is triggered, but only if it has not already been
+// triggered at this point in the process.
+//
+// If output is allowed, the lock on the throttler is released and the next time
+// it is triggered the strike function will be re-executed.
+func (ct *ConsoleThrottle) Allow() bool {
+	if !ct.limit.Try() {
+		if err := ct.lock.Acquire(); err == nil {
+			if ct.strike != nil {
+				ct.strike()
+			}
+		}
+		return false
+	}
+	ct.lock.Release()
+	return true
+}
+
+// Reset resets the console throttler internal rate limiter and overage counter.
+func (ct *ConsoleThrottle) Reset() {
+	ct.limit.Reset()
 }

server/console_test.go

@@ -0,0 +1,62 @@
+package server
+
+import (
+	"testing"
+	"time"
+
+	"github.com/franela/goblin"
+)
+
+func TestName(t *testing.T) {
+	g := goblin.Goblin(t)
+
+	g.Describe("ConsoleThrottler", func() {
+		g.It("keeps count of the number of overages in a time period", func() {
+			t := newConsoleThrottle(1, time.Second)
+			g.Assert(t.Allow()).IsTrue()
+			g.Assert(t.Allow()).IsFalse()
+			g.Assert(t.Allow()).IsFalse()
+		})
+
+		g.It("calls strike once per time period", func() {
+			t := newConsoleThrottle(1, time.Millisecond*20)
+
+			var times int
+			t.strike = func() {
+				times = times + 1
+			}
+
+			t.Allow()
+			t.Allow()
+			t.Allow()
+			time.Sleep(time.Millisecond * 100)
+			t.Allow()
+			t.Reset()
+			t.Allow()
+			t.Allow()
+			t.Allow()
+
+			g.Assert(times).Equal(2)
+		})
+
+		g.It("is properly reset", func() {
+			t := newConsoleThrottle(10, time.Second)
+
+			for i := 0; i < 10; i++ {
+				g.Assert(t.Allow()).IsTrue()
+			}
+			g.Assert(t.Allow()).IsFalse()
+			t.Reset()
+			g.Assert(t.Allow()).IsTrue()
+		})
+	})
+}
+
+func BenchmarkConsoleThrottle(b *testing.B) {
+	t := newConsoleThrottle(10, time.Millisecond*10)
+
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		t.Allow()
+	}
+}

server/errors.go

@@ -12,8 +12,7 @@ var (
 	ErrServerIsRestoring    = errors.New("server is currently being restored")
 )
 
-type crashTooFrequent struct {
-}
+type crashTooFrequent struct{}
 
 func (e *crashTooFrequent) Error() string {
 	return "server has crashed too soon after the last detected crash"
@@ -25,8 +24,7 @@ func IsTooFrequentCrashError(err error) bool {
 	return ok
 }
 
-type serverDoesNotExist struct {
-}
+type serverDoesNotExist struct{}
 
 func (e *serverDoesNotExist) Error() string {
 	return "server does not exist on remote system"

server/events.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/system"
 )
 
 // Defines all of the possible output events for a server.
@@ -20,14 +21,35 @@ const (
 	TransferStatusEvent         = "transfer status"
 )
 
-// Returns the server's emitter instance.
-func (s *Server) Events() *events.EventBus {
+// Events returns the server's emitter instance.
+func (s *Server) Events() *events.Bus {
 	s.emitterLock.Lock()
 	defer s.emitterLock.Unlock()
 
 	if s.emitter == nil {
-		s.emitter = events.New()
+		s.emitter = events.NewBus()
 	}
 
 	return s.emitter
 }
+
+// Sink returns the instantiated and named sink for a server. If the sink has
+// not been configured yet this function will cause a panic condition.
+func (s *Server) Sink(name system.SinkName) *system.SinkPool {
+	sink, ok := s.sinks[name]
+	if !ok {
+		s.Log().Fatalf("attempt to access nil sink: %s", name)
+	}
+	return sink
+}
+
+// DestroyAllSinks iterates over all of the sinks configured for the server and
+// destroys their instances. Note that this will cause a panic if you attempt
+// to call Server.Sink() again after. This function is only used when a server
+// is being deleted from the system.
+func (s *Server) DestroyAllSinks() {
+	s.Log().Info("destroying all registered sinks for server instance")
+	for _, sink := range s.sinks {
+		sink.Destroy()
+	}
+}

server/filesystem/archive.go

@@ -3,6 +3,7 @@ package filesystem
 import (
 	"archive/tar"
 	"io"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -13,8 +14,9 @@ import (
 	"github.com/juju/ratelimit"
 	"github.com/karrick/godirwalk"
 	"github.com/klauspost/pgzip"
+	ignore "github.com/sabhiram/go-gitignore"
+
 	"github.com/pterodactyl/wings/config"
-	"github.com/sabhiram/go-gitignore"
 )
 
 const memory = 4 * 1024
@@ -43,7 +45,7 @@ type Archive 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)
+	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}
@@ -156,9 +158,15 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 		return errors.WrapIff(err, "failed executing os.Lstat on '%s'", rp)
 	}
 
+	// Skip socket files as they are unsupported by archive/tar.
+	// Error will come from tar#FileInfoHeader: "archive/tar: sockets not supported"
+	if s.Mode()&fs.ModeSocket != 0 {
+		return nil
+	}
+
 	// Resolve the symlink target if the file is a symlink.
 	var target string
-	if s.Mode()&os.ModeSymlink != 0 {
+	if s.Mode()&fs.ModeSymlink != 0 {
 		// Read the target of the symlink. If there are any errors we will dump them out to
 		// the logs, but we're not going to stop the backup. There are far too many cases of
 		// symlinks causing all sorts of unnecessary pain in this process. Sucks to suck if
@@ -180,7 +188,7 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 	}
 
 	// Fix the header name if the file is not a symlink.
-	if s.Mode()&os.ModeSymlink == 0 {
+	if s.Mode()&fs.ModeSymlink == 0 {
 		header.Name = rp
 	}
 

server/filesystem/compress.go

@@ -1,6 +1,9 @@
 package filesystem
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
 	"fmt"
 	"os"
 	"path"
@@ -9,8 +12,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"emperror.dev/errors"
 	"github.com/mholt/archiver/v3"
-	"github.com/pterodactyl/wings/system"
 )
 
 // CompressFiles compresses all of the files matching the given paths in the
@@ -86,13 +89,13 @@ func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) er
 	// 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 newFilesystemError(ErrCodeDiskSpace, nil)
 		}
 		return nil
 	})
 	if err != nil {
-		if strings.HasPrefix(err.Error(), "format ") {
-			return &Error{code: ErrCodeUnknownArchive}
+		if IsUnknownArchiveFormatError(err) {
+			return newFilesystemError(ErrCodeUnknownArchive, err)
 		}
 		return err
 	}
@@ -111,7 +114,7 @@ func (fs *Filesystem) DecompressFile(dir string, file string) error {
 	}
 	// Ensure that the source archive actually exists on the system.
 	if _, err := os.Stat(source); err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	// Walk all of the files in the archiver file and write them to the disk. If any
@@ -121,25 +124,61 @@ func (fs *Filesystem) DecompressFile(dir string, file string) error {
 		if f.IsDir() {
 			return nil
 		}
-		name, err := system.ExtractArchiveSourceName(f, dir)
-		if err != nil {
-			return WrapError(err, filepath.Join(dir, f.Name()))
-		}
-		p := filepath.Join(dir, name)
+		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 &Error{code: ErrCodeUnknownError, err: err, resolved: source}
+			return wrapError(err, source)
+		}
+		// Update the file permissions to the one set in the archive.
+		if err := fs.Chmod(p, f.Mode()); err != nil {
+			return wrapError(err, source)
+		}
+		// Update the file modification time to the one set in the archive.
+		if err := fs.Chtimes(p, f.ModTime(), f.ModTime()); err != nil {
+			return wrapError(err, source)
 		}
 		return nil
 	})
 	if err != nil {
-		if strings.HasPrefix(err.Error(), "format ") {
-			return &Error{code: ErrCodeUnknownArchive}
+		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/compress_test.go

@@ -0,0 +1,54 @@
+package filesystem
+
+import (
+	"os"
+	"sync/atomic"
+	"testing"
+
+	. "github.com/franela/goblin"
+)
+
+// Given an archive named test.{ext}, with the following file structure:
+//	test/
+//	|──inside/
+//	|────finside.txt
+//	|──outside.txt
+// this test will ensure that it's being decompressed as expected
+func TestFilesystem_DecompressFile(t *testing.T) {
+	g := Goblin(t)
+	fs, rfs := NewFs()
+
+	g.Describe("Decompress", func() {
+		for _, ext := range []string{"zip", "rar", "tar", "tar.gz"} {
+			g.It("can decompress a "+ext, func() {
+				// copy the file to the new FS
+				c, err := os.ReadFile("./testdata/test." + ext)
+				g.Assert(err).IsNil()
+				err = rfs.CreateServerFile("./test."+ext, c)
+				g.Assert(err).IsNil()
+
+				// decompress
+				err = fs.DecompressFile("/", "test."+ext)
+				g.Assert(err).IsNil()
+
+				// make sure everything is where it is supposed to be
+				_, err = rfs.StatServerFile("test/outside.txt")
+				g.Assert(err).IsNil()
+
+				st, err := rfs.StatServerFile("test/inside")
+				g.Assert(err).IsNil()
+				g.Assert(st.IsDir()).IsTrue()
+
+				_, err = rfs.StatServerFile("test/inside/finside.txt")
+				g.Assert(err).IsNil()
+				g.Assert(st.IsDir()).IsTrue()
+			})
+		}
+
+		g.AfterEach(func() {
+			rfs.reset()
+			atomic.StoreInt64(&fs.diskUsed, 0)
+			atomic.StoreInt64(&fs.diskLimit, 0)
+		})
+	})
+}

server/filesystem/disk_space.go

@@ -1,13 +1,14 @@
 package filesystem
 
 import (
-	"emperror.dev/errors"
-	"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 {
@@ -48,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
 }
@@ -200,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

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
@@ -34,6 +35,14 @@ type Error struct {
 	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
@@ -63,13 +72,13 @@ func (e *Error) Error() string {
 	case ErrCodeUnknownError:
 		fallthrough
 	default:
-		return fmt.Sprintf("filesystem: an error occurred: %s", e.Cause())
+		return fmt.Sprintf("filesystem: an error occurred: %s", e.Unwrap())
 	}
 }
 
-// Cause returns the underlying cause of this filesystem error. In some causes
+// 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) Cause() error {
+func (e *Error) Unwrap() error {
 	return e.err
 }
 
@@ -113,20 +122,26 @@ func IsErrorCode(err error, code ErrorCode) bool {
 	return false
 }
 
-// NewBadPathResolution returns a new BadPathResolution error.
-func NewBadPathResolution(path string, resolved string) *Error {
-	return &Error{code: ErrCodePathResolution, path: path, resolved: resolved}
+// 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
 }
 
-// WrapError wraps the provided error as a Filesystem error and attaches the
+// 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 {
-		return nil
+func wrapError(err error, resolved string) error {
+	if err == nil || IsFilesystemError(err) {
+		return err
 	}
-	if IsFilesystemError(err) {
-		return err.(*Error)
-	}
-	return &Error{code: ErrCodeUnknownError, err: err, resolved: resolved}
+	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

@@ -17,9 +17,10 @@ import (
 	"emperror.dev/errors"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/karrick/godirwalk"
+	ignore "github.com/sabhiram/go-gitignore"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
-	ignore "github.com/sabhiram/go-gitignore"
 )
 
 type Filesystem struct {
@@ -67,7 +68,7 @@ func (fs *Filesystem) File(p string) (*os.File, Stat, error) {
 		return nil, Stat{}, err
 	}
 	if st.IsDir() {
-		return nil, Stat{}, &Error{code: ErrCodeIsDirectory}
+		return nil, Stat{}, newFilesystemError(ErrCodeIsDirectory, nil)
 	}
 	f, err := os.Open(cleaned)
 	if err != nil {
@@ -84,7 +85,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	if err != nil {
 		return nil, err
 	}
-	f, err := os.OpenFile(cleaned, flag, 0644)
+	f, err := os.OpenFile(cleaned, flag, 0o644)
 	if err == nil {
 		return f, nil
 	}
@@ -96,7 +97,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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 {
+		if err := os.MkdirAll(filepath.Dir(cleaned), 0o755); err != nil {
 			return nil, errors.Wrap(err, "server/filesystem: touch: failed to create directory tree")
 		}
 		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
@@ -106,7 +107,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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)
+	f, err = o.open(cleaned, flag, 0o644)
 	if err != nil {
 		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file with wait")
 	}
@@ -144,7 +145,7 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 		return errors.Wrap(err, "server/filesystem: writefile: failed to stat file")
 	} else if err == nil {
 		if stat.IsDir() {
-			return &Error{code: ErrCodeIsDirectory, resolved: cleaned}
+			return errors.WithStack(&Error{code: ErrCodeIsDirectory, resolved: cleaned})
 		}
 		currentSize = stat.Size()
 	}
@@ -180,7 +181,7 @@ func (fs *Filesystem) CreateDirectory(name string, p string) error {
 	if err != nil {
 		return err
 	}
-	return os.MkdirAll(cleaned, 0755)
+	return os.MkdirAll(cleaned, 0o755)
 }
 
 // Moves (or renames) a file or directory.
@@ -209,7 +210,7 @@ func (fs *Filesystem) Rename(from string, to string) error {
 	// Ensure that the directory we're moving into exists correctly on the system. Only do this if
 	// we're not at the root directory level.
 	if d != fs.Path() {
-		if mkerr := os.MkdirAll(d, 0755); mkerr != nil {
+		if mkerr := os.MkdirAll(d, 0o755); mkerr != nil {
 			return errors.WithMessage(mkerr, "failed to create directory structure for file rename")
 		}
 	}
@@ -376,7 +377,7 @@ func (fs *Filesystem) TruncateRootDirectory() error {
 	if err := os.RemoveAll(fs.Path()); err != nil {
 		return err
 	}
-	if err := os.Mkdir(fs.Path(), 0755); err != nil {
+	if err := os.Mkdir(fs.Path(), 0o755); err != nil {
 		return err
 	}
 	atomic.StoreInt64(&fs.diskUsed, 0)
@@ -484,7 +485,7 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 			defer wg.Done()
 
 			var m *mimetype.MIME
-			var d = "inode/directory"
+			d := "inode/directory"
 			if !f.IsDir() {
 				cleanedp := filepath.Join(cleaned, f.Name())
 				if f.Mode()&os.ModeSymlink != 0 {
@@ -527,3 +528,20 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 
 	return out, nil
 }
+
+func (fs *Filesystem) Chtimes(path string, atime, mtime time.Time) error {
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return err
+	}
+
+	if fs.isTest {
+		return nil
+	}
+
+	if err := os.Chtimes(cleaned, atime, mtime); err != nil {
+		return err
+	}
+
+	return nil
+}

server/filesystem/filesystem_test.go

@@ -3,7 +3,6 @@ package filesystem
 import (
 	"bytes"
 	"errors"
-	"io/ioutil"
 	"math/rand"
 	"os"
 	"path/filepath"
@@ -12,6 +11,7 @@ import (
 	"unicode/utf8"
 
 	. "github.com/franela/goblin"
+
 	"github.com/pterodactyl/wings/config"
 )
 
@@ -24,7 +24,7 @@ func NewFs() (*Filesystem, *rootFs) {
 		},
 	})
 
-	tmpDir, err := ioutil.TempDir(os.TempDir(), "pterodactyl")
+	tmpDir, err := os.MkdirTemp(os.TempDir(), "pterodactyl")
 	if err != nil {
 		panic(err)
 	}
@@ -44,17 +44,21 @@ type rootFs struct {
 	root string
 }
 
-func (rfs *rootFs) CreateServerFile(p string, c string) error {
+func (rfs *rootFs) CreateServerFile(p string, c []byte) error {
 	f, err := os.Create(filepath.Join(rfs.root, "/server", p))
 
 	if err == nil {
-		f.Write([]byte(c))
+		f.Write(c)
 		f.Close()
 	}
 
 	return err
 }
 
+func (rfs *rootFs) CreateServerFileFromString(p string, c string) error {
+	return rfs.CreateServerFile(p, []byte(c))
+}
+
 func (rfs *rootFs) StatServerFile(p string) (os.FileInfo, error) {
 	return os.Stat(filepath.Join(rfs.root, "/server", p))
 }
@@ -66,7 +70,7 @@ func (rfs *rootFs) reset() {
 		}
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0755); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0o755); err != nil {
 		panic(err)
 	}
 }
@@ -79,7 +83,7 @@ func TestFilesystem_Readfile(t *testing.T) {
 		buf := &bytes.Buffer{}
 
 		g.It("opens a file if it exists on the system", func() {
-			err := rfs.CreateServerFile("test.txt", "testing")
+			err := rfs.CreateServerFileFromString("test.txt", "testing")
 			g.Assert(err).IsNil()
 
 			err = fs.Readfile("test.txt", buf)
@@ -94,7 +98,7 @@ func TestFilesystem_Readfile(t *testing.T) {
 		})
 
 		g.It("returns an error if the \"file\" is a directory", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Readfile("test.txt", buf)
@@ -103,7 +107,7 @@ func TestFilesystem_Readfile(t *testing.T) {
 		})
 
 		g.It("cannot open a file outside the root directory", func() {
-			err := rfs.CreateServerFile("/../test.txt", "testing")
+			err := rfs.CreateServerFileFromString("/../test.txt", "testing")
 			g.Assert(err).IsNil()
 
 			err = fs.Readfile("/../test.txt", buf)
@@ -281,13 +285,13 @@ func TestFilesystem_Rename(t *testing.T) {
 
 	g.Describe("Rename", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "text content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
 				panic(err)
 			}
 		})
 
 		g.It("returns an error if the target already exists", func() {
-			err := rfs.CreateServerFile("target.txt", "taget content")
+			err := rfs.CreateServerFileFromString("target.txt", "taget content")
 			g.Assert(err).IsNil()
 
 			err = fs.Rename("source.txt", "target.txt")
@@ -314,7 +318,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})
 
 		g.It("does not allow renaming from a location outside the root", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "taget content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "taget content")
 
 			err = fs.Rename("/../ext-source.txt", "target.txt")
 			g.Assert(err).IsNotNil()
@@ -336,7 +340,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})
 
 		g.It("allows a folder to be renamed", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Rename("source_dir", "target_dir")
@@ -378,7 +382,7 @@ func TestFilesystem_Copy(t *testing.T) {
 
 	g.Describe("Copy", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "text content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
 				panic(err)
 			}
 
@@ -392,7 +396,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source is outside the root", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "text content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "text content")
 
 			err = fs.Copy("../ext-source.txt")
 			g.Assert(err).IsNotNil()
@@ -400,10 +404,10 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source directory is outside the root", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
-			err = rfs.CreateServerFile("/../nested/in/dir/ext-source.txt", "external content")
+			err = rfs.CreateServerFileFromString("/../nested/in/dir/ext-source.txt", "external content")
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("../nested/in/dir/ext-source.txt")
@@ -416,7 +420,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source is a directory", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("dir")
@@ -461,10 +465,10 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should create a copy inside of a directory", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
-			err = rfs.CreateServerFile("nested/in/dir/source.txt", "test content")
+			err = rfs.CreateServerFileFromString("nested/in/dir/source.txt", "test content")
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("nested/in/dir/source.txt")
@@ -492,7 +496,7 @@ func TestFilesystem_Delete(t *testing.T) {
 
 	g.Describe("Delete", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "test content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "test content"); err != nil {
 				panic(err)
 			}
 
@@ -500,7 +504,7 @@ func TestFilesystem_Delete(t *testing.T) {
 		})
 
 		g.It("does not delete files outside the root directory", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "external content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "external content")
 
 			err = fs.Delete("../ext-source.txt")
 			g.Assert(err).IsNotNil()
@@ -540,11 +544,11 @@ func TestFilesystem_Delete(t *testing.T) {
 				"foo/bar/baz/source.txt",
 			}
 
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0o755)
 			g.Assert(err).IsNil()
 
 			for _, s := range sources {
-				err = rfs.CreateServerFile(s, "test content")
+				err = rfs.CreateServerFileFromString(s, "test content")
 				g.Assert(err).IsNil()
 			}
 

server/filesystem/path.go

@@ -20,7 +20,7 @@ func (fs *Filesystem) IsIgnored(paths ...string) error {
 			return err
 		}
 		if fs.denylist.MatchesPath(sp) {
-			return &Error{code: ErrCodeDenylistFile, path: p, resolved: sp}
+			return errors.WithStack(&Error{code: ErrCodeDenylistFile, path: p, resolved: sp})
 		}
 	}
 	return nil
@@ -115,8 +115,8 @@ func (fs *Filesystem) ParallelSafePath(paths []string) ([]string, error) {
 	var cleaned []string
 
 	// Simple locker function to avoid racy appends to the array of cleaned paths.
-	var m = new(sync.Mutex)
-	var push = func(c string) {
+	m := new(sync.Mutex)
+	push := func(c string) {
 		m.Lock()
 		cleaned = append(cleaned, c)
 		m.Unlock()

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) {
@@ -102,11 +103,11 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 	g := Goblin(t)
 	fs, rfs := NewFs()
 
-	if err := rfs.CreateServerFile("/../malicious.txt", "external content"); err != nil {
+	if err := rfs.CreateServerFileFromString("/../malicious.txt", "external content"); err != nil {
 		panic(err)
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0777); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0o777); err != nil {
 		panic(err)
 	}
 
@@ -180,7 +181,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		})
 
 		g.It("cannot rename a file to a location outside the directory root", func() {
-			rfs.CreateServerFile("my_file.txt", "internal content")
+			rfs.CreateServerFileFromString("my_file.txt", "internal content")
 
 			err := fs.Rename("my_file.txt", "external_dir/my_file.txt")
 			g.Assert(err).IsNotNil()

server/filesystem/stat.go

@@ -1,12 +1,12 @@
 package filesystem
 
 import (
-	"encoding/json"
 	"os"
 	"strconv"
 	"time"
 
 	"github.com/gabriel-vasile/mimetype"
+	"github.com/goccy/go-json"
 )
 
 type Stat struct {

server/install.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
@@ -23,16 +24,17 @@ import (
 	"github.com/pterodactyl/wings/system"
 )
 
-// Executes the installation stack for a server process. Bubbles any errors up to the calling
-// function which should handle contacting the panel to notify it of the server state.
+// Install executes the installation stack for a server process. Bubbles any
+// errors up to the calling function which should handle contacting the panel to
+// notify it of the server state.
 //
-// Pass true as the first argument in order to execute a server sync before the process to
-// ensure the latest information is used.
+// Pass true as the first argument in order to execute a server sync before the
+// process to ensure the latest information is used.
 func (s *Server) Install(sync bool) error {
 	if sync {
 		s.Log().Info("syncing server state with remote source before executing installation process")
 		if err := s.Sync(); err != nil {
-			return err
+			return errors.WrapIf(err, "install: failed to sync server state with Panel")
 		}
 	}
 
@@ -56,7 +58,7 @@ func (s *Server) Install(sync bool) error {
 		// error to this log entry. Otherwise ignore it in this log since whatever is calling
 		// this function should handle the error and will end up logging the same one.
 		if err == nil {
-			l.WithField("error", serr)
+			l.WithField("error", err)
 		}
 
 		l.Warn("failed to notify panel of server install state")
@@ -70,7 +72,7 @@ func (s *Server) Install(sync bool) error {
 	// the install is completed.
 	s.Events().Publish(InstallCompletedEvent, "")
 
-	return err
+	return errors.WithStackIf(err)
 }
 
 // Reinstalls a server's software by utilizing the install script for the server egg. This
@@ -78,8 +80,8 @@ func (s *Server) Install(sync bool) error {
 func (s *Server) Reinstall() error {
 	if s.Environment.State() != environment.ProcessOfflineState {
 		s.Log().Debug("waiting for server instance to enter a stopped state")
-		if err := s.Environment.WaitForStop(10, true); err != nil {
-			return err
+		if err := s.Environment.WaitForStop(s.Context(), time.Second*10, true); err != nil {
+			return errors.WrapIf(err, "install: failed to stop running environment")
 		}
 	}
 
@@ -88,15 +90,10 @@ func (s *Server) Reinstall() error {
 
 // Internal installation function used to simplify reporting back to the Panel.
 func (s *Server) internalInstall() error {
-	script, err := s.client.GetInstallationScript(s.Context(), s.Id())
+	script, err := s.client.GetInstallationScript(s.Context(), s.ID())
 	if err != nil {
-		if !remote.IsRequestError(err) {
 		return err
 	}
-
-		return errors.New(err.Error())
-	}
-
 	p, err := NewInstallationProcess(s, &script)
 	if err != nil {
 		return err
@@ -114,9 +111,7 @@ func (s *Server) internalInstall() error {
 type InstallationProcess struct {
 	Server *Server
 	Script *remote.InstallationScript
-
 	client *client.Client
-	context context.Context
 }
 
 // Generates a new installation process struct that will be used to create containers,
@@ -131,7 +126,6 @@ func NewInstallationProcess(s *Server, script *remote.InstallationScript) (*Inst
 		return nil, err
 	} else {
 		proc.client = c
-		proc.context = s.Context()
 	}
 
 	return proc, nil
@@ -161,7 +155,7 @@ func (s *Server) SetRestoring(state bool) {
 
 // Removes the installer container for the server.
 func (ip *InstallationProcess) RemoveContainer() error {
-	err := ip.client.ContainerRemove(ip.context, ip.Server.Id()+"_installer", types.ContainerRemoveOptions{
+	err := ip.client.ContainerRemove(ip.Server.Context(), ip.Server.ID()+"_installer", types.ContainerRemoveOptions{
 		RemoveVolumes: true,
 		Force:         true,
 	})
@@ -171,11 +165,10 @@ func (ip *InstallationProcess) RemoveContainer() error {
 	return nil
 }
 
-// Runs the installation process, this is done as in a background thread. This will configure
-// the required environment, and then spin up the installation container.
-//
-// Once the container finishes installing the results will be stored in an installation
-// log in the server's configuration directory.
+// Run runs the installation process, this is done as in a background thread.
+// This will configure the required environment, and then spin up the
+// installation container. Once the container finishes installing the results
+// are stored in an installation log in the server's configuration directory.
 func (ip *InstallationProcess) Run() error {
 	ip.Server.Log().Debug("acquiring installation process lock")
 	if !ip.Server.installing.SwapIf(true) {
@@ -211,7 +204,7 @@ func (ip *InstallationProcess) Run() error {
 
 // Returns the location of the temporary data for the installation process.
 func (ip *InstallationProcess) tempDir() string {
-	return filepath.Join(os.TempDir(), "pterodactyl/", ip.Server.Id())
+	return filepath.Join(config.Get().System.TmpDirectory, ip.Server.ID())
 }
 
 // Writes the installation script to a temporary file on the host machine so that it
@@ -219,11 +212,11 @@ func (ip *InstallationProcess) tempDir() string {
 func (ip *InstallationProcess) writeScriptToDisk() error {
 	// Make sure the temp directory root exists before trying to make a directory within it. The
 	// ioutil.TempDir call expects this base to exist, it won't create it for you.
-	if err := os.MkdirAll(ip.tempDir(), 0700); err != nil {
+	if err := os.MkdirAll(ip.tempDir(), 0o700); err != nil {
 		return errors.WithMessage(err, "could not create temporary directory for install process")
 	}
 
-	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
 	if err != nil {
 		return errors.WithMessage(err, "failed to write server installation script to disk before mount")
 	}
@@ -271,9 +264,9 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 		imagePullOptions.RegistryAuth = b64
 	}
 
-	r, err := ip.client.ImagePull(context.Background(), ip.Script.ContainerImage, imagePullOptions)
+	r, err := ip.client.ImagePull(ip.Server.Context(), ip.Script.ContainerImage, imagePullOptions)
 	if err != nil {
-		images, ierr := ip.client.ImageList(context.Background(), types.ImageListOptions{})
+		images, ierr := ip.client.ImageList(ip.Server.Context(), types.ImageListOptions{})
 		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.
@@ -316,9 +309,10 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 	return nil
 }
 
-// Runs before the container is executed. This pulls down the required docker container image
-// as well as writes the installation script to the disk. This process is executed in an async
-// manner, if either one fails the error is returned.
+// BeforeExecute runs before the container is executed. This pulls down the
+// required docker container image as well as writes the installation script to
+// the disk. This process is executed in an async manner, if either one fails
+// the error is returned.
 func (ip *InstallationProcess) BeforeExecute() error {
 	if err := ip.writeScriptToDisk(); err != nil {
 		return errors.WithMessage(err, "failed to write installation script to disk")
@@ -334,7 +328,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.LogDirectory, "/install", 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
@@ -344,7 +338,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	defer ip.RemoveContainer()
 
 	ip.Server.Log().WithField("container_id", containerId).Debug("pulling installation logs for server")
-	reader, err := ip.client.ContainerLogs(ip.context, containerId, types.ContainerLogsOptions{
+	reader, err := ip.client.ContainerLogs(ip.Server.Context(), containerId, types.ContainerLogsOptions{
 		ShowStdout: true,
 		ShowStderr: true,
 		Follow:     false,
@@ -354,7 +348,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 		return err
 	}
 
-	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}
@@ -370,7 +364,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 |
 | Details
 | ------------------------------
-  Server UUID:          {{.Server.Id}}
+  Server UUID:          {{.Server.ID}}
   Container Image:      {{.Script.ContainerImage}}
   Container Entrypoint: {{.Script.Entrypoint}}
 
@@ -399,12 +393,13 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	return nil
 }
 
-// Executes the installation process inside a specially created docker container.
+// Execute executes the installation process inside a specially created docker
+// container.
 func (ip *InstallationProcess) Execute() (string, error) {
 	// Create a child context that is canceled once this function is done running. This
 	// will also be canceled if the parent context (from the Server struct) is canceled
 	// which occurs if the server is deleted.
-	ctx, cancel := context.WithCancel(ip.context)
+	ctx, cancel := context.WithCancel(ip.Server.Context())
 	defer cancel()
 
 	conf := &container.Config{
@@ -439,6 +434,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 				ReadOnly: false,
 			},
 		},
+		Resources: ip.resourceLimits(),
 		Tmpfs: map[string]string{
 			"/tmp": "rw,exec,nosuid,size=" + tmpfsSize + "M",
 		},
@@ -473,7 +469,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		}
 	}()
 
-	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.Id()+"_installer")
+	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.ID()+"_installer")
 	if err != nil {
 		return "", err
 	}
@@ -510,44 +506,65 @@ func (ip *InstallationProcess) Execute() (string, error) {
 	return r.ID, nil
 }
 
-// Streams the output of the installation process to a log file in the server configuration
-// directory, as well as to a websocket listener so that the process can be viewed in
-// the panel by administrators.
+// StreamOutput streams the output of the installation process to a log file in
+// the server configuration directory, as well as to a websocket listener so
+// that the process can be viewed in the panel by administrators.
 func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) error {
-	reader, err := ip.client.ContainerLogs(ctx, id, types.ContainerLogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Follow:     true,
-	})
-
+	opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true, Follow: true}
+	reader, err := ip.client.ContainerLogs(ctx, id, opts)
 	if err != nil {
 		return err
 	}
 	defer reader.Close()
 
-	evts := ip.Server.Events()
-	err = system.ScanReader(reader, func(line string) {
-		evts.Publish(InstallOutputEvent, line)
-	})
-	if err != nil {
+	err = system.ScanReader(reader, ip.Server.Sink(system.InstallSink).Push)
+	if err != nil && !errors.Is(err, context.Canceled) {
 		ip.Server.Log().WithFields(log.Fields{"container_id": id, "error": err}).Warn("error processing install output lines")
 	}
 	return nil
 }
 
-// Makes a HTTP request to the Panel instance notifying it that the server has
-// completed the installation process, and what the state of the server is. A boolean
-// value of "true" means everything was successful, "false" means something went
-// wrong and the server must be deleted and re-created.
+// resourceLimits returns the install container specific resource limits. This
+// looks at the globally defined install container limits and attempts to use
+// the higher of the two (defined limits & server limits). This allows for servers
+// with super low limits (e.g. Discord bots with 128Mb of memory) to perform more
+// intensive installation processes if needed.
+//
+// This also avoids a server with limits such as 4GB of memory from accidentally
+// consuming 2-5x the defined limits during the install process and causing
+// system instability.
+func (ip *InstallationProcess) resourceLimits() container.Resources {
+	limits := config.Get().Docker.InstallerLimits
+
+	// Create a copy of the configuration so we're not accidentally making changes
+	// to the underlying server build data.
+	c := *ip.Server.Config()
+	cfg := c.Build
+	if cfg.MemoryLimit < limits.Memory {
+		cfg.MemoryLimit = limits.Memory
+	}
+	// Only apply the CPU limit if neither one is currently set to unlimited. If the
+	// installer CPU limit is unlimited don't even waste time with the logic, just
+	// set the config to unlimited for this.
+	if limits.Cpu == 0 {
+		cfg.CpuLimit = 0
+	} else if cfg.CpuLimit != 0 && cfg.CpuLimit < limits.Cpu {
+		cfg.CpuLimit = limits.Cpu
+	}
+
+	resources := cfg.AsContainerResources()
+	// Explicitly remove the PID limits for the installation container. These scripts are
+	// defined at an administrative level and users can't manually execute things like a
+	// fork bomb during this process.
+	resources.PidsLimit = nil
+
+	return resources
+}
+
+// SyncInstallState makes a HTTP request to the Panel instance notifying it that
+// the server has completed the installation process, and what the state of the
+// server is. A boolean 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 := s.client.SetInstallationStatus(s.Context(), s.Id(), successful)
-	if err != nil {
-		if !remote.IsRequestError(err) {
-			return err
-		}
-
-		return errors.New(err.Error())
-	}
-
-	return nil
+	return s.client.SetInstallationStatus(s.Context(), s.ID(), successful)
 }

server/listeners.go

@@ -1,15 +1,17 @@
 package server
 
 import (
-	"encoding/json"
+	"bytes"
 	"regexp"
 	"strconv"
 	"sync"
+	"time"
 
 	"github.com/apex/log"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/system"
+
+	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 )
 
@@ -40,136 +42,137 @@ func (dsl *diskSpaceLimiter) Reset() {
 // 15 seconds, and terminate it forcefully if it does not stop.
 //
 // This function is only executed one time, so whenever a server is marked as booting the limiter
-// should be reset so it can properly be triggered as needed.
+// should be reset, so it can properly be triggered as needed.
 func (dsl *diskSpaceLimiter) Trigger() {
 	dsl.o.Do(func() {
 		dsl.server.PublishConsoleOutputFromDaemon("Server is exceeding the assigned disk space limit, stopping process now.")
-		if err := dsl.server.Environment.WaitForStop(60, true); err != nil {
+		if err := dsl.server.Environment.WaitForStop(dsl.server.Context(), time.Minute, true); err != nil {
 			dsl.server.Log().WithField("error", err).Error("failed to stop server after exceeding space limit!")
 		}
 	})
 }
 
-// Adds all of the internal event listeners we want to use for a server. These listeners can only be
-// removed by deleting the server as they should last for the duration of the process' lifetime.
-func (s *Server) StartEventListeners() {
-	console := func(e events.Event) {
-		t := s.Throttler()
-		err := t.Increment(func() {
-			s.PublishConsoleOutputFromDaemon("Your server is outputting too much data and is being throttled.")
-		})
+// processConsoleOutputEvent handles output from a server's Docker container
+// and runs through different limiting logic to ensure that spam console output
+// does not cause negative effects to the system. This will also monitor the
+// output lines to determine if the server is started yet, and if the output is
+// not being throttled, will send the data over to the websocket.
+func (s *Server) processConsoleOutputEvent(v []byte) {
+	// Always process the console output, but do this in a seperate thread since we
+	// don't really care about side-effects from this call, and don't want it to block
+	// the console sending logic.
+	go s.onConsoleOutput(v)
 
-		// An error is only returned if the server has breached the thresholds set.
-		if err != nil {
-			// If the process is already stopping, just let it continue with that action rather than attempting
-			// to terminate again.
-			if s.Environment.State() != environment.ProcessStoppingState {
-				s.Environment.SetState(environment.ProcessStoppingState)
-
-				go func() {
-					s.Log().Warn("stopping server instance, violating throttle limits")
-					s.PublishConsoleOutputFromDaemon("Your server is being stopped for outputting too much data in a short period of time.")
-
-					// Completely skip over server power actions and terminate the running instance. This gives the
-					// server 15 seconds to finish stopping gracefully before it is forcefully terminated.
-					if err := s.Environment.WaitForStop(config.Get().Throttles.StopGracePeriod, true); err != nil {
-						// If there is an error set the process back to running so that this throttler is called
-						// again and hopefully kills the server.
-						if s.Environment.State() != environment.ProcessOfflineState {
-							s.Environment.SetState(environment.ProcessRunningState)
-						}
-
-						s.Log().WithField("error", err).Error("failed to terminate environment after triggering throttle")
-					}
-				}()
-			}
-		}
-
-		// If we are not throttled, go ahead and output the data.
-		if !t.Throttled() {
-			s.Events().Publish(ConsoleOutputEvent, e.Data)
-		}
-
-		// Also pass the data along to the console output channel.
-		s.onConsoleOutput(e.Data)
-	}
-
-	l := newDiskLimiter(s)
-	state := func(e events.Event) {
-		// Reset the throttler when the process is started.
-		if e.Data == environment.ProcessStartingState {
-			l.Reset()
-			s.Throttler().Reset()
-		}
-
-		s.OnStateChange()
-	}
-
-	stats := func(e events.Event) {
-		st := new(environment.Stats)
-		if err := json.Unmarshal([]byte(e.Data), st); err != nil {
-			s.Log().WithField("error", err).Warn("failed to unmarshal server environment stats")
+	// If the console is being throttled, do nothing else with it, we don't want
+	// to waste time. This code previously terminated server instances after violating
+	// different throttle limits. That code was clunky and difficult to reason about,
+	// in addition to being a consistent pain point for users.
+	//
+	// In the interest of building highly efficient software, that code has been removed
+	// here, and we'll rely on the host to detect bad actors through their own means.
+	if !s.Throttler().Allow() {
 		return
 	}
 
-		// Update the server resource tracking object with the resources we got here.
-		s.resources.mu.Lock()
-		s.resources.Stats = *st
-		s.resources.mu.Unlock()
-
-		// If there is no disk space available at this point, trigger the server disk limiter logic
-		// which will start to stop the running instance.
-		if !s.Filesystem().HasSpaceAvailable(true) {
-			l.Trigger()
+	s.Sink(system.LogSink).Push(v)
 }
 
-		s.emitProcUsage()
-	}
-
-	docker := func(e events.Event) {
-		if e.Topic == environment.DockerImagePullStatus {
-			s.Events().Publish(InstallOutputEvent, e.Data)
-		} else if e.Topic == environment.DockerImagePullStarted {
-			s.PublishConsoleOutputFromDaemon("Pulling Docker container image, this could take a few minutes to complete...")
-		} else {
-			s.PublishConsoleOutputFromDaemon("Finished pulling Docker container image")
-		}
-	}
+// StartEventListeners adds all the internal event listeners we want to use for
+// a server. These listeners can only be removed by deleting the server as they
+// should last for the duration of the process' lifetime.
+func (s *Server) StartEventListeners() {
+	c := make(chan []byte, 8)
+	limit := newDiskLimiter(s)
 
 	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)
-	for _, evt := range dockerEvents {
-		s.Environment.Events().On(evt, &docker)
+	s.Environment.Events().On(c)
+	s.Environment.SetLogCallback(s.processConsoleOutputEvent)
+
+	go func() {
+		for {
+			select {
+			case v := <-c:
+				go func(v []byte, limit *diskSpaceLimiter) {
+					var e events.Event
+					if err := events.DecodeTo(v, &e); err != nil {
+						return
 					}
+					switch e.Topic {
+					case environment.ResourceEvent:
+						{
+							var stats struct {
+								Topic string
+								Data  environment.Stats
+							}
+							if err := events.DecodeTo(v, &stats); err != nil {
+								s.Log().WithField("error", err).Warn("failed to decode server resource event")
+								return
+							}
+							s.resources.UpdateStats(stats.Data)
+							// If there is no disk space available at this point, trigger the server
+							// disk limiter logic which will start to stop the running instance.
+							if !s.Filesystem().HasSpaceAvailable(true) {
+								limit.Trigger()
+							}
+							s.Events().Publish(StatsEvent, s.Proc())
+						}
+					case environment.StateChangeEvent:
+						{
+							// Reset the throttler when the process is started.
+							if e.Data == environment.ProcessStartingState {
+								limit.Reset()
+								s.Throttler().Reset()
+							}
+							s.OnStateChange()
+						}
+					case environment.DockerImagePullStatus:
+						s.Events().Publish(InstallOutputEvent, e.Data)
+					case environment.DockerImagePullStarted:
+						s.PublishConsoleOutputFromDaemon("Pulling Docker container image, this could take a few minutes to complete...")
+					case environment.DockerImagePullCompleted:
+						s.PublishConsoleOutputFromDaemon("Finished pulling Docker container image")
+					default:
+					}
+				}(v, limit)
+			case <-s.Context().Done():
+				return
+			}
+		}
+	}()
 }
 
 var stripAnsiRegex = regexp.MustCompile("[\u001B\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))")
 
 // Custom listener for console output events that will check if the given line
 // of output matches one that should mark the server as started or not.
-func (s *Server) onConsoleOutput(data string) {
-	// Get the server's process configuration.
+func (s *Server) onConsoleOutput(data []byte) {
+	if s.Environment.State() != environment.ProcessStartingState && !s.IsRunning() {
+		return
+	}
+
 	processConfiguration := s.ProcessConfiguration()
 
+	// Make a copy of the data provided since it is by reference, otherwise you'll
+	// potentially introduce a race condition by modifying the value.
+	v := make([]byte, len(data))
+	copy(v, data)
+
 	// Check if the server is currently starting.
 	if s.Environment.State() == environment.ProcessStartingState {
 		// Check if we should strip ansi color codes.
 		if processConfiguration.Startup.StripAnsi {
-			// Strip ansi color codes from the data string.
-			data = stripAnsiRegex.ReplaceAllString(data, "")
+			v = stripAnsiRegex.ReplaceAll(v, []byte(""))
 		}
 
 		// Iterate over all the done lines.
 		for _, l := range processConfiguration.Startup.Done {
-			if !l.Matches(data) {
+			if !l.Matches(v) {
 				continue
 			}
 
 			s.Log().WithFields(log.Fields{
 				"match":   l.String(),
-				"against": strconv.QuoteToASCII(data),
+				"against": strconv.QuoteToASCII(string(v)),
 			}).Debug("detected server in running state based on console line output")
 
 			// If the specific line of output is one that would mark the server as started,
@@ -186,7 +189,7 @@ func (s *Server) onConsoleOutput(data string) {
 	if s.IsRunning() {
 		stop := processConfiguration.Stop
 
-		if stop.Type == remote.ProcessStopCommand && data == stop.Value {
+		if stop.Type == remote.ProcessStopCommand && bytes.Equal(v, []byte(stop.Value)) {
 			s.Environment.SetState(environment.ProcessOfflineState)
 		}
 	}

server/manager.go

@@ -2,10 +2,8 @@ package server
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -15,6 +13,8 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gammazero/workerpool"
+	"github.com/goccy/go-json"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
@@ -28,9 +28,9 @@ type Manager struct {
 	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.
+// NewManager returns a new server manager instance. This will boot up all 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 {
@@ -52,7 +52,7 @@ func (m *Manager) Client() remote.Client {
 	return m.client
 }
 
-// Put replaces all of the current values in the collection with the value that
+// Put replaces all the current values in the collection with the value that
 // is passed through.
 func (m *Manager) Put(s []*Server) {
 	m.mu.Lock()
@@ -60,7 +60,7 @@ func (m *Manager) Put(s []*Server) {
 	m.mu.Unlock()
 }
 
-// All returns all of the items in the collection.
+// All returns all the items in the collection.
 func (m *Manager) All() []*Server {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -78,7 +78,7 @@ func (m *Manager) Add(s *Server) {
 // 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 server.ID() == uuid
 	})
 	return match, match != nil
 }
@@ -130,13 +130,13 @@ func (m *Manager) Remove(filter func(match *Server) bool) {
 func (m *Manager) PersistStates() error {
 	states := map[string]string{}
 	for _, s := range m.All() {
-		states[s.Id()] = s.Environment.State()
+		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 {
+	if err := os.WriteFile(config.Get().System.GetStatesPath(), data, 0o644); err != nil {
 		return errors.WithStack(err)
 	}
 	return nil
@@ -144,7 +144,7 @@ func (m *Manager) PersistStates() error {
 
 // 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)
+	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0o644)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -171,15 +171,18 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 	if err != nil {
 		return nil, err
 	}
-	if err := s.UpdateDataStructure(data.Settings); err != nil {
-		return nil, err
+
+	// Setup the base server configuration data which will be used for all of the
+	// remaining functionality in this call.
+	if err := s.SyncWithConfiguration(data); err != nil {
+		return nil, errors.WithStackIf(err)
 	}
 
-	s.fs = filesystem.New(filepath.Join(config.Get().System.Data, s.Id()), s.DiskSpace(), s.Config().Egg.FileDenylist)
+	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.
+	// some modifications here, obviously.
 	settings := environment.Settings{
 		Mounts:      s.Mounts(),
 		Allocations: s.cfg.Allocations,
@@ -191,17 +194,11 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 		Image: s.Config().Container.Image,
 	}
 
-	if env, err := docker.New(s.Id(), &meta, envCfg); err != nil {
+	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.
@@ -212,7 +209,7 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 	return s, nil
 }
 
-// initializeFromRemoteSource iterates over a given directory and loads all of
+// initializeFromRemoteSource iterates over a given directory and loads all
 // 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")
@@ -252,7 +249,7 @@ func (m *Manager) init(ctx context.Context) error {
 		})
 	}
 
-	// Wait until we've processed all of the configuration files in the directory
+	// Wait until we've processed all the configuration files in the directory
 	// before continuing.
 	pool.StopWait()
 

server/mounts.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/apex/log"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 )

server/power.go

@@ -2,13 +2,14 @@ package server
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"time"
 
 	"emperror.dev/errors"
+	"github.com/google/uuid"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
-	"golang.org/x/sync/semaphore"
 )
 
 type PowerAction string
@@ -18,7 +19,7 @@ type PowerAction string
 // example, sending two "start" actions back to back will not process the second action until
 // the first action has been completed.
 //
-// This utilizes a workerpool with a limit of one worker so that all of the actions execute
+// This utilizes a workerpool with a limit of one worker so that all the actions execute
 // in a sync manner.
 const (
 	PowerActionStart     = "start"
@@ -27,7 +28,7 @@ const (
 	PowerActionTerminate = "kill"
 )
 
-// Checks if the power action being received is valid.
+// IsValid checks if the power action being received is valid.
 func (pa PowerAction) IsValid() bool {
 	return pa == PowerActionStart ||
 		pa == PowerActionStop ||
@@ -39,45 +40,43 @@ func (pa PowerAction) IsStart() bool {
 	return pa == PowerActionStart || pa == PowerActionRestart
 }
 
-// Check if there is currently a power action being processed for the server.
+// ExecutingPowerAction checks if there is currently a power action being
+// processed for the server.
 func (s *Server) ExecutingPowerAction() bool {
-	if s.powerLock == nil {
-		return false
+	return s.powerLock.IsLocked()
 }
 
-	ok := s.powerLock.TryAcquire(1)
-	if ok {
-		s.powerLock.Release(1)
-	}
-
-	// Remember, if we acquired a lock it means nothing was running.
-	return !ok
-}
-
-// Helper function that can receive a power action and then process the actions that need
-// to occur for it. This guards against someone calling Start() twice at the same time, or
-// trying to restart while another restart process is currently running.
+// HandlePowerAction is a helper function that can receive a power action and then process the
+// actions that need to occur for it. This guards against someone calling Start() twice at the
+// same time, or trying to restart while another restart process is currently running.
 //
 // However, the code design for the daemon does depend on the user correctly calling this
 // function rather than making direct calls to the start/stop/restart functions on the
 // environment struct.
 func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error {
-	if s.IsInstalling() {
+	if s.IsInstalling() || s.IsTransferring() || s.IsRestoring() {
+		if s.IsRestoring() {
+			return ErrServerIsRestoring
+		} else if s.IsTransferring() {
+			return ErrServerIsTransferring
+		}
 		return ErrServerIsInstalling
 	}
 
-	if s.IsTransferring() {
-		return ErrServerIsTransferring
+	lockId, _ := uuid.NewUUID()
+	log := s.Log().WithField("lock_id", lockId.String()).WithField("action", action)
+
+	cleanup := func() {
+		log.Info("releasing exclusive lock for power action")
+		s.powerLock.Release()
 	}
 
-	if s.IsRestoring() {
-		return ErrServerIsRestoring
-	}
-
-	if s.powerLock == nil {
-		s.powerLock = semaphore.NewWeighted(1)
+	var wait int
+	if len(waitSeconds) > 0 && waitSeconds[0] > 0 {
+		wait = waitSeconds[0]
 	}
 
+	log.WithField("wait_seconds", wait).Debug("acquiring power action lock for instance")
 	// Only attempt to acquire a lock on the process if this is not a termination event. We want to
 	// just allow those events to pass right through for good reason. If a server is currently trying
 	// to process a power action but has gotten stuck you still should be able to pass through the
@@ -86,33 +85,38 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 	if action != PowerActionTerminate {
 		// 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, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(waitSeconds[0]))
+		if wait > 0 {
+			ctx, cancel := context.WithTimeout(s.ctx, time.Second*time.Duration(wait))
 			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.
-			if err := s.powerLock.Acquire(ctx, 1); err != nil {
-				return errors.WithMessage(err, "could not acquire lock on power state")
+			if err := s.powerLock.TryAcquire(ctx); err != nil {
+				return errors.Wrap(err, fmt.Sprintf("could not acquire lock on power action after %d seconds", wait))
 			}
 		} else {
 			// If no wait duration was provided we will attempt to immediately acquire the lock
 			// and bail out with a context deadline error if it is not acquired immediately.
-			if ok := s.powerLock.TryAcquire(1); !ok {
-				return errors.WithMessage(context.DeadlineExceeded, "could not acquire lock on power state")
+			if err := s.powerLock.Acquire(); err != nil {
+				return errors.Wrap(err, "failed to acquire exclusive lock for power actions")
 			}
 		}
 
-		// Release the lock once the process being requested has finished executing.
-		defer s.powerLock.Release(1)
+		log.Info("acquired exclusive lock on power actions, processing event...")
+		defer cleanup()
 	} else {
-		// Still try to acquire the lock if terminating and it is available, just so that other power
-		// actions are blocked until it has completed. However, if it is unavailable we won't stop
-		// the entire process.
-		if ok := s.powerLock.TryAcquire(1); ok {
-			// If we managed to acquire the lock be sure to released it once this process is completed.
-			defer s.powerLock.Release(1)
+		// Still try to acquire the lock if terminating, and it is available, just so that
+		// other power actions are blocked until it has completed. However, if it cannot be
+		// acquired we won't stop the entire process.
+		//
+		// If we did successfully acquire the lock, make sure we release it once we're done
+		// executiong the power actions.
+		if err := s.powerLock.Acquire(); err == nil {
+			log.Info("acquired exclusive lock on power actions, processing event...")
+			defer cleanup()
+		} else {
+			log.Warn("failed to acquire exclusive lock, ignoring failure for termination event")
 		}
 	}
 
@@ -127,13 +131,13 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 			return err
 		}
 
-		return s.Environment.Start()
+		return s.Environment.Start(s.Context())
 	case PowerActionStop:
-		// We're specifically waiting for the process to be stopped here, otherwise the lock is released
-		// too soon, and you can rack up all sorts of issues.
-		return s.Environment.WaitForStop(10*60, true)
+		fallthrough
 	case PowerActionRestart:
-		if err := s.Environment.WaitForStop(10*60, true); err != nil {
+		// We're specifically waiting for the process to be stopped here, otherwise the lock is
+		// released too soon, and you can rack up all sorts of issues.
+		if err := s.Environment.WaitForStop(s.Context(), time.Minute*10, true); err != nil {
 			// Even timeout errors should be bubbled back up the stack. If the process didn't stop
 			// nicely, but the terminate argument was passed then the server is stopped without an
 			// error being returned.
@@ -145,14 +149,18 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 			return err
 		}
 
+		if action == PowerActionStop {
+			return nil
+		}
+
 		// Now actually try to start the process by executing the normal pre-boot logic.
 		if err := s.onBeforeStart(); err != nil {
 			return err
 		}
 
-		return s.Environment.Start()
+		return s.Environment.Start(s.Context())
 	case PowerActionTerminate:
-		return s.Environment.Terminate(os.Kill)
+		return s.Environment.Terminate(s.Context(), os.Kill)
 	}
 
 	return errors.New("attempting to handle unknown power action")
@@ -190,18 +198,22 @@ func (s *Server) onBeforeStart() error {
 	// Update the configuration files defined for the server before beginning the boot process.
 	// This process executes a bunch of parallel updates, so we just block until that process
 	// is complete. Any errors as a result of this will just be bubbled out in the logger,
-	// we don't need to actively do anything about it at this point, worst comes to worst the
+	// we don't need to actively do anything about it at this point, worse comes to worst the
 	// server starts in a weird state and the user can manually adjust.
 	s.PublishConsoleOutputFromDaemon("Updating process configuration files...")
+	s.Log().Debug("updating server configuration files...")
 	s.UpdateConfigurationFiles()
+	s.Log().Debug("updated server configuration files")
 
 	if config.Get().System.CheckPermissionsOnBoot {
 		s.PublishConsoleOutputFromDaemon("Ensuring file permissions are set correctly, this could take a few seconds...")
-		// Ensure all of the server file permissions are set correctly before booting the process.
+		// Ensure all the server file permissions are set correctly before booting the process.
+		s.Log().Debug("chowning server root directory...")
 		if err := s.Filesystem().Chown("/"); err != nil {
 			return errors.WithMessage(err, "failed to chown root server directory during pre-boot process")
 		}
 	}
 
+	s.Log().Info("completed server preflight, starting boot process...")
 	return nil
 }

server/power_test.go

@@ -0,0 +1,22 @@
+package server
+
+import (
+	"testing"
+
+	. "github.com/franela/goblin"
+	"github.com/pterodactyl/wings/system"
+)
+
+func TestPower(t *testing.T) {
+	g := Goblin(t)
+
+	g.Describe("Server#ExecutingPowerAction", func() {
+		g.It("should return based on locker status", func() {
+			s := &Server{powerLock: system.NewLocker()}
+
+			g.Assert(s.ExecutingPowerAction()).IsFalse()
+			s.powerLock.Acquire()
+			g.Assert(s.ExecutingPowerAction()).IsTrue()
+		})
+	})
+}

server/resources.go

@@ -8,7 +8,7 @@ import (
 	"github.com/pterodactyl/wings/system"
 )
 
-// Defines the current resource usage for a given server instance. If a server is offline you
+// ResourceUsage defines the current resource usage for a given server instance. If a server is offline you
 // should obviously expect memory and CPU usage to be 0. However, disk will always be returned
 // since that is not dependent on the server being running to collect that data.
 type ResourceUsage struct {
@@ -26,7 +26,7 @@ type ResourceUsage struct {
 	Disk int64 `json:"disk_bytes"`
 }
 
-// Returns the current resource usage stats for the server instance. This returns
+// Proc returns the current resource usage stats for the server instance. This returns
 // a copy of the tracked resources, so making any changes to the response will not
 // have the desired outcome for you most likely.
 func (s *Server) Proc() ResourceUsage {
@@ -38,19 +38,22 @@ func (s *Server) Proc() ResourceUsage {
 	return s.resources
 }
 
-// Resets the usages values to zero, used when a server is stopped to ensure we don't hold
+// UpdateStats updates the current stats for the server's resource usage.
+func (ru *ResourceUsage) UpdateStats(stats environment.Stats) {
+	ru.mu.Lock()
+	ru.Stats = stats
+	ru.mu.Unlock()
+}
+
+// Reset resets the usages values to zero, used when a server is stopped to ensure we don't hold
 // onto any values incorrectly.
 func (ru *ResourceUsage) Reset() {
 	ru.mu.Lock()
 	defer ru.mu.Unlock()
+
 	ru.Memory = 0
 	ru.CpuAbsolute = 0
+	ru.Uptime = 0
 	ru.Network.TxBytes = 0
 	ru.Network.RxBytes = 0
 }
-
-func (s *Server) emitProcUsage() {
-	if err := s.Events().PublishJson(StatsEvent, s.Proc()); err != nil {
-		s.Log().WithField("error", err).Warn("error while emitting server resource usage to listeners")
-	}
-}

server/server.go

@@ -3,6 +3,7 @@ package server
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"os"
 	"strings"
 	"sync"
@@ -10,14 +11,14 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/creasty/defaults"
+	"github.com/goccy/go-json"
+
 	"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"
 )
 
 // Server is the high level definition for a server instance being controlled
@@ -30,8 +31,7 @@ type Server struct {
 	ctxCancel *context.CancelFunc
 
 	emitterLock sync.Mutex
-	powerLock    *semaphore.Weighted
-	throttleOnce sync.Once
+	powerLock   *system.Locker
 
 	// Maintains the configuration for the server. This is the data that gets returned by the Panel
 	// such as build settings and container images.
@@ -47,7 +47,7 @@ type Server struct {
 	fs *filesystem.Filesystem
 
 	// Events emitted by the server instance.
-	emitter *events.EventBus
+	emitter *events.Bus
 
 	// Defines the process configuration for the server instance. This is dynamically
 	// fetched from the Pterodactyl Server instance each time the server process is
@@ -63,11 +63,17 @@ type Server struct {
 	restoring    *system.AtomicBool
 
 	// The console throttler instance used to control outputs.
-	throttler *ConsoleThrottler
+	throttler    *ConsoleThrottle
+	throttleOnce sync.Once
 
 	// Tracks open websocket connections for the server.
 	wsBag       *WebsocketBag
 	wsBagLocker sync.Mutex
+
+	sinks map[system.SinkName]*system.SinkPool
+
+	logSink     *system.SinkPool
+	installSink *system.SinkPool
 }
 
 // New returns a new server instance with a context and all of the default
@@ -81,6 +87,11 @@ func New(client remote.Client) (*Server, error) {
 		installing:   system.NewAtomicBool(false),
 		transferring: system.NewAtomicBool(false),
 		restoring:    system.NewAtomicBool(false),
+		powerLock:    system.NewLocker(),
+		sinks: map[system.SinkName]*system.SinkPool{
+			system.LogSink:     system.NewSinkPool(),
+			system.InstallSink: system.NewSinkPool(),
+		},
 	}
 	if err := defaults.Set(&s); err != nil {
 		return nil, errors.Wrap(err, "server: could not set default values for struct")
@@ -92,11 +103,30 @@ func New(client remote.Client) (*Server, error) {
 	return &s, nil
 }
 
-// Id returns the UUID for the server instance.
-func (s *Server) Id() string {
+// CleanupForDestroy stops all running background tasks for this server that are
+// using the context on the server struct. This will cancel any running install
+// processes for the server as well.
+func (s *Server) CleanupForDestroy() {
+	s.CtxCancel()
+	s.Events().Destroy()
+	s.DestroyAllSinks()
+	s.Websockets().CancelAll()
+	s.powerLock.Destroy()
+}
+
+// ID returns the UUID for the server instance.
+func (s *Server) ID() string {
 	return s.Config().GetUuid()
 }
 
+// Id returns the UUID for the server instance. This function is deprecated
+// in favor of Server.ID().
+//
+// Deprecated
+func (s *Server) Id() string {
+	return s.ID()
+}
+
 // Cancels the context assigned to this server instance. Assuming background tasks
 // are using this server's context for things, all of the background tasks will be
 // stopped as a result.
@@ -128,7 +158,7 @@ eloop:
 	for k := range s.Config().EnvVars {
 		// Don't allow any environment variables that we have already set above.
 		for _, e := range out {
-			if strings.HasPrefix(e, strings.ToUpper(k)) {
+			if strings.HasPrefix(e, strings.ToUpper(k)+"=") {
 				continue eloop
 			}
 		}
@@ -140,54 +170,67 @@ eloop:
 }
 
 func (s *Server) Log() *log.Entry {
-	return log.WithField("server", s.Id())
+	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 := s.client.GetServerConfiguration(s.Context(), s.Id())
+	cfg, err := s.client.GetServerConfiguration(s.Context(), s.ID())
 	if err != nil {
-		if !remote.IsRequestError(err) {
-			return err
-		}
-
-		if err.(*remote.RequestError).Status == "404" {
+		if err := remote.AsRequestError(err); err != nil && err.StatusCode() == http.StatusNotFound {
 			return &serverDoesNotExist{}
 		}
-
-		return errors.New(err.Error())
+		return errors.WithStackIf(err)
 	}
 
-	return s.SyncWithConfiguration(cfg)
+	if err := s.SyncWithConfiguration(cfg); err != nil {
+		return errors.WithStackIf(err)
 	}
 
+	// Update the disk space limits for the server whenever the configuration for
+	// it changes.
+	s.fs.SetDiskLimit(s.DiskSpace())
+
+	s.SyncWithEnvironment()
+
+	return nil
+}
+
+// SyncWithConfiguration accepts a configuration object for a server and will
+// sync all of the values with the existing server state. This only replaces the
+// existing configuration and process configuration for the server. The
+// underlying environment will not be affected. This is because this function
+// can be called from scoped where the server may not be fully initialized,
+// therefore other things like the filesystem and environment may not exist yet.
 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
+	c := Configuration{
+		CrashDetectionEnabled: config.Get().System.CrashDetection.CrashDetectionEnabled,
 	}
+	if err := json.Unmarshal(cfg.Settings, &c); err != nil {
+		return errors.WithStackIf(err)
+	}
+
+	s.cfg.mu.Lock()
+	defer s.cfg.mu.Unlock()
+
+	// Lock the new configuration. Since we have the deferred Unlock above we need
+	// to make sure that the NEW configuration object is already locked since that
+	// defer is running on the memory address for "s.cfg.mu" which we're explicitly
+	// changing on the next line.
+	c.mu.Lock()
+
+	//goland:noinspection GoVetCopyLock
+	s.cfg = c
 
 	s.Lock()
 	s.procConfig = cfg.ProcessConfiguration
 	s.Unlock()
 
-	// Update the disk space limits for the server whenever the configuration
-	// for it changes.
-	s.fs.SetDiskLimit(s.DiskSpace())
-
-	// If this is a Docker environment we need to sync the stop configuration with it so that
-	// the process isn't just terminated when a user requests it be stopped.
-	if e, ok := s.Environment.(*docker.Environment); ok {
-		s.Log().Debug("syncing stop configuration with configured docker environment")
-		e.SetImage(s.Config().Container.Image)
-		e.SetStopConfiguration(cfg.ProcessConfiguration.Stop)
-	}
-
 	return nil
 }
 
@@ -196,14 +239,6 @@ func (s *Server) ReadLogfile(len int) ([]string, error) {
 	return s.Environment.Readlog(len)
 }
 
-// Determine if the server is bootable in it's current state or not. This will not
-// indicate why a server is not bootable, only if it is.
-func (s *Server) IsBootable() bool {
-	exists, _ := s.Environment.Exists()
-
-	return exists
-}
-
 // Initializes a server instance. This will run through and ensure that the environment
 // for the server is setup, and that all of the necessary files are created.
 func (s *Server) CreateEnvironment() error {
@@ -238,7 +273,7 @@ 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 {
+			if err := os.MkdirAll(s.fs.Path(), 0o700); err != nil {
 				return errors.WithStack(err)
 			}
 			if err := s.fs.Chown("/"); err != nil {
@@ -251,7 +286,7 @@ func (s *Server) EnsureDataDirectoryExists() error {
 	return nil
 }
 
-// Sets the state of the server internally. This function handles crash detection as
+// OnStateChange 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()
@@ -266,11 +301,11 @@ func (s *Server) OnStateChange() {
 		s.Events().Publish(StatusEvent, st)
 	}
 
-	// Reset the resource usage to 0 when the process fully stops so that all of the UI
+	// Reset the resource usage to 0 when the process fully stops so that all the UI
 	// views in the Panel correctly display 0.
 	if st == environment.ProcessOfflineState {
 		s.resources.Reset()
-		s.emitProcUsage()
+		s.Events().Publish(StatsEvent, s.Proc())
 	}
 
 	// If server was in an online state, and is now in an offline state we should handle
@@ -298,10 +333,31 @@ func (s *Server) OnStateChange() {
 }
 
 // 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
+// from 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/update.go

@@ -1,127 +1,43 @@
 package server
 
 import (
-	"encoding/json"
+	"time"
+
+	"github.com/pterodactyl/wings/environment/docker"
 
-	"emperror.dev/errors"
-	"github.com/buger/jsonparser"
-	"github.com/imdario/mergo"
 	"github.com/pterodactyl/wings/environment"
 )
 
-// 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.
+// SyncWithEnvironment updates the environment for the server to match any of
+// the changed data. This pushes new settings and environment variables to the
+// environment. In addition, the in-situ update method is called on the
+// environment which will allow environments that make use of it (such as Docker)
+// to immediately apply some settings without having to wait on a server to
+// restart.
 //
-// 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
-// that is the case.
-func (s *Server) UpdateDataStructure(data []byte) error {
-	src := new(Configuration)
-	if err := json.Unmarshal(data, src); err != nil {
-		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("server/update: attempting to merge a data stack with an invalid UUID")
-	}
-
-	// Grab a copy of the configuration to work on.
-	c := *s.Config()
-
-	// Lock our copy of the configuration since the deferred unlock will end up acting upon this
-	// new memory address rather than the old one. If we don't lock this, the deferred unlock will
-	// cause a panic when it goes to run. However, since we only update s.cfg at the end, if there
-	// is an error before that point we'll still properly unlock the original configuration for the
-	// server.
-	c.mu.Lock()
-
-	// Lock the server configuration while we're doing this merge to avoid anything
-	// trying to overwrite it or make modifications while we're sorting out what we
-	// need to do.
-	s.cfg.mu.Lock()
-	defer s.cfg.mu.Unlock()
-
-	// 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 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...
-	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 errors.WithStack(err)
-		}
-	} else {
-		c.Build.OOMDisabled = v
-	}
-
-	// Mergo also cannot handle this boolean value.
-	if v, err := jsonparser.GetBoolean(data, "suspended"); err != nil {
-		if err != jsonparser.KeyPathNotFoundError {
-			return errors.WithStack(err)
-		}
-	} else {
-		c.Suspended = v
-	}
-
-	if v, err := jsonparser.GetBoolean(data, "skip_egg_scripts"); err != nil {
-		if err != jsonparser.KeyPathNotFoundError {
-			return errors.WithStack(err)
-		}
-	} else {
-		c.SkipEggScripts = v
-	}
-
-	// Environment and Mappings should be treated as a full update at all times, never a
-	// true patch, otherwise we can't know what we're passing along.
-	if src.EnvVars != nil && len(src.EnvVars) > 0 {
-		c.EnvVars = src.EnvVars
-	}
-
-	if src.Allocations.Mappings != nil && len(src.Allocations.Mappings) > 0 {
-		c.Allocations.Mappings = src.Allocations.Mappings
-	}
-
-	if src.Mounts != nil && len(src.Mounts) > 0 {
-		c.Mounts = src.Mounts
-	}
-
-	// Update the configuration once we have a lock on the configuration object.
-	s.cfg = c
-
-	return nil
-}
-
-// Updates the environment for the server to match any of the changed data. This pushes new settings and
-// environment variables to the environment. In addition, the in-situ update method is called on the
-// environment which will allow environments that make use of it (such as Docker) to immediately apply
-// some settings without having to wait on a server to restart.
-//
-// This functionality allows a server's resources limits to be modified on the fly and have them apply
-// right away allowing for dynamic resource allocation and responses to abusive server processes.
+// This functionality allows a server's resources limits to be modified on the
+// fly and have them apply right away allowing for dynamic resource allocation
+// and responses to abusive server processes.
 func (s *Server) SyncWithEnvironment() {
 	s.Log().Debug("syncing server settings with environment")
 
+	cfg := s.Config()
+
 	// Update the environment settings using the new information from this server.
 	s.Environment.Config().SetSettings(environment.Settings{
 		Mounts:      s.Mounts(),
-		Allocations: s.Config().Allocations,
-		Limits:      s.Config().Build,
+		Allocations: cfg.Allocations,
+		Limits:      cfg.Build,
 	})
 
+	// For Docker specific environments we also want to update the configured image
+	// and stop configuration.
+	if e, ok := s.Environment.(*docker.Environment); ok {
+		s.Log().Debug("syncing stop configuration with configured docker environment")
+		e.SetImage(cfg.Container.Image)
+		e.SetStopConfiguration(s.ProcessConfiguration().Stop)
+	}
+
 	// If build limits are changed, environment variables also change. Plus, any modifications to
 	// the startup command also need to be properly propagated to this environment.
 	//
@@ -144,7 +60,7 @@ func (s *Server) SyncWithEnvironment() {
 			s.Log().Info("server suspended with running process state, terminating now")
 
 			go func(s *Server) {
-				if err := s.Environment.WaitForStop(60, true); err != nil {
+				if err := s.Environment.WaitForStop(s.Context(), time.Minute, true); err != nil {
 					s.Log().WithField("error", err).Warn("failed to terminate server environment after suspension")
 				}
 			}(s)

server/websockets.go

@@ -12,7 +12,7 @@ type WebsocketBag struct {
 	conns map[uuid.UUID]*context.CancelFunc
 }
 
-// Returns the websocket bag which contains all of the currently open websocket connections
+// Websockets returns the websocket bag which contains all the currently open websocket connections
 // for the server instance.
 func (s *Server) Websockets() *WebsocketBag {
 	s.wsBagLocker.Lock()
@@ -25,7 +25,7 @@ func (s *Server) Websockets() *WebsocketBag {
 	return s.wsBag
 }
 
-// Adds a new websocket connection to the stack.
+// Push adds a new websocket connection to the end of the stack.
 func (w *WebsocketBag) Push(u uuid.UUID, cancel *context.CancelFunc) {
 	w.mu.Lock()
 	defer w.mu.Unlock()
@@ -37,23 +37,22 @@ func (w *WebsocketBag) Push(u uuid.UUID, cancel *context.CancelFunc) {
 	w.conns[u] = cancel
 }
 
-// Removes a connection from the stack.
+// Remove removes a connection from the stack.
 func (w *WebsocketBag) Remove(u uuid.UUID) {
 	w.mu.Lock()
 	delete(w.conns, u)
 	w.mu.Unlock()
 }
 
-// Cancels all of the stored cancel functions which has the effect of disconnecting
-// every listening websocket for the server.
+// CancelAll cancels all the stored cancel functions which has the effect of
+// disconnecting every listening websocket for the server.
 func (w *WebsocketBag) CancelAll() {
 	w.mu.Lock()
-	w.mu.Unlock()
+	defer w.mu.Unlock()
 
 	if w.conns != nil {
 		for _, cancel := range w.conns {
-			c := *cancel
-			c()
+			(*cancel)()
 		}
 	}
 

sftp/handler.go

@@ -11,9 +11,11 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/pkg/sftp"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server/filesystem"
 	"golang.org/x/crypto/ssh"
+
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server/filesystem"
 )
 
 const (
@@ -25,8 +27,10 @@ const (
 )
 
 type Handler struct {
-	permissions []string
 	mu sync.Mutex
+
+	permissions []string
+	server      *server.Server
 	fs          *filesystem.Filesystem
 	logger      *log.Entry
 	ro          bool
@@ -34,11 +38,12 @@ type Handler struct {
 
 // 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 {
+func NewHandler(sc *ssh.ServerConn, srv *server.Server) *Handler {
 	return &Handler{
-		fs:          fs,
-		ro:          config.Get().System.Sftp.ReadOnly,
 		permissions: strings.Split(sc.Permissions.Extensions["permissions"], ","),
+		server:      srv,
+		fs:          srv.Filesystem(),
+		ro:          config.Get().System.Sftp.ReadOnly,
 		logger: log.WithFields(log.Fields{
 			"subsystem": "sftp",
 			"username":  sc.User(),
@@ -114,10 +119,13 @@ func (h *Handler) Filewrite(request *sftp.Request) (io.WriterAt, error) {
 		l.WithField("flags", request.Flags).WithField("error", err).Error("failed to open existing file on system")
 		return nil, sftp.ErrSSHFxFailure
 	}
+	// Chown may or may not have been called in the touch function, so always do
+	// it at this point to avoid the file being improperly owned.
+	_ = h.server.Filesystem().Chown(request.Filepath)
 	return f, nil
 }
 
-// Filecmd hander for basic SFTP system calls related to files, but not anything to do with reading
+// Filecmd handler for basic SFTP system calls related to files, but not anything to do with reading
 // or writing to those files.
 func (h *Handler) Filecmd(request *sftp.Request) error {
 	if h.ro {
@@ -137,12 +145,12 @@ func (h *Handler) Filecmd(request *sftp.Request) error {
 		}
 		mode := request.Attributes().FileMode().Perm()
 		// If the client passes an invalid FileMode just use the default 0644.
-		if mode == 0000 {
-			mode = os.FileMode(0644)
+		if mode == 0o000 {
+			mode = os.FileMode(0o644)
 		}
 		// Force directories to be 0755.
 		if request.Attributes().FileMode().IsDir() {
-			mode = 0755
+			mode = 0o755
 		}
 		if err := h.fs.Chmod(request.Filepath, mode); err != nil {
 			if errors.Is(err, os.ErrNotExist) {
@@ -255,7 +263,6 @@ func (h *Handler) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
 		files, err := ioutil.ReadDir(p)
 		if err != nil {
 			h.logger.WithField("source", request.Filepath).WithField("error", err).Error("error while listing directory")
-
 			return nil, sftp.ErrSSHFxFailure
 		}
 		return ListerAt(files), nil
@@ -277,6 +284,10 @@ func (h *Handler) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
 // 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 (h *Handler) can(permission string) bool {
+	if h.server.IsSuspended() {
+		return false
+	}
+
 	// 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.

sftp/server.go

@@ -1,7 +1,11 @@
 package sftp
 
 import (
+	"bytes"
 	"context"
+	"crypto/ecdsa"
+	"crypto/ed25519"
+	"crypto/elliptic"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/x509"
@@ -18,10 +22,11 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/pkg/sftp"
+	"golang.org/x/crypto/ssh"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
-	"golang.org/x/crypto/ssh"
 )
 
 // Usernames all follow the same format, so don't even bother hitting the API if the username is not
@@ -47,20 +52,11 @@ func New(m *server.Manager) *SFTPServer {
 	}
 }
 
-// Starts the SFTP server and add a persistent listener to handle inbound SFTP connections.
+// Run starts the SFTP server and add a persistent listener to handle inbound
+// SFTP connections. This will automatically generate an ED25519 key if one does
+// not already exist on the system for host key verification purposes.
 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 errors.Wrap(err, "sftp/server: could not stat private key file")
-	}
-	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)
+	keys, err := c.loadPrivateKeys()
 	if err != nil {
 		return err
 	}
@@ -69,8 +65,12 @@ func (c *SFTPServer) Run() error {
 		NoClientAuth:      false,
 		MaxAuthTries:      6,
 		PasswordCallback:  c.passwordCallback,
+		PublicKeyCallback: c.publicKeyCallback,
+	}
+
+	for _, k := range keys {
+		conf.AddHostKey(k)
 	}
-	conf.AddHostKey(private)
 
 	listener, err := net.Listen("tcp", c.Listen)
 	if err != nil {
@@ -103,7 +103,7 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 		// If its not a session channel we just move on because its not something we
 		// know how to handle at this point.
 		if ch.ChannelType() != "session" {
-			ch.Reject(ssh.UnknownChannelType, "unknown channel type")
+			_ = ch.Reject(ssh.UnknownChannelType, "unknown channel type")
 			continue
 		}
 
@@ -117,7 +117,7 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 				// 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)
+				_ = req.Reply(req.Type == "subsystem" && string(req.Payload[4:]) == "sftp", nil)
 			}
 		}(requests)
 
@@ -132,41 +132,169 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 			if uuid == "" {
 				return false
 			}
-			return s.Id() == uuid
+			return s.ID() == uuid
 		})
 		if srv == nil {
+			_ = conn.Close()
 			continue
 		}
 
 		// 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())
+		handler := sftp.NewRequestServer(channel, NewHandler(sconn, srv).Handlers())
 		if err := handler.Serve(); err == io.EOF {
-			handler.Close()
+			_ = handler.Close()
 		}
 	}
 }
 
-// Generates a private key that will be used by the SFTP server.
-func (c *SFTPServer) generatePrivateKey() error {
-	key, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return errors.WithStack(err)
+func (c *SFTPServer) loadPrivateKeys() ([]ssh.Signer, error) {
+	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_rsa")); err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
 		}
-	if err := os.MkdirAll(path.Join(c.BasePath, ".sftp"), 0755); err != nil {
+
+		if err := c.generateRSAPrivateKey(); err != nil {
+			return nil, err
+		}
+	}
+	rsaBytes, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_rsa"))
+	if err != nil {
+		return nil, errors.Wrap(err, "sftp/server: could not read private key file")
+	}
+	rsaPrivateKey, err := ssh.ParsePrivateKey(rsaBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_ecdsa")); err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+
+		if err := c.generateECDSAPrivateKey(); err != nil {
+			return nil, err
+		}
+	}
+	ecdsaBytes, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_ecdsa"))
+	if err != nil {
+		return nil, errors.Wrap(err, "sftp/server: could not read private key file")
+	}
+	ecdsaPrivateKey, err := ssh.ParsePrivateKey(ecdsaBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_ed25519")); err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+
+		if err := c.generateEd25519PrivateKey(); err != nil {
+			return nil, err
+		}
+	}
+	ed25519Bytes, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_ed25519"))
+	if err != nil {
+		return nil, errors.Wrap(err, "sftp/server: could not read private key file")
+	}
+	ed25519PrivateKey, err := ssh.ParsePrivateKey(ed25519Bytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return []ssh.Signer{
+		rsaPrivateKey,
+		ecdsaPrivateKey,
+		ed25519PrivateKey,
+	}, nil
+}
+
+// generateRSAPrivateKey generates a RSA-4096 private key that will be used by the SFTP server.
+func (c *SFTPServer) generateRSAPrivateKey() error {
+	key, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(path.Dir(c.PrivateKeyPath("rsa")), 0o755); err != nil {
 		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
 	}
-	o, err := os.OpenFile(path.Join(c.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	o, err := os.OpenFile(c.PrivateKeyPath("rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
-		return errors.WithStack(err)
+		return err
 	}
 	defer o.Close()
 
-	err = pem.Encode(o, &pem.Block{
+	if err := pem.Encode(o, &pem.Block{
 		Type:  "RSA PRIVATE KEY",
 		Bytes: x509.MarshalPKCS1PrivateKey(key),
-	})
-	return errors.WithStack(err)
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+
+// generateECDSAPrivateKey generates a ECDSA-P256 private key that will be used by the SFTP server.
+func (c *SFTPServer) generateECDSAPrivateKey() error {
+	key, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(path.Dir(c.PrivateKeyPath("ecdsa")), 0o755); err != nil {
+		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
+	}
+	o, err := os.OpenFile(c.PrivateKeyPath("ecdsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
+	if err != nil {
+		return err
+	}
+	defer o.Close()
+
+	privBytes, err := x509.MarshalPKCS8PrivateKey(key)
+	if err != nil {
+		return err
+	}
+
+	if err := pem.Encode(o, &pem.Block{
+		Type:  "PRIVATE KEY",
+		Bytes: privBytes,
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+
+// generateEd25519PrivateKey generates an ed25519 private key that will be used by the SFTP server.
+func (c *SFTPServer) generateEd25519PrivateKey() error {
+	_, key, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(path.Dir(c.PrivateKeyPath("ed25519")), 0o755); err != nil {
+		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
+	}
+	o, err := os.OpenFile(c.PrivateKeyPath("ed25519"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
+	if err != nil {
+		return err
+	}
+	defer o.Close()
+
+	privBytes, err := x509.MarshalPKCS8PrivateKey(key)
+	if err != nil {
+		return err
+	}
+
+	if err := pem.Encode(o, &pem.Block{
+		Type:  "PRIVATE KEY",
+		Bytes: privBytes,
+	}); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PrivateKeyPath returns the path the host private key for this server instance.
+func (c *SFTPServer) PrivateKeyPath(name string) string {
+	return path.Join(c.BasePath, ".sftp", "id_"+name)
 }
 
 // A function capable of validating user credentials with the Panel API.
@@ -177,6 +305,7 @@ func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.
 		IP:            conn.RemoteAddr().String(),
 		SessionID:     conn.SessionID(),
 		ClientVersion: conn.ClientVersion(),
+		Type:          "password",
 	}
 
 	logger := log.WithFields(log.Fields{"subsystem": "sftp", "username": conn.User(), "ip": conn.RemoteAddr().String()})
@@ -187,6 +316,11 @@ func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.
 		return nil, &remote.SftpInvalidCredentialsError{}
 	}
 
+	if len(pass) < 1 {
+		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 {
@@ -208,3 +342,56 @@ func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.
 
 	return sshPerm, nil
 }
+
+func (c *SFTPServer) publicKeyCallback(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
+	request := remote.SftpAuthRequest{
+		User:          conn.User(),
+		Pass:          "KEKW",
+		IP:            conn.RemoteAddr().String(),
+		SessionID:     conn.SessionID(),
+		ClientVersion: conn.ClientVersion(),
+		Type:          "publicKey",
+	}
+
+	logger := log.WithFields(log.Fields{"subsystem": "sftp", "username": conn.User(), "ip": conn.RemoteAddr().String()})
+	logger.Debug("validating public key 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
+	}
+
+	if len(resp.SSHKeys) < 1 {
+		return nil, &remote.SftpInvalidCredentialsError{}
+	}
+
+	for _, k := range resp.SSHKeys {
+		storedPublicKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(k))
+		if err != nil {
+			return nil, err
+		}
+
+		if !bytes.Equal(key.Marshal(), storedPublicKey.Marshal()) {
+			continue
+		}
+
+		return &ssh.Permissions{
+			Extensions: map[string]string{
+				"uuid":        resp.Server,
+				"user":        conn.User(),
+				"permissions": strings.Join(resp.Permissions, ","),
+			},
+		}, nil
+	}
+	return nil, &remote.SftpInvalidCredentialsError{}
+}

sftp/utils.go

@@ -6,15 +6,15 @@ import (
 )
 
 const (
-	// Extends the default SFTP server to return a quota exceeded error to the client.
+	// ErrSSHQuotaExceeded 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)
+	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.
+// ListAt returns the number of entries copied and an io.EOF error if we made it to the end of the file list.
 // Take a look at the pkg/sftp godoc for more information about how this function should work.
 func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
 	if offset >= int64(len(l)) {
@@ -28,9 +28,9 @@ func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
 	}
 }
 
-type fxerr uint32
+type fxErr uint32
 
-func (e fxerr) Error() string {
+func (e fxErr) Error() string {
 	switch e {
 	case ErrSSHQuotaExceeded:
 		return "Quota Exceeded"

system/const.go

@@ -1,6 +1,3 @@
 package system
 
-var (
-	// The current version of this software.
-	Version = "0.0.1"
-)
+var Version = "develop"