Bump for release

.dockerignore

@@ -1,56 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.dll
-*.so
-*.dylib
-.idea/*
-
-# Test binary, build with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
-.glide/
-
-# dep related files and folders
-/vendor*
-
-# ignore logfiles (/* so the .gitkeep override works)
-/logs/*
-
-# ignore configuration file
-/config.yml
-
-# Ignore Vagrant stuff
-/.vagrant
-
-# Builds by gox
-/build
-
-# Go Coverage tool
-/coverage.out
-
-# The built executable
-wings
-wings.exe
-
-# IDE/Editor files (VS Code)
-/.vscode
-
-# test files
-test_*/
-
-# Keep all gitkeep files (This needs to stay at the bottom)
-!.gitkeep
-debug
-.DS_Store
-*.pprof
-*.pdf
-
-Dockerfile
-CHANGELOG.md
-Makefile
-README.md
-wings-api.paw

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: [ matthewpi ]

.github/workflows/build-test.yml

@@ -1,76 +0,0 @@
-name: Run Tests
-on:
-  push:
-    branches:
-      - develop
-  pull_request:
-    branches:
-      - develop
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-20.04 ]
-        go: [ '1.18.7' ]
-        goos: [ linux ]
-        goarch: [ amd64, arm64 ]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Code Checkout
-        uses: actions/checkout@v2
-      - name: Setup Go v${{ matrix.go }}
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go }}
-      - name: Print Environment
-        id: env
-        run: |
-          printf "Go Executable Path: $(which go)\n"
-          printf "Go Version: $(go version)\n"
-          printf "\n\nGo Environment:\n\n"
-          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:
-          key: ${{ runner.os }}-go${{ matrix.go }}-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ 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 ./...
-      - name: Build
-        env:
-          GOOS: ${{ matrix.goos }}
-          GOARCH: ${{ matrix.goarch }}
-          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_${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: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
-        with:
-          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

@@ -1,30 +0,0 @@
-name: CodeQL
-on:
-  push:
-    branches:
-      - develop
-  pull_request:
-    branches:
-      - develop
-  schedule:
-    - cron: '0 9 * * 4'
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-    steps:
-      - uses: actions/checkout@v2
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
-        with:
-          languages: ${{ matrix.language }}
-      - uses: github/codeql-action/autobuild@v1
-      - uses: github/codeql-action/analyze@v1

.github/workflows/docker.yml

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

@@ -1,89 +0,0 @@
-name: Create Release
-on:
-  push:
-    tags:
-      - 'v*'
-jobs:
-  release:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Code Checkout
-        uses: actions/checkout@v2
-      - uses: actions/setup-go@v2
-        with:
-          go-version: '1.18.7'
-      - name: Build
-        env:
-          REF: ${{ github.ref }}
-        run: |
-          CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_amd64 -v wings.go
-          CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_arm64 -v wings.go
-      - name: Test
-        run: go test ./...
-      - name: Compress binary and make it executable
-        run: |
-          upx build/wings_linux_amd64 && chmod +x build/wings_linux_amd64
-          upx build/wings_linux_arm64 && chmod +x build/wings_linux_arm64
-      - name: Extract changelog
-        env:
-          REF: ${{ github.ref }}
-        run: |
-          sed -n "/^## ${REF:10}/,/^## /{/^## /b;p}" CHANGELOG.md > ./RELEASE_CHANGELOG
-          echo ::set-output name=version_name::`sed -nr "s/^## (${REF:10} .*)$/\1/p" CHANGELOG.md`
-      - name: Create checksum and add to changelog
-        run: |
-          SUM=`cd build && sha256sum wings_linux_amd64`
-          SUM2=`cd build && sha256sum wings_linux_arm64`
-          echo -e "\n#### SHA256 Checksum\n\`\`\`\n$SUM\n$SUM2\n\`\`\`\n" >> ./RELEASE_CHANGELOG
-          echo -e "$SUM\n$SUM2" > checksums.txt
-      - name: Create release branch
-        env:
-          REF: ${{ github.ref }}
-        run: |
-          BRANCH=release/${REF:10}
-          git config --local user.email "ci@pterodactyl.io"
-          git config --local user.name "Pterodactyl CI"
-          git checkout -b $BRANCH
-          git push -u origin $BRANCH
-          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
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ steps.extract_changelog.outputs.version_name }}
-          body_path: ./RELEASE_CHANGELOG
-          draft: true
-          prerelease: ${{ contains(github.ref, 'beta') || contains(github.ref, 'alpha') }}
-      - name: Upload amd64 Binary
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: build/wings_linux_amd64
-          asset_name: wings_linux_amd64
-          asset_content_type: application/octet-stream
-      - name: Upload arm64 Binary
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: build/wings_linux_arm64
-          asset_name: wings_linux_arm64
-          asset_content_type: application/octet-stream
-      - name: Upload checksum
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./checksums.txt
-          asset_name: checksums.txt
-          asset_content_type: text/plain

.gitignore

@@ -22,7 +22,6 @@
 
 # ignore configuration file
 /config.yml
-/config*.yml
 
 # Ignore Vagrant stuff
 /.vagrant
@@ -46,7 +45,5 @@ test_*/
 # Keep all gitkeep files (This needs to stay at the bottom)
 !.gitkeep
 debug
+data/.states.json
 .DS_Store
-*.pprof
-*.pdf
-pprof.*

.travis.yml

@@ -0,0 +1,47 @@
+os: linux
+dist: xenial
+language: go
+
+go:
+- 1.13.x
+
+go_import_path: "github.com/pterodactyl/wings"
+
+services:
+- docker
+
+install:
+- mkdir -p $GOPATH/bin
+
+# Install used tools
+- go get github.com/mitchellh/gox
+- go get github.com/haya14busa/goverage
+- go get github.com/schrej/godacov
+
+- go mod download
+
+script:
+- make cross-build
+- goverage -v -coverprofile=coverage.out ./...
+- godacov -t $CODACY_TOKEN -r ./coverage.out -c $TRAVIS_COMMIT
+
+deploy:
+  provider: releases
+  api_key:
+    secure: HQ8AvnSsOW2aDUKv25sU83SswK9rReGeFi68SotLGPdWyFBWJbp/JEHhw9swSqvhLPykx5QqLnRPG4nomOp2i5dVTXgM/7C3wQ2ULymkJDZqDJEAxjm1IuNsjXgcFqp0zcNXL3g0moaorHS2XZpzbgaewlCyYoEb+3SZUGzOCPIjSFvoIBaAYx6kRn+pyWo1I0mQChno2i7SGvAoZwh/hZIO6L5FZe5PcpBs/SxkZ+/shsGMk7CIyNMhG6CQTE1tlr+ZenluXjtliZfc4XwkHG/9MICNl8ihUrnN6YfdvJZXLQvolZQ0QJ5Eyb04jQd1yzKR1hcLx2S42IAWxaWTy5QxSN8QyG5wBRNg567ib5FEqY4M1nyQnWQbUbaiYloYBp14aR1L9DQw8+xmXnlgnTUPq1w+cOpQLeY/RENCalgHe7NoI3lClC2b7/c1j+O7RA68yYUFUod0y7ZXcCwsJkbRk7xgyDEAGs+rq8wLknj6f8y8cfNm179lRARwblnmo9uA43Tlee8DBSziSvJy/mYMzdIQeb+PHuznXjr4fze7x+zvronkiD/JH8MjJl3SWaE7DGtc5jz4+aRxU3rMbHwToEOY6u5pIsvz5PRFYWBvKX2+VoxmdR+m1qhAxsg0wtbA0CTnqgHNGMIFDWVTDQSy8LvJt+usUn1RtrYyyiI=
+  file_glob: true
+  file: build/*
+  on:
+    tags: true
+    branch: master
+
+notifications:
+  email: false
+  webhooks:
+    urls:
+      - https://misc.schrej.net/travistodiscord/pterodev.php
+    on_success: change
+    on_failure: always
+    on_error: always
+    on_cancel: always
+    on_start: never

CHANGELOG.md

@@ -1,597 +1,5 @@
 # Changelog
 
-## v1.7.4
-### Fixed
-* CVE-2023-25168
-
-## v1.7.3
-### Fixed
-* CVE-2023-25152
-
-## v1.7.2
-### Fixed
-* The S3 backup driver now supports Cloudflare R2
-
-### Added
-* During a server transfer, there is a new "Archiving" status that outputs the progress of creating the server transfer archive.
-* Adds a configuration option to control the list of trusted proxies that can be used to determine the client IP address.
-* Adds a configuration option to control the Docker username space setting when Wings creates containers.
-
-### Changed
-* Releases are now built using `Go 1.18` — the minimum version required to build Wings is now `Go 1.18`.
-
-## v1.7.1
-### Fixed
-* YAML parser has been updated to fix some strange issues
-
-### Added
-* Added `Force Outgoing IP` option for servers to ensure outgoing traffic uses the server's IP address
-* Adds an option to control the level of gzip compression for backups
-
-## v1.7.0
-### Fixed
-* Fixes multi-platform support for Wings' Docker image.
-
-### Added
-* Adds support for tracking of SFTP actions, power actions, server commands, and file uploads by utilizing a local SQLite database and processing events before sending them to the Panel.
-* Adds support for configuring the MTU on the `pterodactyl0` network.
-
-## v1.6.4
-### Fixed
-* Fixes a bug causing CPU limiting to not be properly applied to servers.
-* Fixes a bug causing zip archives to decompress without taking into account nested folder structures.
-
-## v1.6.3
-### Fixed
-* Fixes SFTP authentication failing for administrative users due to a permissions adjustment on the Panel.
-
-## v1.6.2
-### Fixed
-* Fixes file upload size not being properly enforced.
-* Fixes a bug that prevented listing a directory when it contained a named pipe. Also added a check to prevent attempting to read a named pipe directly.
-* Fixes a bug with the archiver logic that would include folders that had the same name prefix. (for example, requesting only `map` would also include `map2` and `map3`)
-* Requests to the Panel that return a client error (4xx response code) no longer trigger an exponential backoff, they immediately stop the request.
-
-### Changed
-* CPU limit fields are only set on the Docker container if they have been specified for the server — otherwise they are left empty.
-
-### Added
-* Added the ability to define the location of the temporary folder used by Wings — defaults to `/tmp/pterodactyl`.
-* Adds the ability to authenticate for SFTP using public keys (requires `Panel@1.8.0`).
-
-## 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.
-
-### Changed
-* Updated server transfer logic to use newer file archiving tools to avoid frequent errors when transferring symlinked files.
-
-## v1.3.0
-### Fixed
-* Fixes improper error handling when attempting to create a new Docker network.
-* Fixes edge-case crash that would occur when a user triggers an install for a server that does not currently have a data directory present on the system.
-* Fixes missing return on error when attempting to get the contents of a file from Wings.
-* Fixes certain stop signals not being properly handled and parsed by Wings.
-* Fixes server build settings not always being updated properly if set to their zero-value.
-* Fixes context leak when waiting on a server instance to be stopped.
-* Fix potential application panic when chowning a file if there is an error getting file details.
-* Fixes `Filesystem.Chown` unintentionally touching all of the files within a given directory tree which could cause some games to trigger a full refresh thinking files had been changed.
-* Fixes `Content-Disposition` header not being properly escaped causing some browsers to not report the correct filename on downloads.
-
-### Added
-* Adds support for restoring server backups (including remote backups) with the ability to reset the current file state for a server.
-* Adds underlying support for allowing Eggs to mark specific files (or patterns) as being inaccessible to users within the file manager.
-
-### Changed
-* Refactored SFTP subsystem to be less of a standalone package and more integrated with the underlying server logic in Wings. This significantly simplified the logic and makes it much easier to reason about.
-* Refactored much of the underlying API logic to be more extensible down the road, support automatic retries, and be more testable.
-* Refactored much of the underlying HTTP middleware logic to be packaged differently and easier to reason about in the codebase.
-* System defined `TZ` variable will be used if present rather than attempting to parse the timezone using `datetimectl`.
-* Improves error handling and reporting for server installation process to improve debugging in the future if things break.
-
-## v1.2.3
-### Fixed
-* **[Security]** Fixes a remaining security vulnerability in the code handling remote file downloads for servers relating to redirect validation.
-
-### Added
-* Adds a configuration key at `api.disable_remote_download` that can be set to `true` to completely download the remote download system.
-
-## v1.2.2
-### Fixed
-* Reverts changes to logic handling blocking until a server process is done running when polling stats. This change exposed a bug in the underlying Docker system causing servers to enter a state in which Wings was unable to terminate the process and Docker commands would hang if executed against the container.
-
-### Changed
-* Adds logic to handle a console stream unexpectedly returning an EOF when reading console logs. New code should automatically re-attach the stream avoiding issues where the console would stop live updating for servers.
-
-## v1.2.1
-### Fixed
-* Fixes servers not be properly marked as no longer transfering if an error occurs during the archive process.
-* Fixes problems with user detection when running Wings inside a Docker container.
-* Fixes filename decoding issues with multiple endpoints related to the file manager (namely move/copy/delete).
-* **[Security]** Fixes vulnerability allowing a malicious user to abuse the remote file download utilitity to scan or access resources on the local network.
-* Fixes network `tx` stats not correctly being reported (was previously reporting `rx` for both `rx` and `tx`).
-
-### Changed
-* Cleans up the logic related to polling resources for the server to make a little more sense and not do pointless `io.Copy()` operations.
-
-## v1.2.0
-### Fixed
-* Fixes log compression being set on the Docker containers being created to avoid errors on some versions of Docker.
-* Cleaned up logic handling server resource usage to avoid race conditions in the future and make the logic simpler.
-* Fixes directories being created when writing a file before checking if there was space for the file to even be written to the disk.
-* Significant performance and resource usage fixes to backups and server transfers to avoid obliterating machine `i/o` and causing excessive resource exhaustion on busy systems or low end machines.
-* Fixes server install process to not unintentionally exit and cause invalid states if a line during the install process was too long.
-* Fixes symlink error handling in backups to not unexpectedly tank a request. Any errors due to a symlink are now ignored and will not impact the generation of a backup (including for server transfers).
-
-### Changed
-* Changed `--debug` flag to no longer ignore certificate errors on requests. Use `--ignore-certificate-errors` to ignore any certificate errors encountered when in development environments.
-* Changed all Filesystem related errors to be of the same internal error type making error checking significantly easier and less error prone.
-* Improves log output stacktraces to be more accurate as to the source of the issue.
-
-### Added
-* Adds support for downloading files to a server's data directory and optionally checking the status of or canceling in-progress downloads.
-* Adds a `context.Context` to `server.Server` structs allowing for cancelation of long running background tasks when a server is deleted without additional complexity on developer's end.
-
-## v1.1.3
-### Fixed
-* Fixes `archive/tar: write too long` error when creating a server backup.
-* Fixes server installation docker images not using authentication properly during the pull.
-* Fixes temporary transfer files not being removed after the transfer is completed.
-* Fixes TLS certificate checking to be all lowercase to avoid any lookup issues when an all-caps domain is provided.
-* Fixes multiple interfaces with the same port not being publishable for a server.
-* Fixes errors encountered during websocket processes being incorrectly passed back to the Panel as a JWT error rather than a generic Wings error for admin users.
-
-### Added
-* Added logic to notify the Panel when archive generation fails.
-* Added endpoint to run `chmod` commands against server files and updated API response to include the mode bits when requesting files.
-
-### Changed
-* Updated internals to call `Server.Environment.State()` rather than deprecated `Server.GetState()` functions.
-* Improved error handling logic and massively simplified error passing around the codebase.
-
-## v1.1.2
-### Fixed
-* Fixes binaries built as part of the release process not being usable in MUSL based environments (such as our Docker images).
-* Fixes server states being incorrectly set back to offline when a server is started after a system restart.
-
-### Changed
-* Improved logic for cleaning `allowed_mount` paths for consistency.
-* Certain context cancelation deadline errors are no longer wrong reported at an error level (since they're expected).
-* Very minor micro-optimizations for some string handling with server console output.
-
-### Added
-* Added a hidden option to disable all disk checking for servers by setting the `disk_check_interval` to `0` in the config file.
-
-## v1.1.1
-### Fixed
-* Fixes certain files returning invalid data in the request due to a bad header set after sending data down the line.
-
-## v1.1.0
-This release **requires** `Panel@1.1.0` or later to run due to API changes.
-
-### Added
-* Adds support for denying client JWT access to specific token keys generated before Wings starts, or before an arbitrary date from an API call.
-* Adds support for a configurable number of log messages to be returned when connecting to a server socket and requesting the logs.
-* Adds support for both CPU and Memory profiling of Wings via a CLI argument.
-
-### Fixed
-* Errors encountered while uploading files to Wings are now properly reported back to the client rather than causing a generic 500 error.
-* Servers exceeding their disk limit are now properly stopped when they exceed limits while running.
-* Fixes server environment starting as an empty value rather than an "offline" value.
-
-### Changed
-* Cleaned up code internals for handling API requests to make it easier on new developers and use a more sane system.
-* Server configuration retrieval from the Panel is now done in a paginated loop rather than a single large call to allow systems with thousands of instances to boot properly.
-* Switches to multipart S3 uploads to handle backups larger than 5GB in size.
-* Switches the error handling package from `pkg/errors` to `emperror` to avoid overwriting existing stack traces associated with an error and provide additional functionality.
-
-## v1.0.1
-### Added
-* Adds support for ARM to build outputs for wings.
-
-### Fixed
-* Fixed a few docker clients not having version negotiation enabled.
-* Fixes local images prefixed with `~` getting pulled from remote sources rather than just using the local copy.
-* Fixes console output breaking with certain games when excessive line length was output.
-* Fixes an error when console lines were too long that would cause the console to stop updating until the server was restarted,
-
-### Changed
-* Simplified timezone logic for containers by properly grabbing the system timezone and then passing that through to containers with the `TZ=` environment variable.
-
-## v1.0.0
-This is the first official stable release of Wings! Please be aware that while this specific version changelog is very short,
-it technically includes all of the previous beta and alpha releases within it. For the sake of version history and following
-along though, I've only included the differences between this version and the previous RC build.
-
-### Fixed
-* Fixes file parser not properly appending newline character to modified lines.
-* Fixes server disk usage not being properly reported back to the API and websocket.
-
-### Changed
-* Changes diagnostics endpoint URL to be `ptero.co` rather than `hastebin.com`.
-* Diagnostics report now includes system time for easier debugging of logs and container issues.
-
-## v1.0.0-rc.7
-### Fixed
-* **[Security]** Prevents the `allowed_mounts` configuration value from being set by a remote API call.
-* Fixes an unexpected error when attempting to make a copy of an archive file.
-* Fixes certain expected filesystems errors being returned to the API as a 500 error rather than a 4XX series error.
-* Fixes a panic crash when there is no text on a line and the parser is attempting to determine if the line is a comment.
-* Fixes multiple filesystem operations to correctly check, increment, and decrement disk usage for a server.
-* Fixes a negative disk space usage issue when deleting a file due to a bad int swap.
-* Errors from a websocket connection being closed will no longer spam the console.
-* Fixes an extraneous `.` in the install script for servers causing errors in some scenarios.
-* Fixes unexpected error spam due to a change in how `os.ErrNotExist` is returned from some functions.
-
-### Changed
-* Stacktrace is no longer emitted when warning that an image exists locally.
-* Configuration parser now attempts to create the directory structure leading to a configuration file if it is missing.
-* If a file name is too long for the system a nice error is returned to the caller.
-* Enables client version negotiation for Docker to support more versions.
-* Disk space errors are no longer logged into the wings logs.
-* Servers can no longer be reinstalled while another power action is currently running. This avoids data collisions and wings running into issues with the container state.
-* Wings now uses `1024` rather than `1000` bytes when calculating the disk space usage for a server to match how the Panel reports usage.
-* JWT errors in the websocket are now sent back to the connection as a specific event type allowing them to be handled even if the timer fails to execute or executes but is not being listened for.
-* A server struct is no longer embedded in the virtual filesystem allowing for easier testing and modularization of the codebase.
-* Server websockets are now closed when a server is deleted, disconnecting any currently connected clients.
-
-### Removed
-* **[Security]** Removes the `SafeJoin` function which could wrongly assume the state of a file and allow a user to escape the root if the developer implementing the call calls `Stat` rather than `Lstat`.
-
-## v1.0.0-rc.6
-### Fixed
-* Fixes race condition when checking if the running state of a server has changed.
-* Fixes files mistakenly unpacking themselves to the root directory rather than the directory they are told to unpack to.
-* Fixes console output not being sent to the websocket in the same order that it was received.
-* Fixes a file busy error causing a 500 error response when unpacking an archive rather than a 400 error with a message indicating what is wrong to the user.
-* Fixes docker image not properly updating when a server is started.
-
-### Changed
-* Replaces fragile event bus logic with a more robust and easier to understand system. This fixes all remaining console and stats output issues that have been reported.
-* Cleans up API response error messaging to avoid empty errors being logged which cannot be acted upon.
-* Adds support for retrying a file write a few times with a back-off if the file is busy when the write occurs.
-
-### Added
-* Docker image pull data is shown in the console when an admin is connected to the websocket.
-* Adds console throttling to stop a server if too much data is being piped out of the console. This logic mimics the logic present in the old Nodejs daemon, but with a 2x line count limit (1000 -> 2000) per period.
-
-## v1.0.0-rc.5
-### Fixed
-* Fixes long standing bug with console output not properly sending back to the client with server stats in certain edge case scenarios. This was "fixed" in `rc.4` but ended up breaking many servers in significantly more painful manners, but did allow us to better track down the issue.
-* Fixes build flags during release process to correctly strip unnessary code allowing the final binary size to be reduced back down to `~5MB`
-* Fixes Wings returning the last `16384` lines of the log file when connecting to the websocket.
-* Fixes pre-boot actions always running for a server start event even if the server is already running.
-
-### Added
-* Adds support for configuring the amount of time that can elapse between server disk size checking before the value is considered stale.
-
-## v1.0.0-rc.4
-### Fixed
-* Fixes server files being inaccessible if the root data path is a symlink to another location on the machine.
-* Fixes some console output being written to the logs accidentally truncating other lines due to special ANSI sequences being output.
-* Fixes `server.properties` files getting mangled by the automatic configuration editor when booting a server.
-* Fixes a missed stream close when stopping resource polling that would lead to memory leaks.
-* Fixes port bindings being incorrectly re-assigned when using `127.0.0.1` with Docker. These are now properly re-mapped to the `pterodactyl0` interface so that networking operates as expected for the server.
-* Fixes handling of values within arrays in `yaml` and `json` configuration files.
-* Fixes a 304 error being returned rather than a 400 error when a file upload is invalid.
-* Fixes deadlocks and response delays when processing server console and stat events. This was causing server consoles to become completely unresponsive after random periods of time and was only resolvable via a Wings restart.
-
-### Changed
-* Allows a stale value to be present when starting a server if the server is allowed an unlimited amount of disk space.
-* Removed all remaining traces of the `zap` logging library from the codebase.
-* Servers no longer auto-restart as if they crashed when a stop command is manually sent via the server console to the instance.
-* Changes the CORS checks to allow `*` as a remote origin.
-
-### Added
-* Added an auto-generated logrotate file which is written to the normal logrotate directory when wings is first started.
-* Added additional debug logging within the internals of the resource polling for servers to better trace unexpected behavior.
-* Adds additional logic check to avoid even trying to stop a suspended server if it is already stopped.
-
-## v1.0.0-rc.3
-### Fixed
-* Errors during the backup process are now correctly reported to the Panel and logged into the output correctly.
-* Empty directories are no longer pushed into the backup file list (which was causing errors to occur previously).
-* Covered an edge case to prevent errors if a file gets deleted while a backup is in progress.
-* Fixed a bug causing Wings to panic and crash if an invalid environment variable value was passed through. These invalid values are now logged to the output to better detect and an empty string is returned in their place.
-* Fixed startup variables and other server information not properly being updated when a server is restarted.
-* Suspension state of a server is now properly returned by the API.
-* Fixes an error being thrown if a backup does not exist on the local machine. A 404 is now properly returned and handled by the Panel when this occurs.
-* Fixes an error when attempting to move or rename a folder due to the target being created accidentally before the rename occurred.
-* Fixes install scripts running even when the checkbox to not run them on installation was selected in the Panel.
-
-### Changed
-* Disk space checking modified to not block in as many parts of the codebase and allow returning a stale cache value where that is appropriate. Thanks @cyberkitsune!
-* SFTP package code is now merged into the codebase to make keeping up with all of the code simpler, and reduce the complexity of the SFTP server.
-
-### Added
-* Added the ability for a node to be configured to skip file permissions checking when starting a server.
-* Added console output message to indicate that server disk space checking is occurring rather than silently sitting there.
-
-## v1.0.0-rc.2
-### Fixed
-* Fixes significant performance degradation due to excessive `syscall` actions when determining directory sizes on large servers. This was previously causing CPU & I/O lockups on servers and should be significantly more performant and less impactful on the system now.
-* Fixes panic crash when booting wings with no log directory created.
-
-### Changed
-* Changed default interval for disk space calculation from every 60 seconds to every 2.5 minutes.
-
-## v1.0.0-rc.1
-### Fixed
-* Servers are no longer incorrectly marked as stopping when they are, in fact, offline.
-* Release build version is now correctly output when starting wings.
-* Termination signals can now always be sent to a server instance even if the instance is currently starting/stopping.
-* Removed the file chown on wings boot to avoid slowing down the boot process unnecessarily when working with hundreds of servers on a node.
-* Fixed a multitude of race conditions throughout the code that cropped up during testing and made power handling even more robust for server instances.
-* In general multiple fragile areas of the codebase have been improved and are more likely to return useful errors should they break.
-* Addressed serious CPU usage issues when generating backups, and additionally decreased the amount of time they take to generate.
-
-### Changed
-* Internal server now uses more secure and recommended TLS settings.
-* Environment handling is now completely separate from the server package itself, allowing the environments to no longer be tightly coupled to the server.
-* `/tmp` directory mounted into containers can now be programmatically managed and uses better defaults to avoid people even needing to edit it.
-
-### Added
-* Wings logs are now properly persisted to the disk.
-* Adds the ability for an egg to use ANSI-stripped matching when determining if a server is done booting.
-
-## v1.0.0-beta.9
-### Fixed
-* Fixes server resource usage stats not being returned correctly by the API endpoint.
-* Fixes an exception thrown when attempting to write server installation logs.
-* Fixes error handling to provide a more accurate stack-trace in more scenarios where one is missing initially.
-* Fixes a memory leak and zombie event listeners when disconnecting from a server's websocket.
-* Fixes a race condition when wings is attempting to register/de-register event subscribers.
-* Server data directories now correctly have their permissions set recursively when booting Wings.
-* Fixes a race condition when a server's console stream was not fully closed before the next power action was started.
-
-### Changed
-* Server power handling is now handled in a synchronous manner. This avoids endless bugs and race conditions that would crop up if someone triggered two restart processes back to back. The new logic prevents performing any additional power actions until the currently executing action is completed.
-* Server disk usage is now correctly calculated when restarting the daemon as long as the server data directory exists.
-* Multiple code pathways within the boot process were cleaned up and modified to be less IO intensive and overall easier to reason about as a developer.
-* Additional timezone data is now mounted into containers to better improve the ability for instances running to be using the correct timezone.
-
-### Added
-* Adds basic internal file upload endpoints (these are currently not exposed anywhere in the Panel).
-* Added additional process events for installation start and completion.
-* Additional CORS allowed origins for the websocket can now be defined in the configuration file.
-* Adds the ability to authenticate with a docker registry when pulling images.
-
-## v1.0.0-beta.8
-### Fixed
-* Server state is synced with the Panel before performing a reinstall to ensure that the latest information is used.
-* Wings no longer crashes when a non-string environment variable value is passed through.
-* SFTP server authentication no longer attempts to contact the Panel to validate credentials if the format is known to already be incorrect.
-* Some previously missing error stacks are now properly returned when encountered.
-* Renaming a file no longer triggers an error if the base path does not exist.
-* Disk space is now properly calculated for a server even if it is assigned unlimited space.
-* **[Security]** Prevent symlink files from unintentionally chmodding their target file when a server is booted when the target file resides outside the server data directory.
-* **[Security]** Cleans up multiple code pathways that may unintentionally allow a malicious user to impact files outside their home directory.
-* Fixes numerous race conditions during a server's boot process that may lead to unintended data states.
-* Fixes an error thrown when attempting to delete a file that points to a symlink outside the server data directory.
-* Deleting a symlink will no longer attempt to remove the source file, only the symlink itself.
-* Websocket no longer blocks when handling a long running process for a user.
-
-### Changed
-* Install log for servers is now more detailed and more useful for debugging what might be going wrong.
-* Certain file management API endpoints now support passing through multiple paths at once to make mass actions easier to perform.
-* Re-worked file walking implementation to not cause a server crash when working with very large directories, and avoid race conditions when recursively walking directories.
-* Server configuration structure re-worked to be more manageable in the code base and avoid additional race conditions and complexity while making on-the-fly changes to it.
-
-### Added
-* Support for configuring additional file mount points in a container via the Panel.
-* Support for automated SSL certificate generation when booting the Daemon.
-* Added wings diagnostics command.
-* New API endpoints to compress and decompress files on a server.
-
-## v1.0.0-beta.7
-### Fixed
-* Stacktraces are now displayed once in the error output, rather than twice when certain errors are encountered.
-* Additional errors that did not previously output a stack trace have been fixed to output.
-* Fixes a bug where server space available would be triggered when creating a new server from a remote configuration before that file location existed on the disk, leading to an error.
-* Fixes context timeouts while pulling server docker images. Time was upped from 10 seconds to 15 minutes.
-* Configuration file replacement values are now properly de-escaped when writing to the disk. `\/no\/more\/slashes`
-* `.properties` files are now saved correctly to the disk with newlines, rather than shoved on a single line.
-* `./wings configure` command can now properly save the configuration to the disk.
-* Custom SSL locations are no longer obliterated when making changes to the Node's configuration via the Panel.
-
-### Changed
-* Exclusive lock is now acquired when performing a server installation to avoid two install processes being triggered at the same time. This also allows an install to be properly canceled if the server is deleted before it is completed.
-
-## v1.0.0-beta.6
-### Fixed
-* Server status is no longer sent to all connected websocket clients when a new client connects to the socket.
-* Server disk usage is sent back over the socket when connecting.
-* Default configuration for the SFTP server is now properly returned to `on` rather than `off`
-* Server boot is no longer blocked if there is an error fetching the Docker image as long as that image exists on the host.
-* The websocket no longer gets locked up when Wings attempts to send an error to the client.
-* Fixed a crash loop when an error is thrown during pre-boot phase of server startup.
-* Errors with `BindJSON` in API endpoints are now properly handled and returned.
-* Fixed warning about Gin running in non-release mode, even when the binary is running in release mode.
-
-### Changed
-* Switched logging libraries to output data in a clearer format more suited to the CLI where this application runs.
-* Cleaner debug messaging in debug mode from the router.
-
-## v1.0.0-beta.5
-### Fixed
-* Default config location settled on `/etc/pterodactyl/config.yml`; wings will now check all of the previous locations for the configuration and move it automatically to the new location.
-* Deleting a server no longer fails the process if the container cannot be found.
-* Fixes permissions checking for subusers connecting to the SFTP instance.
-* S3 backups now properly send back hash data to the panel.
-* Server installation containers are now always deleted, even if the installer process fails for the instance.
-* Files and folders with special characters and spaces in them no longer return a 404 error.
-* Servers using eggs with bad configurations will no longer cause the daemon to fail booting; these bad configurations are simply skipped over and a warning is emitted into the logs.
-* Environment variables passed to containers no longer contain improper quotes around them.
-* Matching on array indexes in configurations now works correctly; `foo[0]` is quietly transformed into the proper `foo.0` syntax.
-
-### Added
-* New banner error message when the daemon is unable to locate the configuration file. This should better clarify what the user needs to do in order to resolve the issue.
-* Adds ability to configure the default networking driver used by docker.
-
-## v1.0.0-beta.4
-### Fixed
-* Fixes unexpected nil-pointer panic when attempting to start some newly created servers, or any server that was missing a container on the system.
-* Fixes memory usage of process being reported differently than the `docker stats` output leading to some confusion. These numbers should be more correct now.
-* Fixes possible nil-pointer panic when detecting a deleted container as being crashed.
-
 ## v1.0.0-beta.3
 ### Fixed
 * Daemon will no longer crash if someone requests a websocket for a deleted server.
@@ -603,39 +11,6 @@ along though, I've only included the differences between this version and the pr
 ### Changed
 * Memory overhead for containers is now 5/10/15% higher than the passed limit to account for JVM heap and prevent crashing.
 
-## v1.0.0-beta.2
-### Changed
-* Backup functionality made significantly more modular to ease adding additional methods in the future.
-* Websocket permissions changed to use same name as in panel.
-* Container memory hard-limits are now adjusted up by 15% (< 2G memory), 10% (< 4G memory), or 5% to avoid unexpected OOM crashes for memory heavy games.
-* Wings executable is now 80% smaller thanks to better compilation arguments.
-
-### Added
-* Adds support for ignoring files and directories when generating a new backup.
-* Added internal directory walker with callback-continue support.
-
-### Fixed
-* Fixed linux distro matching when booting the daemon.
-* Fixes DNS to be configurable for docker containers that are made for servers.
-* Fixes incorrect file truncation when making modifications to a server's configuration files.
-
-## v1.0.0-beta.1
-### Added
-* Added support for passing specific threads to the docker environment when running a server.
-* Added support for reinstalling an existing server.
-* Added support for restarting a server.
-* Adds support for transferring servers between daemon instances.
-* Added auto-deploy command to fetch configuration from Panel automatically.
-
-### Changed
-* Server file and backup downloads now hit a direct endpoint with a one-time JWT to avoid proxying large downloads through the panel.
-
-### Fixed
-* Fixes a go routine causing a memory and CPU leak.
-* Fixed improper chown of server directories on boot.
-* Miscellaneous fixes to CPU usage, abandoned go-routines, and race conditions.
-* Fixes support for Alpine based systems.
-
 ## v1.0.0-alpha.2
 ### Added
 * Ability to run an installation process for a server and notify the panel when completed.

Dockerfile

@@ -1,25 +1,14 @@
-# Stage 1 (Build)
+# ----------------------------------
-FROM golang:1.18-alpine AS builder
+# Pterodactyl Panel Dockerfile
+# ----------------------------------
 
-ARG VERSION
+FROM golang:1.14-alpine
-RUN apk add --update --no-cache git make
+COPY . /go/wings/
-WORKDIR /app/
+WORKDIR /go/wings/
-COPY go.mod go.sum /app/
+RUN apk add --no-cache upx \
-RUN go mod download
+ && go build -ldflags="-s -w" \
-COPY . /app/
+ && upx --brute wings
-RUN CGO_ENABLED=0 go build \
-    -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=$VERSION" \
-    -v \
-    -trimpath \
-    -o wings \
-    wings.go
-RUN echo "ID=\"distroless\"" > /etc/os-release
 
-# Stage 2 (Final)
+FROM alpine:latest
-FROM gcr.io/distroless/static:latest
+COPY --from=0 /go/wings/wings /usr/bin/
-COPY --from=builder /etc/os-release /etc/os-release
+CMD ["wings","--config", "/var/lib/pterodactyl/config.yml"]
-
-COPY --from=builder /app/wings /usr/bin/
-CMD [ "/usr/bin/wings", "--config", "/etc/pterodactyl/config.yml" ]
-
-EXPOSE 8080

LICENSE

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

Makefile

@@ -1,18 +1,5 @@
-GIT_HEAD = $(shell git rev-parse HEAD | head -c8)
-
 build:
-	GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_amd64 -v wings.go
+	GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -gcflags "all=-trimpath=/Users/dane/Sites/development/code" -o build/wings_linux_amd64 -v wings.go
-	GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_arm64 -v wings.go
-
-debug:
-	go build -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.
-rmdebug:
-	go build -gcflags "all=-N -l" -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
-	sudo dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./wings -- --debug --ignore-certificate-errors --config config.yml
 
 compress:
 	upx --brute build/wings_*
@@ -21,5 +8,3 @@ cross-build: clean build compress
 
 clean:
 	rm -rf build/wings_*
-
-.PHONY: all build compress clean

README.md

@@ -1,43 +1,16 @@
-[![Logo Image](https://cdn.pterodactyl.io/logos/new/pterodactyl_logo.png)](https://pterodactyl.io)
+# Alpha Project
+Please refrain from opening PRs or Issues at this time. This project is still under heavy development, and until we have a solid foundation and plan for how everything will connect, we will not be accepting PRs or feature suggestions.
 
-![Discord](https://img.shields.io/discord/122900397965705216?label=Discord&logo=Discord&logoColor=white)
+# Pterodactyl wings [![travis](https://img.shields.io/travis/pterodactyl/wings.svg?style=flat-square)](https://travis-ci.org/pterodactyl/wings) [![codacy quality](https://img.shields.io/codacy/grade/27a1576bda86450f853b1052b12fa570.svg?style=flat-square)](https://www.codacy.com/app/schrej/wings/dashboard) [![codacy coverage](https://img.shields.io/codacy/coverage/27a1576bda86450f853b1052b12fa570.svg?style=flat-square)](https://www.codacy.com/app/schrej/wings/files)
-![GitHub Releases](https://img.shields.io/github/downloads/pterodactyl/wings/latest/total)
-[![Go Report Card](https://goreportcard.com/badge/github.com/pterodactyl/wings)](https://goreportcard.com/report/github.com/pterodactyl/wings)
 
-# Pterodactyl Wings
+```
-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
+__ Pterodactyl _____/___/_______ _______ ______
-instances, fetch server logs, generate backups, and control all aspects of the server lifecycle.
+\_____\    \/\/    /   /       /  __   /   ___/
+   \___\          /   /   /   /  /_/  /___   /
+        \___/\___/___/___/___/___    /______/
+                            /_______/ alpha
+```
 
-In addition, Wings ships with a built-in SFTP server allowing your system to remain free of Pterodactyl specific
+A new generation of the Pterodactyl daemon, written in go.
-dependencies, and allowing users to authenticate with the same credentials they would normally use to access the Panel.
 
-## Sponsors
-I would like to extend my sincere thanks to the following sponsors for helping find Pterodactyl's developement.
-[Interested in becoming a sponsor?](https://github.com/sponsors/matthewpi)
-
-| Company | About |
-| ------- | ----- |
-| [**WISP**](https://wisp.gg) | Extra features. |
-| [**BisectHosting**](https://www.bisecthosting.com/) | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012. |
-| [**Fragnet**](https://fragnet.net) | Providing low latency, high-end game hosting solutions to gamers, game studios and eSports platforms. |
-| [**Tempest**](https://tempest.net/) | Tempest Hosting is a subsidiary of Path Network, Inc. offering unmetered DDoS protected 10Gbps dedicated servers, starting at just $80/month. Full anycast, tons of filters. |
-| [**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 the most highend French hosting company for your minecraft server? More than 24,000 members on our discord trust us. Give us a try! |
-| [**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! |
-| [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
-| [**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. |
-| [**HostEZ**](https://hostez.io) | Providing North America Valheim, Minecraft and other popular games with low latency, high uptime and maximum availability. EZ! |
-| [**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.|
-| [**Gamenodes**](https://gamenodes.nl) | Gamenodes love quality. For Minecraft, Discord Bots and other services, among others. With our own programmers, we provide just that little bit of extra service! |
-
-## Documentation
-* [Panel Documentation](https://pterodactyl.io/panel/1.0/getting_started.html)
-* [Wings Documentation](https://pterodactyl.io/wings/1.0/installing.html)
-* [Community Guides](https://pterodactyl.io/community/about.html)
-* Or, get additional help [via Discord](https://discord.gg/pterodactyl)
-
-## Reporting Issues
-Please use the [pterodactyl/panel](https://github.com/pterodactyl/panel) repository to report any issues or make
-feature requests for Wings. In addition, the [security policy](https://github.com/pterodactyl/panel/security/policy) listed
-within that repository also applies to Wings.

api/api.go

@@ -0,0 +1,165 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/config"
+	"go.uber.org/zap"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Initializes the requester instance.
+func NewRequester() *PanelRequest {
+	return &PanelRequest{
+		Response: nil,
+	}
+}
+
+type PanelRequest struct {
+	Response *http.Response
+}
+
+// Builds the base request instance that can be used with the HTTP client.
+func (r *PanelRequest) GetClient() *http.Client {
+	return &http.Client{Timeout: time.Second * 30}
+}
+
+func (r *PanelRequest) SetHeaders(req *http.Request) *http.Request {
+	req.Header.Set("Accept", "application/vnd.pterodactyl.v1+json")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s.%s", config.Get().AuthenticationTokenId, config.Get().AuthenticationToken))
+
+	return req
+}
+
+func (r *PanelRequest) GetEndpoint(endpoint string) string {
+	return fmt.Sprintf(
+		"%s/api/remote/%s",
+		strings.TrimSuffix(config.Get().PanelLocation, "/"),
+		strings.TrimPrefix(strings.TrimPrefix(endpoint, "/"), "api/remote/"),
+	)
+}
+
+// Logs the request into the debug log with all of the important request bits.
+// The authorization key will be cleaned up before being output.
+func (r *PanelRequest) logDebug(req *http.Request) {
+	headers := make(map[string][]string)
+	for k, v := range req.Header {
+		if k != "Authorization" || len(v) == 0 {
+			headers[k] = v
+			continue
+		}
+
+		headers[k] = []string{v[0][0:15] + "(redacted)"}
+	}
+
+
+	zap.S().Debugw(
+		"making request to external HTTP endpoint",
+		zap.String("method", req.Method),
+		zap.String("endpoint", req.URL.String()),
+		zap.Any("headers", headers),
+	)
+}
+
+func (r *PanelRequest) Get(url string) (*http.Response, error) {
+	c := r.GetClient()
+
+	req, err := http.NewRequest(http.MethodGet, r.GetEndpoint(url), nil)
+	req = r.SetHeaders(req)
+
+	if err != nil {
+		return nil, err
+	}
+
+	r.logDebug(req)
+
+	return c.Do(req)
+}
+
+func (r *PanelRequest) Post(url string, data []byte) (*http.Response, error) {
+	c := r.GetClient()
+
+	req, err := http.NewRequest(http.MethodPost, r.GetEndpoint(url), bytes.NewBuffer(data))
+	req = r.SetHeaders(req)
+
+	if err != nil {
+		return nil, err
+	}
+
+	r.logDebug(req)
+
+	return c.Do(req)
+}
+
+// Determines if the API call encountered an error. If no request has been made
+// the response will be false.
+func (r *PanelRequest) HasError() bool {
+	if r.Response == nil {
+		return false
+	}
+
+	return r.Response.StatusCode >= 300 || r.Response.StatusCode < 200
+}
+
+// Reads the body from the response and returns it, then replaces it on the response
+// so that it can be read again later.
+func (r *PanelRequest) ReadBody() ([]byte, error) {
+	var b []byte
+	if r.Response == nil {
+		return nil, errors.New("no response exists on interface")
+	}
+
+	if r.Response.Body != nil {
+		b, _ = ioutil.ReadAll(r.Response.Body)
+	}
+
+	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
+
+	return b, nil
+}
+
+func (r *PanelRequest) HttpResponseCode() int {
+	if r.Response == nil {
+		return 0
+	}
+
+	return r.Response.StatusCode
+}
+
+type RequestError struct {
+	Code   string `json:"code"`
+	Status string `json:"status"`
+	Detail string `json:"detail"`
+}
+
+// Returns the error response in a string form that can be more easily consumed.
+func (re *RequestError) String() string {
+	return fmt.Sprintf("%s: %s (HTTP/%s)", re.Code, re.Detail, re.Status)
+}
+
+type RequestErrorBag struct {
+	Errors []RequestError `json:"errors"`
+}
+
+// Returns the error message from the API call as a string. The error message will be formatted
+// similar to the below example:
+//
+// HttpNotFoundException: The requested resource does not exist. (HTTP/404)
+func (r *PanelRequest) Error() *RequestError {
+	body, _ := r.ReadBody()
+
+	bag := RequestErrorBag{}
+	json.Unmarshal(body, &bag)
+
+	if len(bag.Errors) == 0 {
+		return new(RequestError)
+	}
+
+	return &bag.Errors[0]
+}

api/backup_endpoints.go

@@ -0,0 +1,35 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+)
+
+type BackupRequest struct {
+	Checksum string `json:"checksum"`
+	Size     int64  `json:"size"`
+	Successful bool `json:"successful"`
+}
+
+// Notifies the panel that a specific backup has been completed and is now
+// available for a user to view and download.
+func (r *PanelRequest) SendBackupStatus(backup string, data BackupRequest) (*RequestError, error) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	resp, err := r.Post(fmt.Sprintf("/backups/%s", backup), b)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+	if r.HasError() {
+		return r.Error(), nil
+	}
+
+	return nil, nil
+}

api/server_endpoints.go

@@ -0,0 +1,205 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/parser"
+)
+
+const (
+	ProcessStopCommand    = "command"
+	ProcessStopSignal     = "signal"
+	ProcessStopNativeStop = "stop"
+)
+
+// Holds the server configuration data returned from the Panel. When a server process
+// is started, Wings communicates with the Panel to fetch the latest build information
+// as well as get all of the details needed to parse the given Egg.
+//
+// This means we do not need to hit Wings each time part of the server is updated, and
+// the Panel serves as the source of truth at all times. This also means if a configuration
+// is accidentally wiped on Wings we can self-recover without too much hassle, so long
+// as Wings is aware of what servers should exist on it.
+type ServerConfigurationResponse struct {
+	Settings             json.RawMessage       `json:"settings"`
+	ProcessConfiguration *ProcessConfiguration `json:"process_configuration"`
+}
+
+// Defines the process configuration for a given server instance. This sets what the
+// daemon is looking for to mark a server as done starting, what to do when stopping,
+// and what changes to make to the configuration file for a server.
+type ProcessConfiguration struct {
+	Startup struct {
+		Done            string   `json:"done"`
+		UserInteraction []string `json:"userInteraction"`
+	} `json:"startup"`
+	Stop struct {
+		Type  string `json:"type"`
+		Value string `json:"value"`
+	} `json:"stop"`
+	ConfigurationFiles []parser.ConfigurationFile `json:"configs"`
+}
+
+// Defines installation script information for a server process. This is used when
+// a server is installed for the first time, and when a server is marked for re-installation.
+type InstallationScript struct {
+	ContainerImage string `json:"container_image"`
+	Entrypoint     string `json:"entrypoint"`
+	Script         string `json:"script"`
+}
+
+// GetAllServerConfigurations fetches configurations for all servers assigned to this node.
+func (r *PanelRequest) GetAllServerConfigurations() (map[string]*ServerConfigurationResponse, *RequestError, error) {
+	resp, err := r.Get("/servers")
+	if err != nil {
+		return nil, nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+
+	if r.HasError() {
+		return nil, r.Error(), nil
+	}
+
+	b, _ := r.ReadBody()
+	res := map[string]*ServerConfigurationResponse{}
+	if len(b) == 2 {
+		return res, nil, nil
+	}
+
+	if err := json.Unmarshal(b, &res); err != nil {
+		return nil, nil, errors.WithStack(err)
+	}
+
+	return res, nil, nil
+}
+
+// Fetches the server configuration and returns the struct for it.
+func (r *PanelRequest) GetServerConfiguration(uuid string) (*ServerConfigurationResponse, *RequestError, error) {
+	resp, err := r.Get(fmt.Sprintf("/servers/%s", uuid))
+	if err != nil {
+		return nil, nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+
+	if r.HasError() {
+		return nil, r.Error(), nil
+	}
+
+	res := &ServerConfigurationResponse{}
+	b, _ := r.ReadBody()
+
+	if err := json.Unmarshal(b, res); err != nil {
+		return nil, nil, errors.WithStack(err)
+	}
+
+	return res, nil, nil
+}
+
+// Fetches installation information for the server process.
+func (r *PanelRequest) GetInstallationScript(uuid string) (InstallationScript, *RequestError, error) {
+	res := InstallationScript{}
+
+	resp, err := r.Get(fmt.Sprintf("/servers/%s/install", uuid))
+	if err != nil {
+		return res, nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+
+	if r.HasError() {
+		return res, r.Error(), nil
+	}
+
+	b, _ := r.ReadBody()
+
+	if err := json.Unmarshal(b, &res); err != nil {
+		return res, nil, errors.WithStack(err)
+	}
+
+	return res, nil, nil
+}
+
+type installRequest struct {
+	Successful bool `json:"successful"`
+}
+
+// Marks a server as being installed successfully or unsuccessfully on the panel.
+func (r *PanelRequest) SendInstallationStatus(uuid string, successful bool) (*RequestError, error) {
+	b, err := json.Marshal(installRequest{Successful: successful})
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	resp, err := r.Post(fmt.Sprintf("/servers/%s/install", uuid), b)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+	if r.HasError() {
+		return r.Error(), nil
+	}
+
+	return nil, nil
+}
+
+type archiveRequest struct {
+	Successful bool `json:"successful"`
+}
+
+func (r *PanelRequest) SendArchiveStatus(uuid string, successful bool) (*RequestError, error) {
+	b, err := json.Marshal(archiveRequest{Successful: successful})
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	resp, err := r.Post(fmt.Sprintf("/servers/%s/archive", uuid), b)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+	if r.HasError() {
+		return r.Error(), nil
+	}
+
+	return nil, nil
+}
+
+func (r *PanelRequest) SendTransferFailure(uuid string) (*RequestError, error) {
+	resp, err := r.Get(fmt.Sprintf("/servers/%s/transfer/failure", uuid))
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+	if r.HasError() {
+		return r.Error(), nil
+	}
+
+	return nil, nil
+}
+
+func (r *PanelRequest) SendTransferSuccess(uuid string) (*RequestError, error) {
+	resp, err := r.Get(fmt.Sprintf("/servers/%s/transfer/success", uuid))
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+	if r.HasError() {
+		return r.Error(), nil
+	}
+
+	return nil, nil
+}

api/sftp_endpoints.go

@@ -0,0 +1,45 @@
+package api
+
+import (
+	"encoding/json"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/sftp-server"
+	"go.uber.org/zap"
+)
+
+func (r *PanelRequest) ValidateSftpCredentials(request sftp_server.AuthenticationRequest) (*sftp_server.AuthenticationResponse, error) {
+	b, err := json.Marshal(request)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := r.Post("/sftp/auth", b)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	r.Response = resp
+
+	if r.HasError() {
+		if r.HttpResponseCode() >= 400 && r.HttpResponseCode() < 500 {
+			zap.S().Debugw("failed to validate server credentials for SFTP", zap.String("error", r.Error().String()))
+
+			return nil, new(sftp_server.InvalidCredentialsError)
+		}
+
+		rerr := errors.New(r.Error().String())
+		zap.S().Warnw("error validating SFTP credentials", zap.Error(rerr))
+
+		return nil, rerr
+	}
+
+	response := new(sftp_server.AuthenticationResponse)
+	body, _ := r.ReadBody()
+
+	if err := json.Unmarshal(body, response); err != nil {
+		return nil, err
+	}
+
+	return response, nil
+}

cmd/config_finder.go

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

cmd/configure.go

@@ -2,31 +2,32 @@ package cmd
 
 import (
 	"crypto/tls"
+	"encoding/json"
 	"fmt"
-	"io"
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/AlecAivazis/survey/v2/terminal"
+	"github.com/creasty/defaults"
+	"github.com/pterodactyl/wings/config"
+	"github.com/spf13/cobra"
+	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os"
 	"path"
 	"regexp"
 	"time"
-
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/AlecAivazis/survey/v2/terminal"
-	"github.com/goccy/go-json"
-	"github.com/spf13/cobra"
-
-	"github.com/pterodactyl/wings/config"
 )
 
-var configureArgs struct {
+var (
-	PanelURL      string
+	configureArgs struct {
-	Token         string
+		PanelURL      string
-	ConfigPath    string
+		Token         string
-	Node          string
+		ConfigPath    string
-	Override      bool
+		Node          string
-	AllowInsecure bool
+		Override      bool
-}
+		AllowInsecure bool
+	}
+)
 
 var nodeIdRegex = regexp.MustCompile(`^(\d+)$`)
 
@@ -138,16 +139,16 @@ 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, _ := io.ReadAll(res.Body)
+		b, _ := ioutil.ReadAll(res.Body)
 
 		fmt.Println("An error occurred while processing this request.\n", string(b))
 		os.Exit(1)
 	}
 
-	b, err := io.ReadAll(res.Body)
+	b, err := ioutil.ReadAll(res.Body)
 
-	cfg, err := config.NewAtPath(configPath)
+	cfg := new(config.Configuration)
-	if err != nil {
+	if err := defaults.Set(cfg); err != nil {
 		panic(err)
 	}
 
@@ -155,7 +156,7 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 		panic(err)
 	}
 
-	if err = config.WriteToDisk(cfg); err != nil {
+	if err = cfg.WriteToDisk(); err != nil {
 		panic(err)
 	}
 

cmd/diagnostics.go

@@ -1,262 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os/exec"
-	"path"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/AlecAivazis/survey/v2"
-	"github.com/AlecAivazis/survey/v2/terminal"
-	"github.com/apex/log"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/pkg/parsers/kernel"
-	"github.com/docker/docker/pkg/parsers/operatingsystem"
-	"github.com/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"
-)
-
-const (
-	DefaultHastebinUrl = "https://ptero.co"
-	DefaultLogLines    = 200
-)
-
-var diagnosticsArgs struct {
-	IncludeEndpoints   bool
-	IncludeLogs        bool
-	ReviewBeforeUpload bool
-	HastebinURL        string
-	LogLines           int
-}
-
-func newDiagnosticsCommand() *cobra.Command {
-	command := &cobra.Command{
-		Use:   "diagnostics",
-		Short: "Collect and report information about this Wings instance to assist in debugging.",
-		PreRun: func(cmd *cobra.Command, args []string) {
-			initConfig()
-			log.SetHandler(cli.Default)
-		},
-		Run: diagnosticsCmdRun,
-	}
-
-	command.Flags().StringVar(&diagnosticsArgs.HastebinURL, "hastebin-url", DefaultHastebinUrl, "the url of the hastebin instance to use")
-	command.Flags().IntVar(&diagnosticsArgs.LogLines, "log-lines", DefaultLogLines, "the number of log lines to include in the report")
-
-	return command
-}
-
-// diagnosticsCmdRun collects diagnostics about wings, its configuration and the node.
-// We collect:
-// - wings and docker versions
-// - relevant parts of daemon configuration
-// - the docker debug output
-// - running docker containers
-// - logs
-func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
-	questions := []*survey.Question{
-		{
-			Name:   "IncludeEndpoints",
-			Prompt: &survey.Confirm{Message: "Do you want to include endpoints (i.e. the FQDN/IP of your panel)?", Default: false},
-		},
-		{
-			Name:   "IncludeLogs",
-			Prompt: &survey.Confirm{Message: "Do you want to include the latest logs?", Default: true},
-		},
-		{
-			Name: "ReviewBeforeUpload",
-			Prompt: &survey.Confirm{
-				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,
-			},
-		},
-	}
-	if err := survey.Ask(questions, &diagnosticsArgs); err != nil {
-		if err == terminal.InterruptErr {
-			return
-		}
-		panic(err)
-	}
-
-	dockerVersion, dockerInfo, dockerErr := getDockerInfo()
-
-	output := &strings.Builder{}
-	fmt.Fprintln(output, "Pterodactyl Wings - Diagnostics Report")
-	printHeader(output, "Versions")
-	fmt.Fprintln(output, "               Wings:", system.Version)
-	if dockerErr == nil {
-		fmt.Fprintln(output, "              Docker:", dockerVersion.Version)
-	}
-	if v, err := kernel.GetKernelVersion(); err == nil {
-		fmt.Fprintln(output, "              Kernel:", v)
-	}
-	if os, err := operatingsystem.GetOperatingSystem(); err == nil {
-		fmt.Fprintln(output, "                  OS:", os)
-	}
-
-	printHeader(output, "Wings Configuration")
-	if err := config.FromFile(config.DefaultLocation); err != nil {
-	}
-	cfg := config.Get()
-	fmt.Fprintln(output, "      Panel Location:", redact(cfg.PanelLocation))
-	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "  Internal Webserver:", redact(cfg.Api.Host), ":", cfg.Api.Port)
-	fmt.Fprintln(output, "         SSL Enabled:", cfg.Api.Ssl.Enabled)
-	fmt.Fprintln(output, "     SSL Certificate:", redact(cfg.Api.Ssl.CertificateFile))
-	fmt.Fprintln(output, "             SSL Key:", redact(cfg.Api.Ssl.KeyFile))
-	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "         SFTP Server:", redact(cfg.System.Sftp.Address), ":", cfg.System.Sftp.Port)
-	fmt.Fprintln(output, "      SFTP Read-Only:", cfg.System.Sftp.ReadOnly)
-	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "      Root Directory:", cfg.System.RootDirectory)
-	fmt.Fprintln(output, "      Logs Directory:", cfg.System.LogDirectory)
-	fmt.Fprintln(output, "      Data Directory:", cfg.System.Data)
-	fmt.Fprintln(output, "   Archive Directory:", cfg.System.ArchiveDirectory)
-	fmt.Fprintln(output, "    Backup Directory:", cfg.System.BackupDirectory)
-	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "            Username:", cfg.System.Username)
-	fmt.Fprintln(output, "         Server Time:", time.Now().Format(time.RFC1123Z))
-	fmt.Fprintln(output, "          Debug Mode:", cfg.Debug)
-
-	printHeader(output, "Docker: Info")
-	if dockerErr == nil {
-		fmt.Fprintln(output, "Server Version:", dockerInfo.ServerVersion)
-		fmt.Fprintln(output, "Storage Driver:", dockerInfo.Driver)
-		if dockerInfo.DriverStatus != nil {
-			for _, pair := range dockerInfo.DriverStatus {
-				fmt.Fprintf(output, "  %s: %s\n", pair[0], pair[1])
-			}
-		}
-		if dockerInfo.SystemStatus != nil {
-			for _, pair := range dockerInfo.SystemStatus {
-				fmt.Fprintf(output, " %s: %s\n", pair[0], pair[1])
-			}
-		}
-		fmt.Fprintln(output, "LoggingDriver:", dockerInfo.LoggingDriver)
-		fmt.Fprintln(output, " CgroupDriver:", dockerInfo.CgroupDriver)
-		if len(dockerInfo.Warnings) > 0 {
-			for _, w := range dockerInfo.Warnings {
-				fmt.Fprintln(output, w)
-			}
-		}
-	} else {
-		fmt.Fprintln(output, dockerErr.Error())
-	}
-
-	printHeader(output, "Docker: Running Containers")
-	c := exec.Command("docker", "ps")
-	if co, err := c.Output(); err == nil {
-		output.Write(co)
-	} else {
-		fmt.Fprint(output, "Couldn't list containers: ", err)
-	}
-
-	printHeader(output, "Latest Wings Logs")
-	if diagnosticsArgs.IncludeLogs {
-		p := "/var/log/pterodactyl/wings.log"
-		if cfg != nil {
-			p = path.Join(cfg.System.LogDirectory, "wings.log")
-		}
-		if c, err := exec.Command("tail", "-n", strconv.Itoa(diagnosticsArgs.LogLines), p).Output(); err != nil {
-			fmt.Fprintln(output, "No logs found or an error occurred.")
-		} else {
-			fmt.Fprintf(output, "%s\n", string(c))
-		}
-	} else {
-		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")
-
-	upload := !diagnosticsArgs.ReviewBeforeUpload
-	if !upload {
-		survey.AskOne(&survey.Confirm{Message: "Upload to " + diagnosticsArgs.HastebinURL + "?", Default: false}, &upload)
-	}
-	if upload {
-		u, err := uploadToHastebin(diagnosticsArgs.HastebinURL, output.String())
-		if err == nil {
-			fmt.Println("Your report is available here: ", u)
-		}
-	}
-}
-
-func getDockerInfo() (types.Version, types.Info, error) {
-	client, err := environment.Docker()
-	if err != nil {
-		return types.Version{}, types.Info{}, err
-	}
-	dockerVersion, err := client.ServerVersion(context.Background())
-	if err != nil {
-		return types.Version{}, types.Info{}, err
-	}
-	dockerInfo, err := client.Info(context.Background())
-	if err != nil {
-		return types.Version{}, types.Info{}, err
-	}
-	return dockerVersion, dockerInfo, nil
-}
-
-func uploadToHastebin(hbUrl, content string) (string, error) {
-	r := strings.NewReader(content)
-	u, err := url.Parse(hbUrl)
-	if err != nil {
-		return "", err
-	}
-	u.Path = path.Join(u.Path, "documents")
-	res, err := http.Post(u.String(), "plain/text", r)
-	if err != nil || res.StatusCode != 200 {
-		fmt.Println("Failed to upload report to ", u.String(), err)
-		return "", err
-	}
-	pres := make(map[string]interface{})
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		fmt.Println("Failed to parse response.", err)
-		return "", err
-	}
-	json.Unmarshal(body, &pres)
-	if key, ok := pres["key"].(string); ok {
-		u, _ := url.Parse(hbUrl)
-		u.Path = path.Join(u.Path, key)
-		return u.String(), nil
-	}
-	return "", errors.New("failed to find key in response")
-}
-
-func redact(s string) string {
-	if !diagnosticsArgs.IncludeEndpoints {
-		return "{redacted}"
-	}
-	return s
-}
-
-func printHeader(w io.Writer, title string) {
-	fmt.Fprintln(w, "\n|\n|", title)
-	fmt.Fprintln(w, "| ------------------------------")
-}

cmd/root.go

@@ -1,443 +1,275 @@
 package cmd
 
 import (
-	"context"
 	"crypto/tls"
-	"errors"
 	"fmt"
-	"github.com/pterodactyl/wings/internal/cron"
+	"github.com/mitchellh/colorstring"
-	"github.com/pterodactyl/wings/internal/database"
-	log2 "log"
 	"net/http"
-	_ "net/http/pprof"
 	"os"
 	"path"
-	"path/filepath"
-	"runtime"
-	"strconv"
 	"strings"
-	"time"
-
-	"github.com/NYTimes/logrotate"
-	"github.com/apex/log"
-	"github.com/apex/log/handlers/multi"
-	"github.com/docker/docker/client"
-	"github.com/gammazero/workerpool"
-	"github.com/mitchellh/colorstring"
-	"github.com/spf13/cobra"
-	"golang.org/x/crypto/acme"
-	"golang.org/x/crypto/acme/autocert"
 
+	"github.com/pkg/errors"
+	"github.com/pkg/profile"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/loggers/cli"
-	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/sftp"
 	"github.com/pterodactyl/wings/system"
+	"github.com/remeh/sizedwaitgroup"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
 )
 
-var (
+var configPath = config.DefaultLocation
-	configPath = config.DefaultLocation
+var debug = false
-	debug      = false
+var shouldRunProfiler = false
-)
 
-var rootCommand = &cobra.Command{
+var root = &cobra.Command{
 	Use:   "wings",
-	Short: "Runs the API server allowing programmatic control of game servers for Pterodactyl Panel.",
+	Short: "The wings of the pterodactyl game management panel",
-	PreRun: func(cmd *cobra.Command, args []string) {
+	Long:  ``,
-		initConfig()
+	Run:   rootCmdRun,
-		initLogging()
-		if tls, _ := cmd.Flags().GetBool("auto-tls"); tls {
-			if host, _ := cmd.Flags().GetString("tls-hostname"); host == "" {
-				fmt.Println("A TLS hostname must be provided when running wings with automatic TLS, e.g.:\n\n    ./wings --auto-tls --tls-hostname my.example.com")
-				os.Exit(1)
-			}
-		}
-	},
-	Run: rootCmdRun,
-}
-
-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 - %d Dane Everitt & Contributors\n", system.Version, time.Now().Year())
-	},
-}
-
-func Execute() {
-	if err := rootCommand.Execute(); err != nil {
-		log2.Fatalf("failed to execute command: %s", err)
-	}
 }
 
 func init() {
-	rootCommand.PersistentFlags().StringVar(&configPath, "config", config.DefaultLocation, "set the location for the configuration file")
+	root.PersistentFlags().StringVar(&configPath, "config", config.DefaultLocation, "set the location for the configuration file")
-	rootCommand.PersistentFlags().BoolVar(&debug, "debug", false, "pass in order to run wings in debug mode")
+	root.PersistentFlags().BoolVar(&debug, "debug", false, "pass in order to run wings in debug mode")
+	root.PersistentFlags().BoolVar(&shouldRunProfiler, "profile", false, "pass in order to profile wings")
 
-	// Flags specifically used when running the API.
+	root.AddCommand(configureCmd)
-	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 its 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")
-
-	rootCommand.AddCommand(versionCommand)
-	rootCommand.AddCommand(configureCmd)
-	rootCommand.AddCommand(newDiagnosticsCommand())
 }
 
-func rootCmdRun(cmd *cobra.Command, _ []string) {
+// Get the configuration path based on the arguments provided.
-	printLogo()
+func readConfiguration() (*config.Configuration, error) {
-	log.Debug("running in debug mode")
+	var p = configPath
-	log.WithField("config_file", configPath).Info("loading configuration from file")
+	if !strings.HasPrefix(p, "/") {
+		d, err := os.Getwd()
+		if err != nil {
+			return nil, err
+		}
+
+		p = path.Clean(path.Join(d, configPath))
+	}
+
+	if s, err := os.Stat(p); err != nil {
+		return nil, errors.WithStack(err)
+	} else if s.IsDir() {
+		return nil, errors.New("cannot use directory as configuration file path")
+	}
+
+	return config.ReadConfiguration(p)
+}
+
+func rootCmdRun(*cobra.Command, []string) {
+	if shouldRunProfiler {
+		defer profile.Start().Stop()
+	}
+
+	// Only attempt configuration file relocation if a custom location has not
+	// been specified in the command startup.
+	if configPath == config.DefaultLocation {
+		if err := RelocateConfiguration(); err != nil {
+			if os.IsNotExist(err) {
+				exitWithConfigurationNotice()
+			}
+
+			panic(err)
+		}
+	}
+
+	c, err := readConfiguration()
+	if err != nil {
+		panic(err)
+	}
+
+	if debug {
+		c.Debug = true
+	}
+
+	printLogo()
+	if err := configureLogging(c.Debug); err != nil {
+		panic(err)
+	}
+
+	zap.S().Infof("using configuration from path: %s", c.GetPath())
+	if c.Debug {
+		zap.S().Debugw("running in debug mode")
+		zap.S().Infow("certificate checking is disabled")
 
-	if ok, _ := cmd.Flags().GetBool("ignore-certificate-errors"); ok {
-		log.Warn("running with --ignore-certificate-errors: TLS certificate host chains and name will not be verified")
 		http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{
 			InsecureSkipVerify: true,
 		}
 	}
 
-	if err := config.ConfigureTimezone(); err != nil {
+	config.Set(c)
-		log.WithField("error", err).Fatal("failed to detect system timezone or use supplied configuration value")
+	config.SetDebugViaFlag(debug)
-	}
+
-	log.WithField("timezone", config.Get().System.Timezone).Info("configured wings with system timezone")
+	if err := c.System.ConfigureDirectories(); err != nil {
-	if err := config.ConfigureDirectories(); err != nil {
+		zap.S().Panicw("failed to configure system directories for pterodactyl", zap.Error(err))
-		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
-		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")
-	}
-	log.WithFields(log.Fields{
-		"username": config.Get().System.Username,
-		"uid":      config.Get().System.User.Uid,
-		"gid":      config.Get().System.User.Gid,
-	}).Info("configured system user successfully")
-	if err := config.EnableLogRotation(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
 		return
 	}
 
-	pclient := remote.New(
+	zap.S().Infof("checking for pterodactyl system user \"%s\"", c.System.Username)
-		config.Get().PanelLocation,
+	if su, err := c.EnsurePterodactylUser(); err != nil {
-		remote.WithCredentials(config.Get().AuthenticationTokenId, config.Get().AuthenticationToken),
+		zap.S().Panicw("failed to create pterodactyl system user", zap.Error(err))
-		remote.WithHttpClient(&http.Client{
+		return
-			Timeout: time.Second * time.Duration(config.Get().RemoteQuery.Timeout),
+	} else {
-		}),
+		zap.S().Infow("configured system user", zap.String("username", su.Username), zap.String("uid", su.Uid), zap.String("gid", su.Gid))
-	)
-
-	if err := database.Initialize(); err != nil {
-		log.WithField("error", err).Fatal("failed to initialize database")
 	}
 
-	manager, err := server.NewManager(cmd.Context(), pclient)
+	zap.S().Infow("beginning file permission setting on server data directories")
-	if err != nil {
+	if err := c.EnsureFilePermissions(); err != nil {
-		log.WithField("error", err).Fatal("failed to load server configurations")
+		zap.S().Errorw("failed to properly chown data directories", zap.Error(err))
+	} else {
+		zap.S().Infow("finished ensuring file permissions")
 	}
 
-	if err := environment.ConfigureDocker(cmd.Context()); err != nil {
+	if err := server.LoadDirectory(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure docker environment")
+		zap.S().Fatalw("failed to load server configurations", zap.Error(errors.WithStack(err)))
+		return
 	}
 
-	if err := config.WriteToDisk(config.Get()); err != nil {
+	if err := environment.ConfigureDocker(&c.Docker); err != nil {
-		log.WithField("error", err).Fatal("failed to write configuration to disk")
+		zap.S().Fatalw("failed to configure docker environment", zap.Error(errors.WithStack(err)))
+		os.Exit(1)
+	}
+
+	if err := c.WriteToDisk(); err != nil {
+		zap.S().Errorw("failed to save configuration to disk", zap.Error(errors.WithStack(err)))
 	}
 
 	// Just for some nice log output.
-	for _, s := range manager.All() {
+	for _, s := range server.GetServers().All() {
-		log.WithField("server", s.ID()).Info("finished loading configuration for server")
+		zap.S().Infow("loaded configuration for server", zap.String("server", s.Uuid))
 	}
 
-	states, err := manager.ReadStates()
+	// Create a new WaitGroup that limits us to 4 servers being bootstrapped at a time
-	if err != nil {
-		log.WithField("error", err).Error("failed to retrieve locally cached server states from disk, assuming all servers in offline state")
-	}
-
-	ticker := time.NewTicker(time.Minute)
-	// Every minute, write the current server states to the disk to allow for a more
-	// seamless hard-reboot process in which wings will re-sync server states based
-	// on its last tracked state.
-	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				if err := manager.PersistStates(); err != nil {
-					log.WithField("error", err).Warn("failed to persist server states to disk")
-				}
-			case <-cmd.Context().Done():
-				ticker.Stop()
-				return
-			}
-		}
-	}()
-
-	// Create a new workerpool that limits us to 4 servers being bootstrapped at a time
 	// on Wings. This allows us to ensure the environment exists, write configurations,
 	// and reboot processes without causing a slow-down due to sequential booting.
-	pool := workerpool.New(4)
+	wg := sizedwaitgroup.New(4)
-	for _, serv := range manager.All() {
-		s := serv
 
-		// For each server we encounter make sure the root data directory exists.
+	for _, serv := range server.GetServers().All() {
-		if err := s.EnsureDataDirectoryExists(); err != nil {
+		wg.Add()
-			s.Log().Error("could not create root data directory for server: not loading server...")
-			continue
-		}
 
-		pool.Submit(func() {
+		go func(s *server.Server) {
-			s.Log().Info("configuring server environment and restoring to previous state")
+			defer wg.Done()
-			var st string
+
-			if state, exists := states[s.ID()]; exists {
+			// Create a server environment if none exists currently. This allows us to recover from Docker
-				st = state
+			// being reinstalled on the host system for example.
+			zap.S().Infow("ensuring environment exists", zap.String("server", s.Uuid))
+			if err := s.Environment.Create(); err != nil {
+				zap.S().Errorw("failed to create an environment for server", zap.String("server", s.Uuid), zap.Error(err))
 			}
 
-			// Use a timed context here to avoid booting issues where Docker hangs for a
+			r, err := s.Environment.IsRunning()
-			// specific container that would cause Wings to be un-bootable until the entire
+			if err != nil {
-			// machine is rebooted. It is much better for us to just have a single failed
+				zap.S().Errorw("error checking server environment status", zap.String("server", s.Uuid), zap.Error(err))
-			// server instance than an entire offline node.
+			}
+
+			// If the server is currently running on Docker, mark the process as being in that state.
+			// We never want to stop an instance that is currently running external from Wings since
+			// that is a good way of keeping things running even if Wings gets in a very corrupted state.
 			//
-			// @see https://github.com/pterodactyl/panel/issues/2475
+			// This will also validate that a server process is running if the last tracked state we have
-			// @see https://github.com/pterodactyl/panel/issues/3358
+			// is that it was running, but we see that the container process is not currently running.
-			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*30)
+			if r || (!r && s.IsRunning()) {
-			defer cancel()
+				zap.S().Infow("detected server is running, re-attaching to process", zap.String("server", s.Uuid))
+				if err := s.Environment.Start(); err != nil {
+					zap.S().Warnw(
+						"failed to properly start server detected as already running",
+						zap.String("server", s.Uuid),
+						zap.Error(errors.WithStack(err)),
+					)
+				}
 
-			r, err := s.Environment.IsRunning(ctx)
+				return
-			// 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 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")
 			}
 
-			// Check if the server was previously running. If so, attempt to start the server now so that Wings
+			// Addresses potentially invalid data in the stored file that can cause Wings to lose
-			// can pick up where it left off. If the environment does not exist at all, just create it and then allow
+			// track of what the actual server state is.
-			// the normal flow to execute.
+			s.SetState(server.ProcessOfflineState)
-			//
+		}(serv)
-			// This does mean that booting wings after a catastrophic machine crash and wiping out the Docker images
-			// as a result will result in a slow boot.
-			if !r && (st == environment.ProcessRunningState || st == environment.ProcessStartingState) {
-				if err := s.HandlePowerAction(server.PowerActionStart); err != nil {
-					s.Log().WithField("error", err).Warn("failed to return server to running state")
-				}
-			} else if r || (!r && s.IsRunning()) {
-				// If the server is currently running on Docker, mark the process as being in that state.
-				// We never want to stop an instance that is currently running external from Wings since
-				// that is a good way of keeping things running even if Wings gets in a very corrupted state.
-				//
-				// This will also validate that a server process is running if the last tracked state we have
-				// is that it was running, but we see that the container process is not currently running.
-				s.Log().Info("detected server is running, re-attaching to process...")
-
-				s.Environment.SetState(environment.ProcessRunningState)
-				if err := s.Environment.Attach(ctx); err != nil {
-					s.Log().WithField("error", err).Warn("failed to attach to running server environment")
-				}
-			} else {
-				// At this point we've determined that the server should indeed be in an offline state, so we'll
-				// make a call to set that state just to ensure we don't ever accidentally end up with some invalid
-				// 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 the servers are ready to go before we fire up the SFTP and HTTP servers.
+	// Wait until all of the servers are ready to go before we fire up the HTTP server.
-	pool.StopWait()
+	wg.Wait()
-	defer func() {
-		// 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()
-		}
-	}()
 
-	if s, err := cron.Scheduler(cmd.Context(), manager); err != nil {
+	// If the SFTP subsystem should be started, do so now.
-		log.WithField("error", err).Fatal("failed to initialize cron system")
+	if c.System.Sftp.UseInternalSystem {
-	} else {
+		sftp.Initialize(c)
-		log.WithField("subsystem", "cron").Info("starting cron processes")
-		s.StartAsync()
 	}
 
-	go func() {
-		// Run the SFTP server.
-		if err := sftp.New(manager).Run(); err != nil {
-			log.WithError(err).Fatal("failed to initialize the sftp server")
-			return
-		}
-	}()
-
-	go func() {
-		log.Info("updating server states on Panel: marking installing/restoring servers as normal")
-		// Update all the servers on the Panel to be in a valid state if they're
-		// currently marked as installing/restoring now that Wings is restarted.
-		if err := pclient.ResetServersState(cmd.Context()); err != nil {
-			log.WithField("error", err).Error("failed to reset server states on Panel: some instances may be stuck in an installing/restoring state unexpectedly")
-		}
-	}()
-
-	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(sys.ArchiveDirectory, 0o755); err != nil {
+	if err := os.MkdirAll(c.System.ArchiveDirectory, 0755); err != nil {
-		log.WithField("error", err).Error("failed to create archive directory")
+		zap.S().Errorw("failed to create archive directory", zap.Error(err))
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(sys.BackupDirectory, 0o755); err != nil {
+	if err := os.MkdirAll(c.System.BackupDirectory, 0755); err != nil {
-		log.WithField("error", err).Error("failed to create backup directory")
+		zap.S().Errorw("failed to create backup directory", zap.Error(err))
 	}
 
-	autotls, _ := cmd.Flags().GetBool("auto-tls")
+	zap.S().Infow("configuring webserver", zap.Bool("ssl", c.Api.Ssl.Enabled), zap.String("host", c.Api.Host), zap.Int("port", c.Api.Port))
-	tlshostname, _ := cmd.Flags().GetString("tls-hostname")
-	if autotls && tlshostname == "" {
-		autotls = false
-	}
 
-	api := config.Get().Api
+	r := router.Configure()
-	log.WithFields(log.Fields{
+	addr := fmt.Sprintf("%s:%d", c.Api.Host, c.Api.Port)
-		"use_ssl":      api.Ssl.Enabled,
-		"use_auto_tls": autotls,
-		"host_address": api.Host,
-		"host_port":    api.Port,
-	}).Info("configuring internal webserver")
 
-	// Create a new HTTP server instance to handle inbound requests from the Panel
+	if c.Api.Ssl.Enabled {
-	// and external clients.
+		if err := r.RunTLS(addr, c.Api.Ssl.CertificateFile, c.Api.Ssl.KeyFile); err != nil {
-	s := &http.Server{
+			zap.S().Fatalw("failed to configure HTTPS server", zap.Error(err))
-		Addr:      api.Host + ":" + strconv.Itoa(api.Port),
-		Handler:   router.Configure(manager, pclient),
-		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.
+	} else {
-		runtime.SetMutexProfileFraction(100)
+		if err := r.Run(addr); err != nil {
-
+			zap.S().Fatalw("failed to configure HTTP server", zap.Error(err))
-		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.
-	if autotls {
-		m := autocert.Manager{
-			Prompt:     autocert.AcceptTOS,
-			Cache:      autocert.DirCache(path.Join(sys.RootDirectory, "/.tls-cache")),
-			HostPolicy: autocert.HostWhitelist(tlshostname),
 		}
-
-		log.WithField("hostname", tlshostname).Info("webserver is now listening with auto-TLS enabled; certificates will be automatically generated by Let's Encrypt")
-
-		// Hook autocert into the main http server.
-		s.TLSConfig.GetCertificate = m.GetCertificate
-		s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, acme.ALPNProto) // enable tls-alpn ACME challenges
-
-		// Start the autocert server.
-		go func() {
-			if err := http.ListenAndServe(":http", m.HTTPHandler(nil)); err != nil {
-				log.WithError(err).Error("failed to serve autocert http server")
-			}
-		}()
-		// Start the main http server with TLS using autocert.
-		if err := s.ListenAndServeTLS("", ""); err != nil {
-			log.WithFields(log.Fields{"auto_tls": true, "tls_hostname": tlshostname, "error": err}).Fatal("failed to configure HTTP server using auto-tls")
-		}
-		return
-	}
-
-	// 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(api.Ssl.CertificateFile, api.Ssl.KeyFile); err != nil {
-			log.WithFields(log.Fields{"auto_tls": false, "error": err}).Fatal("failed to configure HTTPS server")
-		}
-		return
-	}
-	s.TLSConfig = nil
-	if err := s.ListenAndServe(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure HTTP server")
 	}
 }
 
-// Reads the configuration from the disk and then sets up the global singleton
+// Execute calls cobra to handle cli commands
-// with all the configuration values.
+func Execute() error {
-func initConfig() {
+	return root.Execute()
-	if !strings.HasPrefix(configPath, "/") {
-		d, err := os.Getwd()
-		if err != nil {
-			log2.Fatalf("cmd/root: could not determine directory: %s", err)
-		}
-		configPath = path.Clean(path.Join(d, configPath))
-	}
-	err := config.FromFile(configPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			exitWithConfigurationNotice()
-		}
-		log2.Fatalf("cmd/root: error while reading configuration file: %s", err)
-	}
-	if debug && !config.Get().Debug {
-		config.SetDebugViaFlag(debug)
-	}
 }
 
 // Configures the global logger for Zap so that we can call it from any location
 // in the code without having to pass around a logger instance.
-func initLogging() {
+func configureLogging(debug bool) error {
-	dir := config.Get().System.LogDirectory
+	cfg := zap.NewProductionConfig()
-	if err := os.MkdirAll(path.Join(dir, "/install"), 0o700); err != nil {
+	if debug {
-		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
+		cfg = zap.NewDevelopmentConfig()
 	}
-	p := filepath.Join(dir, "/wings.log")
+
-	w, err := logrotate.NewFile(p)
+	cfg.Encoding = "console"
+	cfg.OutputPaths = []string{
+		"stdout",
+	}
+
+	logger, err := cfg.Build()
 	if err != nil {
-		log2.Fatalf("cmd/root: failed to create wings log: %s", err)
+		return err
 	}
-	log.SetLevel(log.InfoLevel)
+
-	if config.Get().Debug {
+	zap.ReplaceGlobals(logger)
-		log.SetLevel(log.DebugLevel)
+
-	}
+	return nil
-	log.SetHandler(multi.New(cli.Default, cli.New(w.File, false)))
-	log.WithField("path", p).Info("writing log files to disk")
 }
 
 // Prints the wings logo, nothing special here!
 func printLogo() {
-	fmt.Printf(colorstring.Color(`
+	fmt.Println()
-                     ____
+	fmt.Println(`                     ____`)
-__ [blue][bold]Pterodactyl[reset] _____/___/_______ _______ ______
+	fmt.Println(`__ Pterodactyl _____/___/_______ _______ ______`)
-\_____\    \/\/    /   /       /  __   /   ___/
+	fmt.Println(`\_____\    \/\/    /   /       /  __   /   ___/`)
-   \___\          /   /   /   /  /_/  /___   /
+	fmt.Println(`   \___\          /   /   /   /  /_/  /___   /`)
-        \___/\___/___/___/___/___    /______/
+	fmt.Println(`        \___/\___/___/___/___/___    /______/`)
-                            /_______/ [bold]%s[reset]
+	fmt.Println(`                            /_______/ v` + system.Version)
-
+	fmt.Println()
-Copyright © 2018 - %d Dane Everitt & Contributors
+	fmt.Println(`Website: https://pterodactyl.io`)
-
+	fmt.Println(`Source: https://github.com/pterodactyl/wings`)
-Website:  https://pterodactyl.io
+	fmt.Println()
- Source:  https://github.com/pterodactyl/wings
+	fmt.Println(`Copyright © 2018 - 2020 Dane Everitt & Contributors`)
-License:  https://github.com/pterodactyl/wings/blob/develop/LICENSE
+	fmt.Println()
-
-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, time.Now().Year(), "\n\n")
 }
 
 func exitWithConfigurationNotice() {
@@ -445,8 +277,11 @@ func exitWithConfigurationNotice() {
 [_red_][white][bold]Error: Configuration File Not Found[reset]
 
 Wings was not able to locate your configuration file, and therefore is not
-able to complete its boot process. Please ensure you have copied your instance
+able to complete its boot process.
-configuration file into the default location below.
+
+Please ensure you have copied your instance configuration file into
+the default location, or have provided the --config flag to use a
+custom location.
 
 Default Location: /etc/pterodactyl/config.yml
 

config/config.go

@@ -1,272 +1,40 @@
 package config
 
 import (
-	"context"
+	"errors"
-	"crypto/tls"
 	"fmt"
+	"github.com/cobaugh/osrelease"
+	"github.com/creasty/defaults"
+	"github.com/gbrlsnchs/jwt/v3"
+	"go.uber.org/zap"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/user"
 	"path"
-	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 	"sync"
-	"text/template"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/cobaugh/osrelease"
-	"github.com/creasty/defaults"
-	"github.com/gbrlsnchs/jwt/v3"
-	"gopkg.in/yaml.v2"
-
-	"github.com/pterodactyl/wings/system"
 )
 
 const DefaultLocation = "/etc/pterodactyl/config.yml"
 
-// DefaultTLSConfig sets sane defaults to use when configuring the internal
-// webserver to listen for public connections.
-//
-// @see https://blog.cloudflare.com/exposing-go-on-the-internet
-var DefaultTLSConfig = &tls.Config{
-	NextProtos: []string{"h2", "http/1.1"},
-	CipherSuites: []uint16{
-		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-		tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-		tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
-		tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
-	},
-	PreferServerCipherSuites: true,
-	MinVersion:               tls.VersionTLS12,
-	MaxVersion:               tls.VersionTLS13,
-	CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
-}
-
-var (
-	mu            sync.RWMutex
-	_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.
-var _writeLock sync.Mutex
-
-// SftpConfiguration defines the configuration of the internal SFTP server.
-type SftpConfiguration struct {
-	// The bind address of the SFTP server.
-	Address string `default:"0.0.0.0" json:"bind_address" yaml:"bind_address"`
-	// The bind port of the SFTP server.
-	Port int `default:"2022" json:"bind_port" yaml:"bind_port"`
-	// If set to true, no write actions will be allowed on the SFTP server.
-	ReadOnly bool `default:"false" yaml:"read_only"`
-}
-
-// ApiConfiguration defines the configuration for the internal API that is
-// exposed by the Wings webserver.
-type ApiConfiguration struct {
-	// The interface that the internal webserver should bind to.
-	Host string `default:"0.0.0.0" yaml:"host"`
-
-	// The port that the internal webserver should bind to.
-	Port int `default:"8080" yaml:"port"`
-
-	// SSL configuration for the daemon.
-	Ssl struct {
-		Enabled         bool   `json:"enabled" yaml:"enabled"`
-		CertificateFile string `json:"cert" yaml:"cert"`
-		KeyFile         string `json:"key" yaml:"key"`
-	}
-
-	// Determines if functionality for allowing remote download of files into server directories
-	// is enabled on this instance. If set to "true" remote downloads will not be possible for
-	// servers.
-	DisableRemoteDownload bool `json:"disable_remote_download" yaml:"disable_remote_download"`
-
-	// The maximum size for files uploaded through the Panel in MB.
-	UploadLimit int64 `default:"100" json:"upload_limit" yaml:"upload_limit"`
-
-	// A list of IP address of proxies that may send a X-Forwarded-For header to set the true clients IP
-	TrustedProxies []string `json:"trusted_proxies" yaml:"trusted_proxies"`
-}
-
-// RemoteQueryConfiguration defines the configuration settings for remote requests
-// from Wings to the Panel.
-type RemoteQueryConfiguration struct {
-	// The amount of time in seconds that Wings should allow for a request to the Panel API
-	// to complete. If this time passes the request will be marked as failed. If your requests
-	// are taking longer than 30 seconds to complete it is likely a performance issue that
-	// should be resolved on the Panel, and not something that should be resolved by upping this
-	// number.
-	Timeout int `default:"30" yaml:"timeout"`
-
-	// The number of servers to load in a single request to the Panel API when booting the
-	// Wings instance. A single request is initially made to the Panel to get this number
-	// of servers, and then the pagination status is checked and additional requests are
-	// fired off in parallel to request the remaining pages.
-	//
-	// It is not recommended to change this from the default as you will likely encounter
-	// memory limits on your Panel instance. In the grand scheme of things 4 requests for
-	// 50 servers is likely just as quick as two for 100 or one for 400, and will certainly
-	// be less likely to cause performance issues on the Panel.
-	BootServersPerPage int `default:"50" yaml:"boot_servers_per_page"`
-}
-
-// SystemConfiguration defines basic system configuration settings.
-type SystemConfiguration struct {
-	// The root directory where all of the pterodactyl data is stored at.
-	RootDirectory string `default:"/var/lib/pterodactyl" yaml:"root_directory"`
-
-	// Directory where logs for server installations and other wings events are logged.
-	LogDirectory string `default:"/var/log/pterodactyl" yaml:"log_directory"`
-
-	// Directory where the server data is stored at.
-	Data string `default:"/var/lib/pterodactyl/volumes" yaml:"data"`
-
-	// Directory where server archives for transferring will be stored.
-	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" yaml:"archive_directory"`
-
-	// Directory where local backups will be stored on the machine.
-	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`
-
-	// 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"`
-
-	// The timezone for this Wings instance. This is detected by Wings automatically if possible,
-	// and falls back to UTC if not able to be detected. If you need to set this manually, that
-	// can also be done.
-	//
-	// This timezone value is passed into all containers created by Wings.
-	Timezone string `yaml:"timezone"`
-
-	// Definitions for the user that gets created to ensure that we can quickly access
-	// this information without constantly having to do a system lookup.
-	User struct {
-		Uid int
-		Gid int
-	}
-
-	// The amount of time in seconds that can elapse before a server's disk space calculation is
-	// considered stale and a re-check should occur. DANGER: setting this value too low can seriously
-	// impact system performance and cause massive I/O bottlenecks and high CPU usage for the Wings
-	// process.
-	//
-	// Set to 0 to disable disk checking entirely. This will always return 0 for the disk space used
-	// by a server and should only be set in extreme scenarios where performance is critical and
-	// disk usage is not a concern.
-	DiskCheckInterval int64 `default:"150" yaml:"disk_check_interval"`
-
-	// ActivitySendInterval is the amount of time that should ellapse between aggregated server activity
-	// being sent to the Panel. By default this will send activity collected over the last minute. Keep
-	// in mind that only a fixed number of activity log entries, defined by ActivitySendCount, will be sent
-	// in each run.
-	ActivitySendInterval int `default:"60" yaml:"activity_send_interval"`
-
-	// ActivitySendCount is the number of activity events to send per batch.
-	ActivitySendCount int `default:"100" yaml:"activity_send_count"`
-
-	// If set to true, file permissions for a server will be checked when the process is
-	// booted. This can cause boot delays if the server has a large amount of files. In most
-	// cases disabling this should not have any major impact unless external processes are
-	// frequently modifying a servers' files.
-	CheckPermissionsOnBoot bool `default:"true" yaml:"check_permissions_on_boot"`
-
-	// If set to false Wings will not attempt to write a log rotate configuration to the disk
-	// when it boots and one is not detected.
-	EnableLogRotate bool `default:"true" yaml:"enable_log_rotate"`
-
-	// The number of lines to send when a server connects to the websocket.
-	WebsocketLogCount int `default:"150" yaml:"websocket_log_count"`
-
-	Sftp SftpConfiguration `yaml:"sftp"`
-
-	CrashDetection CrashDetection `yaml:"crash_detection"`
-
-	Backups Backups `yaml:"backups"`
-
-	Transfers Transfers `yaml:"transfers"`
-}
-
-type CrashDetection struct {
-	// 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.
-	DetectCleanExitAsCrash bool `default:"true" yaml:"detect_clean_exit_as_crash"`
-
-	// Timeout specifies the timeout between crashes that will not cause the server
-	// to be automatically restarted, this value is used to prevent servers from
-	// becoming stuck in a boot-loop after multiple consecutive crashes.
-	Timeout int `default:"60" json:"timeout"`
-}
-
-type Backups struct {
-	// WriteLimit imposes a Disk I/O write limit on backups to the disk, this affects all
-	// backup drivers as the archiver must first write the file to the disk in order to
-	// upload it to any external storage provider.
-	//
-	// If the value is less than 1, the write speed is unlimited,
-	// if the value is greater than 0, the write speed is the value in MiB/s.
-	//
-	// Defaults to 0 (unlimited)
-	WriteLimit int `default:"0" yaml:"write_limit"`
-
-	// CompressionLevel determines how much backups created by wings should be compressed.
-	//
-	// "none" -> no compression will be applied
-	// "best_speed" -> uses gzip level 1 for fast speed
-	// "best_compression" -> uses gzip level 9 for minimal disk space useage
-	//
-	// Defaults to "best_speed" (level 1)
-	CompressionLevel string `default:"best_speed" yaml:"compression_level"`
-}
-
-type Transfers struct {
-	// DownloadLimit imposes a Network I/O read limit when downloading a transfer archive.
-	//
-	// If the value is less than 1, the write speed is unlimited,
-	// if the value is greater than 0, the write speed is the value in MiB/s.
-	//
-	// Defaults to 0 (unlimited)
-	DownloadLimit int `default:"0" yaml:"download_limit"`
-}
-
-type ConsoleThrottles struct {
-	// Whether or not the throttler is enabled for this instance.
-	Enabled bool `json:"enabled" yaml:"enabled" default:"true"`
-
-	// The total number of lines that can be output in a given Period period before
-	// a warning is triggered and counted against the server.
-	Lines uint64 `json:"lines" yaml:"lines" default:"2000"`
-
-	// 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.
-	Period uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
-}
-
 type Configuration struct {
+	sync.RWMutex `json:"-" yaml:"-"`
+
 	// The location from which this configuration instance was instantiated.
 	path string
 
+	// Locker specific to writing the configuration to the disk, this happens
+	// in areas that might already be locked so we don't want to crash the process.
+	writeLock sync.Mutex
+
 	// Determines if wings should be running in debug mode. This value is ignored
 	// if the debug flag is passed through the command line arguments.
 	Debug bool
 
-	AppName string `default:"Pterodactyl" json:"app_name" yaml:"app_name"`
-
 	// A unique identifier for this node in the Panel.
 	Uuid string
 
@@ -282,362 +50,302 @@ type Configuration struct {
 	System SystemConfiguration `json:"system" yaml:"system"`
 	Docker DockerConfiguration `json:"docker" yaml:"docker"`
 
+	// The amount of time in seconds that should elapse between disk usage checks
+	// run by the daemon. Setting a higher number can result in better IO performance
+	// at an increased risk of a malicious user creating a process that goes over
+	// the assigned disk limits.
+	DiskCheckTimeout int `yaml:"disk_check_timeout"`
+
 	// Defines internal throttling configurations for server processes to prevent
 	// someone from running an endless loop that spams data to logs.
-	Throttles ConsoleThrottles
+	Throttles struct {
+		// The number of data overage warnings (inclusive) that can accumulate
+		// before a process is terminated.
+		KillAtCount int `default:"5" yaml:"kill_at_count"`
+
+		// The number of seconds that must elapse before the internal counter
+		// begins decrementing warnings assigned to a process that is outputting
+		// too much data.
+		DecaySeconds int `default:"10" json:"decay" yaml:"decay"`
+
+		// The total number of bytes allowed to be output by a server process
+		// per interval.
+		BytesPerInterval int `default:"4096" json:"bytes" yaml:"bytes"`
+
+		// The amount of time that should lapse between data output throttle
+		// checks. This should be defined in milliseconds.
+		CheckInterval int `default:"100" yaml:"check_interval"`
+	}
 
 	// The location where the panel is running that this daemon should connect to
 	// to collect data and send events.
-	PanelLocation string                   `json:"remote" yaml:"remote"`
+	PanelLocation string `json:"remote" yaml:"remote"`
-	RemoteQuery   RemoteQueryConfiguration `json:"remote_query" yaml:"remote_query"`
-
-	// AllowedMounts is a list of allowed host-system mount points.
-	// This is required to have the "Server Mounts" feature work properly.
-	AllowedMounts []string `json:"-" yaml:"allowed_mounts"`
-
-	// AllowedOrigins is a list of allowed request origins.
-	// 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.
+// Defines the configuration of the internal SFTP server.
-// This function does not modify the currently stored global configuration.
+type SftpConfiguration struct {
-func NewAtPath(path string) (*Configuration, error) {
+	// If set to false, the internal SFTP server will not be booted and you will need
-	var c Configuration
+	// to run the SFTP server independent of this program.
+	UseInternalSystem bool `default:"true" json:"use_internal" yaml:"use_internal"`
+	// If set to true disk checking will not be performed. This will prevent the SFTP
+	// server from checking the total size of a directory when uploading files.
+	DisableDiskChecking bool `default:"false" yaml:"disable_disk_checking"`
+	// The bind address of the SFTP server.
+	Address string `default:"0.0.0.0" json:"bind_address" yaml:"bind_address"`
+	// The bind port of the SFTP server.
+	Port int `default:"2022" json:"bind_port" yaml:"bind_port"`
+	// If set to true, no write actions will be allowed on the SFTP server.
+	ReadOnly bool `default:"false" yaml:"read_only"`
+}
+
+// Defines the configuration for the internal API that is exposed by the
+// daemon webserver.
+type ApiConfiguration struct {
+	// The interface that the internal webserver should bind to.
+	Host string `default:"0.0.0.0" yaml:"host"`
+
+	// The port that the internal webserver should bind to.
+	Port int `default:"8080" yaml:"port"`
+
+	// SSL configuration for the daemon.
+	Ssl struct {
+		Enabled         bool   `default:"false"`
+		CertificateFile string `json:"cert" yaml:"cert"`
+		KeyFile         string `json:"key" yaml:"key"`
+	}
+
+	// The maximum size for files uploaded through the Panel in bytes.
+	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
+}
+
+// Reads the configuration from the provided file and returns the configuration
+// object that can then be used.
+func ReadConfiguration(path string) (*Configuration, error) {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	c := new(Configuration)
 	// Configures the default values for many of the configuration options present
 	// in the structs. Values set in the configuration file take priority over the
 	// default values.
-	if err := defaults.Set(&c); err != nil {
+	if err := defaults.Set(c); err != nil {
 		return nil, err
 	}
+
 	// Track the location where we created this configuration.
 	c.path = path
-	return &c, nil
+
+	// Replace environment variables within the configuration file with their
+	// values from the host system.
+	b = []byte(os.ExpandEnv(string(b)))
+
+	if err := yaml.Unmarshal(b, c); err != nil {
+		return nil, err
+	}
+
+	return c, nil
 }
 
+var Mutex sync.RWMutex
+
+var _config *Configuration
+var _jwtAlgo *jwt.HMACSHA
+var _debugViaFlag bool
+
 // Set the global configuration instance. This is a blocking operation such that
 // anything trying to set a different configuration value, or read the configuration
 // will be paused until it is complete.
 func Set(c *Configuration) {
-	mu.Lock()
+	Mutex.Lock()
+
 	if _config == nil || _config.AuthenticationToken != c.AuthenticationToken {
 		_jwtAlgo = jwt.NewHS256([]byte(c.AuthenticationToken))
 	}
+
 	_config = c
-	mu.Unlock()
+	Mutex.Unlock()
 }
 
-// SetDebugViaFlag tracks if the application is running in debug mode because of
-// a command line flag argument. If so we do not want to store that configuration
-// change to the disk.
 func SetDebugViaFlag(d bool) {
-	mu.Lock()
-	_config.Debug = d
 	_debugViaFlag = d
-	mu.Unlock()
 }
 
-// Get returns the global configuration instance. This is a thread-safe operation
+// Get the global configuration instance. This is a read-safe operation that will block
-// that will block if the configuration is presently being modified.
+// if the configuration is presently being modified.
-//
-// Be aware that you CANNOT make modifications to the currently stored configuration
-// by modifying the struct returned by this function. The only way to make
-// modifications is by using the Update() function and passing data through in
-// the callback.
 func Get() *Configuration {
-	mu.RLock()
+	Mutex.RLock()
-	// Create a copy of the struct so that all modifications made beyond this
+	defer Mutex.RUnlock()
-	// point are immutable.
+
-	//goland:noinspection GoVetCopyLock
+	return _config
-	c := *_config
-	mu.RUnlock()
-	return &c
 }
 
-// Update performs an in-situ update of the global configuration object using
+// Returns the in-memory JWT algorithm.
-// a thread-safe mutex lock. This is the correct way to make modifications to
-// the global configuration.
-func Update(callback func(c *Configuration)) {
-	mu.Lock()
-	callback(_config)
-	mu.Unlock()
-}
-
-// GetJwtAlgorithm returns the in-memory JWT algorithm.
 func GetJwtAlgorithm() *jwt.HMACSHA {
-	mu.RLock()
+	Mutex.RLock()
-	defer mu.RUnlock()
+	defer Mutex.RUnlock()
+
 	return _jwtAlgo
 }
 
-// WriteToDisk writes the configuration to the disk. This is a thread safe operation
+// Returns the path for this configuration file.
-// and will only allow one write at a time. Additional calls while writing are
+func (c *Configuration) GetPath() string {
-// queued up.
+	return c.path
-func WriteToDisk(c *Configuration) error {
-	_writeLock.Lock()
-	defer _writeLock.Unlock()
-
-	//goland:noinspection GoVetCopyLock
-	ccopy := *c
-	// If debugging is set with the flag, don't save that to the configuration file,
-	// otherwise you'll always end up in debug mode.
-	if _debugViaFlag {
-		ccopy.Debug = false
-	}
-	if c.path == "" {
-		return errors.New("cannot write configuration, no path defined in struct")
-	}
-	b, err := yaml.Marshal(&ccopy)
-	if err != nil {
-		return err
-	}
-	if err := os.WriteFile(c.path, b, 0o600); err != nil {
-		return err
-	}
-	return nil
 }
 
-// EnsurePterodactylUser ensures that the Pterodactyl core user exists on the
+// Ensures that the Pterodactyl core user exists on the system. This user will be the
-// system. This user will be the owner of all data in the root data directory
+// owner of all data in the root data directory and is used as the user within containers.
-// and is used as the user within containers. If files are not owned by this
-// user there will be issues with permissions on Docker mount points.
 //
-// This function IS NOT thread safe and should only be called in the main thread
+// If files are not owned by this user there will be issues with permissions on Docker
-// when the application is booting.
+// mount points.
-func EnsurePterodactylUser() error {
+func (c *Configuration) EnsurePterodactylUser() (*user.User, error) {
-	sysName, err := getSystemName()
+	u, err := user.Lookup(c.System.Username)
-	if err != nil {
-		return err
-	}
 
-	// Our way of detecting if wings is running inside of Docker.
-	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_GID"), "988"))
-		return nil
-	}
-
-	u, err := user.Lookup(_config.System.Username)
 	// If an error is returned but it isn't the unknown user error just abort
 	// the process entirely. If we did find a user, return it immediately.
-	if err != nil {
+	if err == nil {
-		if _, ok := err.(user.UnknownUserError); !ok {
+		return u, c.setSystemUser(u)
-			return err
+	} else if _, ok := err.(user.UnknownUserError); !ok {
-		}
+		return nil, err
-	} else {
-		_config.System.User.Uid = system.MustInt(u.Uid)
-		_config.System.User.Gid = system.MustInt(u.Gid)
-		return nil
 	}
 
-	command := fmt.Sprintf("useradd --system --no-create-home --shell /usr/sbin/nologin %s", _config.System.Username)
+	sysName, err := getSystemName()
-	// Alpine Linux is the only OS we currently support that doesn't work with the useradd
+	if err != nil {
-	// command, so in those cases we just modify the command a bit to work as expected.
+		return nil, err
+	}
+
+	var command = fmt.Sprintf("useradd --system --no-create-home --shell /bin/false %s", c.System.Username)
+
+	// Alpine Linux is the only OS we currently support that doesn't work with the useradd command, so
+	// in those cases we just modify the command a bit to work as expected.
 	if strings.HasPrefix(sysName, "alpine") {
-		command = fmt.Sprintf("adduser -S -D -H -G %[1]s -s /sbin/nologin %[1]s", _config.System.Username)
+		command = fmt.Sprintf("adduser -S -D -H -G %[1]s -s /bin/false %[1]s", c.System.Username)
+
 		// We have to create the group first on Alpine, so do that here before continuing on
 		// to the user creation process.
-		if _, err := exec.Command("addgroup", "-S", _config.System.Username).Output(); err != nil {
+		if _, err := exec.Command("addgroup", "-S", c.System.Username).Output(); err != nil {
-			return err
+			return nil, err
 		}
 	}
 
 	split := strings.Split(command, " ")
 	if _, err := exec.Command(split[0], split[1:]...).Output(); err != nil {
-		return err
+		return nil, err
 	}
-	u, err = user.Lookup(_config.System.Username)
+
-	if err != nil {
+	if u, err := user.Lookup(c.System.Username); err != nil {
-		return err
+		return nil, err
+	} else {
+		return u, c.setSystemUser(u)
 	}
-	_config.System.User.Uid = system.MustInt(u.Uid)
-	_config.System.User.Gid = system.MustInt(u.Gid)
-	return nil
 }
 
-// FromFile reads the configuration from the provided file and stores it in the
+// Set the system user into the configuration and then write it to the disk so that
-// global singleton for this instance.
+// it is persisted on boot.
-func FromFile(path string) error {
+func (c *Configuration) setSystemUser(u *user.User) error {
-	b, err := os.ReadFile(path)
+	uid, _ := strconv.Atoi(u.Uid)
-	if err != nil {
+	gid, _ := strconv.Atoi(u.Gid)
-		return err
-	}
-	c, err := NewAtPath(path)
-	if err != nil {
-		return err
-	}
 
-	if err := yaml.Unmarshal(b, c); err != nil {
+	c.Lock()
-		return err
+	defer c.Unlock()
-	}
 
-	// Store this configuration in the global state.
+	c.System.Username = u.Username
-	Set(c)
+	c.System.User.Uid = uid
-	return nil
+	c.System.User.Gid = gid
+
+	return c.WriteToDisk()
 }
 
-// ConfigureDirectories ensures that all the system directories exist on the
+// Ensures that the configured data directory has the correct permissions assigned to
-// system. These directories are created so that only the owner can read the data,
+// all of the files and folders within.
-// and no other users.
+func (c *Configuration) EnsureFilePermissions() error {
-//
+	// Don't run this unless it is configured to be run. On large system this can often slow
-// This function IS NOT thread-safe.
+	// things down dramatically during the boot process.
-func ConfigureDirectories() error {
+	if !c.System.SetPermissionsOnBoot {
-	root := _config.System.RootDirectory
-	log.WithField("path", root).Debug("ensuring root data directory exists")
-	if err := os.MkdirAll(root, 0o700); err != nil {
-		return err
-	}
-
-	// There are a non-trivial number of users out there whose data directories are actually a
-	// symlink to another location on the disk. If we do not resolve that final destination at this
-	// point things will appear to work, but endless errors will be encountered when we try to
-	// verify accessed paths since they will all end up resolving outside the expected data directory.
-	//
-	// For the sake of automating away as much of this as possible, see if the data directory is a
-	// symlink, and if so resolve to its final real path, and then update the configuration to use
-	// that.
-	if d, err := filepath.EvalSymlinks(_config.System.Data); err != nil {
-		if !os.IsNotExist(err) {
-			return err
-		}
-	} else if d != _config.System.Data {
-		_config.System.Data = d
-	}
-
-	log.WithField("path", _config.System.Data).Debug("ensuring server data directory exists")
-	if err := os.MkdirAll(_config.System.Data, 0o700); err != nil {
-		return err
-	}
-
-	log.WithField("path", _config.System.ArchiveDirectory).Debug("ensuring archive data directory exists")
-	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, 0o700); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// EnableLogRotation writes a logrotate file for wings to the system logrotate
-// configuration directory if one exists and a logrotate file is not found. This
-// allows us to basically automate away the log rotation for most installs, but
-// also enable users to make modifications on their own.
-//
-// This function IS NOT thread-safe.
-func EnableLogRotation() error {
-	if !_config.System.EnableLogRotate {
-		log.Info("skipping log rotate configuration, disabled in wings config file")
 		return nil
 	}
 
-	if st, err := os.Stat("/etc/logrotate.d"); err != nil && !os.IsNotExist(err) {
+	r := regexp.MustCompile("^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$")
-		return err
-	} else if (err != nil && os.IsNotExist(err)) || !st.IsDir() {
-		return nil
-	}
-	if _, err := os.Stat("/etc/logrotate.d/wings"); err == nil || !os.IsNotExist(err) {
-		return err
-	}
 
-	log.Info("no log rotation configuration found: adding file now")
+	files, err := ioutil.ReadDir(c.System.Data)
-	// If we've gotten to this point it means the logrotate directory exists on the system
-	// but there is not a file for wings already. In that case, let us write a new file to
-	// it so files can be rotated easily.
-	f, err := os.Create("/etc/logrotate.d/wings")
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	t, err := template.New("logrotate").Parse(`{{.LogDirectory}}/wings.log {
-    size 10M
-    compress
-    delaycompress
-    dateext
-    maxage 7
-    missingok
-    notifempty
-    postrotate
-        /usr/bin/systemctl kill -s HUP wings.service >/dev/null 2>&1 || true
-    endscript
-}`)
 	if err != nil {
 		return err
 	}
 
-	return errors.Wrap(t.Execute(f, _config.System), "config: failed to write logrotate to disk")
+	su, err := user.Lookup(c.System.Username)
-}
+	if err != nil {
-
+		return err
-// GetStatesPath returns the location of the JSON file that tracks server states.
-func (sc *SystemConfiguration) GetStatesPath() string {
-	return path.Join(sc.RootDirectory, "/states.json")
-}
-
-// ConfigureTimezone sets the timezone data for the configuration if it is
-// currently missing. If a value has been set, this functionality will only run
-// to validate that the timezone being used is valid.
-//
-// This function IS NOT thread-safe.
-func ConfigureTimezone() error {
-	tz := os.Getenv("TZ")
-	if _config.System.Timezone == "" && tz != "" {
-		_config.System.Timezone = tz
-	}
-	if _config.System.Timezone == "" {
-		b, err := os.ReadFile("/etc/timezone")
-		if err != nil {
-			if !os.IsNotExist(err) {
-				return errors.WithMessage(err, "config: failed to open timezone file")
-			}
-
-			_config.System.Timezone = "UTC"
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-			defer cancel()
-			// Okay, file isn't found on this OS, we will try using timedatectl to handle this. If this
-			// command fails, exit, but if it returns a value use that. If no value is returned we will
-			// fall through to UTC to get Wings booted at least.
-			out, err := exec.CommandContext(ctx, "timedatectl").Output()
-			if err != nil {
-				log.WithField("error", err).Warn("failed to execute \"timedatectl\" to determine system timezone, falling back to UTC")
-				return nil
-			}
-
-			r := regexp.MustCompile(`Time zone: ([\w/]+)`)
-			matches := r.FindSubmatch(out)
-			if len(matches) != 2 || string(matches[1]) == "" {
-				log.Warn("failed to parse timezone from \"timedatectl\" output, falling back to UTC")
-				return nil
-			}
-			_config.System.Timezone = string(matches[1])
-		} else {
-			_config.System.Timezone = string(b)
-		}
 	}
 
-	_config.System.Timezone = regexp.MustCompile(`(?i)[^a-z_/]+`).ReplaceAllString(_config.System.Timezone, "")
+	wg := new(sync.WaitGroup)
-	_, err := time.LoadLocation(_config.System.Timezone)
 
-	return errors.WithMessage(err, fmt.Sprintf("the supplied timezone %s is invalid", _config.System.Timezone))
+	for _, file := range files {
+		wg.Add(1)
+
+		// Asynchronously run through the list of files and folders in the data directory. If
+		// the item is not a folder, or is not a folder that matches the expected UUIDv4 format
+		// skip over it.
+		//
+		// If we do have a positive match, run a chown against the directory.
+		go func(f os.FileInfo) {
+			defer wg.Done()
+
+			if !f.IsDir() || !r.MatchString(f.Name()) {
+				return
+			}
+
+			uid, _ := strconv.Atoi(su.Uid)
+			gid, _ := strconv.Atoi(su.Gid)
+
+			if err := os.Chown(path.Join(c.System.Data, f.Name()), uid, gid); err != nil {
+				zap.S().Warnw("failed to chown server directory", zap.String("directory", f.Name()), zap.Error(err))
+			}
+		}(file)
+	}
+
+	wg.Wait()
+
+	return nil
+}
+
+// Writes the configuration to the disk as a blocking operation by obtaining an exclusive
+// lock on the file. This prevents something else from writing at the exact same time and
+// leading to bad data conditions.
+func (c *Configuration) WriteToDisk() error {
+	ccopy := *c
+	// If debugging is set with the flag, don't save that to the configuration file, otherwise
+	// you'll always end up in debug mode.
+	if _debugViaFlag {
+		ccopy.Debug = false
+	}
+
+	if c.path == "" {
+		return errors.New("cannot write configuration, no path defined in struct")
+	}
+
+	b, err := yaml.Marshal(&ccopy)
+	if err != nil {
+		return err
+	}
+
+	// Obtain an exclusive write against the configuration file.
+	c.writeLock.Lock()
+	defer c.writeLock.Unlock()
+
+	if err := ioutil.WriteFile(c.GetPath(), b, 0644); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // Gets the system release name.
 func getSystemName() (string, error) {
 	// use osrelease to get release version and ID
-	release, err := osrelease.Read()
+	if release, err := osrelease.Read(); err != nil {
-	if err != nil {
 		return "", err
+	} else {
+		return release["ID"], nil
 	}
-	return release["ID"], nil
 }

config/config_docker.go

@@ -1,18 +1,11 @@
 package config
 
-import (
-	"encoding/base64"
-	"sort"
-
-	"github.com/docker/docker/api/types"
-	"github.com/goccy/go-json"
-)
-
 type dockerNetworkInterfaces struct {
 	V4 struct {
 		Subnet  string `default:"172.18.0.0/16"`
 		Gateway string `default:"172.18.0.1"`
 	}
+
 	V6 struct {
 		Subnet  string `default:"fdba:17c8:6c94::/64"`
 		Gateway string `default:"fdba:17c8:6c94::1011"`
@@ -36,133 +29,25 @@ type DockerNetworkConfiguration struct {
 	Mode       string                  `default:"pterodactyl_nw" yaml:"network_mode"`
 	IsInternal bool                    `default:"false" yaml:"is_internal"`
 	EnableICC  bool                    `default:"true" yaml:"enable_icc"`
-	NetworkMTU int64                   `default:"1500" yaml:"network_mtu"`
 	Interfaces dockerNetworkInterfaces `yaml:"interfaces"`
 }
 
-// DockerConfiguration defines the docker configuration used by the daemon when
+// Defines the docker configuration used by the daemon when interacting with
-// interacting with containers and networks on the system.
+// containers and networks on the system.
 type DockerConfiguration struct {
 	// Network configuration that should be used when creating a new network
 	// for containers run through the daemon.
 	Network DockerNetworkConfiguration `json:"network" yaml:"network"`
 
-	// Domainname is the Docker domainname for all containers.
+	// If true, container images will be updated when a server starts if there
-	Domainname string `default:"" json:"domainname" yaml:"domainname"`
+	// is an update available. If false the daemon will not attempt updates and will
+	// defer to the host system to manage image updates.
+	UpdateImages bool `default:"true" json:"update_images" yaml:"update_images"`
 
-	// Registries .
+	// The location of the Docker socket.
-	Registries map[string]RegistryConfiguration `json:"registries" yaml:"registries"`
+	Socket string `default:"/var/run/docker.sock" json:"socket" yaml:"socket"`
 
-	// TmpfsSize specifies the size for the /tmp directory mounted into containers. Please be
+	// Defines the location of the timezone file on the host system that should
-	// aware that Docker utilizes the host's system memory for this value, and that we do not
+	// be mounted into the created containers so that they all use the same time.
-	// keep track of the space used there, so avoid allocating too much to a server.
+	TimezonePath string `default:"/etc/timezone" json:"timezone_path" yaml:"timezone_path"`
-	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"`
-
-	// Sets the user namespace mode for the container when user namespace remapping option is
-	// enabled.
-	//
-	// If the value is blank, the daemon's user namespace remapping configuration is used,
-	// if the value is "host", then the pterodactyl containers are started with user namespace
-	// remapping disabled
-	UsernsMode string `default:"" json:"userns_mode" yaml:"userns_mode"`
-}
-
-// RegistryConfiguration defines the authentication credentials for a given
-// Docker registry.
-type RegistryConfiguration struct {
-	Username string `yaml:"username"`
-	Password string `yaml:"password"`
-}
-
-// Base64 returns the authentication for a given registry as a base64 encoded
-// string value.
-func (c RegistryConfiguration) Base64() (string, error) {
-	b, err := json.Marshal(types.AuthConfig{
-		Username: c.Username,
-		Password: c.Password,
-	})
-	if err != nil {
-		return "", err
-	}
-	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
 }

config/config_system.go

@@ -0,0 +1,96 @@
+package config
+
+import (
+	"go.uber.org/zap"
+	"os"
+	"path"
+)
+
+// Defines basic system configuration settings.
+type SystemConfiguration struct {
+	// The root directory where all of the pterodactyl data is stored at.
+	RootDirectory string `default:"/var/lib/pterodactyl" yaml:"root_directory"`
+
+	// Directory where logs for server installations and other wings events are logged.
+	LogDirectory string `default:"/var/log/pterodactyl" yaml:"log_directory"`
+
+	// Directory where the server data is stored at.
+	Data string `default:"/var/lib/pterodactyl/volumes" yaml:"data"`
+
+	// Directory where server archives for transferring will be stored.
+	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" yaml:"archive_directory"`
+
+	// Directory where local backups will be stored on the machine.
+	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`
+
+	// The user that should own all of the server files, and be used for containers.
+	Username string `default:"pterodactyl" yaml:"username"`
+
+	// Definitions for the user that gets created to ensure that we can quickly access
+	// this information without constantly having to do a system lookup.
+	User struct {
+		Uid int
+		Gid int
+	}
+
+	// Determines if permissions for a server should be set automatically on
+	// daemon boot. This can take a long time on systems with many servers, or on
+	// systems with servers containing thousands of files.
+	//
+	// Setting this to true by default helps us avoid a lot of support requests
+	// from people that keep trying to move files around as a root user leading
+	// to server permission issues.
+	//
+	// In production and heavy use environments where boot speed is essential,
+	// this should be set to false as servers will self-correct permissions on
+	// boot anyways.
+	SetPermissionsOnBoot bool `default:"true" yaml:"set_permissions_on_boot"`
+
+	// Determines if Wings should detect a server that stops with a normal exit code of
+	// "0" as being crashed if the process stopped without any Wings interaction. E.g.
+	// the user did not press the stop button, but the process stopped cleanly.
+	DetectCleanExitAsCrash bool `default:"true" yaml:"detect_clean_exit_as_crash"`
+
+	Sftp *SftpConfiguration `yaml:"sftp"`
+}
+
+// Ensures that all of the system directories exist on the system. These directories are
+// created so that only the owner can read the data, and no other users.
+func (sc *SystemConfiguration) ConfigureDirectories() error {
+	zap.S().Debugw("ensuring root data directory exists", zap.String("path", sc.RootDirectory))
+	if err := os.MkdirAll(sc.RootDirectory, 0700); err != nil {
+		return err
+	}
+
+	zap.S().Debugw("ensuring log directory exists", zap.String("path", sc.LogDirectory))
+	if err := os.MkdirAll(path.Join(sc.LogDirectory, "/install"), 0700); err != nil {
+		return err
+	}
+
+	zap.S().Debugw("ensuring server data directory exists", zap.String("path", sc.Data))
+	if err := os.MkdirAll(sc.Data, 0700); err != nil {
+		return err
+	}
+
+	zap.S().Debugw("ensuring archive data directory exists", zap.String("path", sc.ArchiveDirectory))
+	if err := os.MkdirAll(sc.ArchiveDirectory, 0700); err != nil {
+		return err
+	}
+
+	zap.S().Debugw("ensuring backup data directory exists", zap.String("path", sc.BackupDirectory))
+	if err := os.MkdirAll(sc.BackupDirectory, 0700); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Returns the location of the JSON file that tracks server states.
+func (sc *SystemConfiguration) GetStatesPath() string {
+	return path.Join(sc.RootDirectory, "states.json")
+}
+
+// Returns the location of the JSON file that tracks server states.
+func (sc *SystemConfiguration) GetInstallLogPath() string {
+	return path.Join(sc.LogDirectory, "install/")
+}

docker-compose.example.yml

@@ -1,39 +1,26 @@
-version: '3.8'
+version: '3'
-
 services:
-  wings:
+  daemon:
-    image: ghcr.io/pterodactyl/wings:latest
+    build: .
     restart: always
-    networks:
+    hostname: daemon
-      - wings0
     ports:
       - "8080:8080"
       - "2022:2022"
     tty: true
     environment:
-      TZ: "UTC"
+      - "DEBUG=false"
-      WINGS_UID: 988
-      WINGS_GID: 988
-      WINGS_USERNAME: pterodactyl
     volumes:
       - "/var/run/docker.sock:/var/run/docker.sock"
       - "/var/lib/docker/containers/:/var/lib/docker/containers/"
-      - "/etc/pterodactyl/:/etc/pterodactyl/"
       - "/var/lib/pterodactyl/:/var/lib/pterodactyl/"
-      - "/var/log/pterodactyl/:/var/log/pterodactyl/"
+      - "/srv/daemon-data/:/srv/daemon-data/"
       - "/tmp/pterodactyl/:/tmp/pterodactyl/"
-      - "/etc/ssl/certs:/etc/ssl/certs:ro"
+      - "/etc/timezone:/etc/timezone:ro"
-      # you may need /srv/daemon-data if you are upgrading from an old daemon
+      ## Required for ssl if you user let's encrypt. uncomment to use.
-      #- "/srv/daemon-data/:/srv/daemon-data/"
+      ## - "/etc/letsencrypt/:/etc/letsencrypt/"
-      # Required for ssl if you use let's encrypt. uncomment to use.
-      #- "/etc/letsencrypt/:/etc/letsencrypt/"
-
 networks:
-  wings0:
+  default:
-    name: wings0
-    driver: bridge
     ipam:
       config:
-        - subnet: "172.21.0.0/16"
+        - subnet: 172.21.0.0/16
-    driver_opts:
-      com.docker.network.bridge.name: wings0

environment/allocations.go

@@ -1,109 +0,0 @@
-package environment
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/docker/go-connections/nat"
-
-	"github.com/pterodactyl/wings/config"
-)
-
-// Defines the allocations available for a given server. When using the Docker environment
-// driver these correspond to mappings for the container that allow external connections.
-type Allocations struct {
-	// ForceOutgoingIP causes a dedicated bridge network to be created for the
-	// server with a special option, causing Docker to SNAT outgoing traffic to
-	// the DefaultMapping's IP. This is important to servers which rely on external
-	// services that check the IP of the server (Source Engine servers, for example).
-	ForceOutgoingIP bool `json:"force_outgoing_ip"`
-	// Defines the default allocation that should be used for this server. This is
-	// what will be used for {SERVER_IP} and {SERVER_PORT} when modifying configuration
-	// files or the startup arguments for a server.
-	DefaultMapping struct {
-		Ip   string `json:"ip"`
-		Port int    `json:"port"`
-	} `json:"default"`
-
-	// 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"`
-}
-
-// Converts the server allocation mappings into a format that can be understood by Docker. While
-// we do strive to support multiple environments, using Docker's standardized format for the
-// bindings certainly makes life a little easier for managing things.
-//
-// 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 {
-	out := nat.PortMap{}
-
-	for ip, ports := range a.Mappings {
-		for _, port := range ports {
-			// Skip over invalid ports.
-			if port < 1 || port > 65535 {
-				continue
-			}
-
-			binding := nat.PortBinding{
-				HostIP:   ip,
-				HostPort: strconv.Itoa(port),
-			}
-
-			tcp := nat.Port(fmt.Sprintf("%d/tcp", port))
-			udp := nat.Port(fmt.Sprintf("%d/udp", port))
-
-			out[tcp] = append(out[tcp], binding)
-			out[udp] = append(out[udp], binding)
-		}
-	}
-
-	return out
-}
-
-// Returns the bindings for the server in a way that is supported correctly by Docker. This replaces
-// any reference to 127.0.0.1 with the IP of the pterodactyl0 network interface which will allow the
-// server to operate on a local address while still being accessible by other containers.
-func (a *Allocations) DockerBindings() nat.PortMap {
-	iface := config.Get().Docker.Network.Interface
-
-	out := a.Bindings()
-	// 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 {
-		for i, alloc := range binds {
-			if alloc.HostIP != "127.0.0.1" {
-				continue
-			}
-
-			// If using ISPN just delete the local allocation from the server.
-			if config.Get().Docker.Network.ISPN {
-				out[p] = append(out[p][:i], out[p][i+1:]...)
-			} else {
-				out[p][i] = nat.PortBinding{
-					HostIP:   iface,
-					HostPort: alloc.HostPort,
-				}
-			}
-		}
-	}
-
-	return out
-}
-
-// Converts the server allocation mappings into a PortSet that can be understood
-// by Docker. This formatting is slightly different than "Bindings" as it should
-// return an empty struct rather than a binding.
-//
-// 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 {
-	out := nat.PortSet{}
-
-	for port := range a.DockerBindings() {
-		out[port] = struct{}{}
-	}
-
-	return out
-}

environment/config.go

@@ -1,77 +0,0 @@
-package environment
-
-import (
-	"sync"
-)
-
-type Settings struct {
-	Mounts      []Mount
-	Allocations Allocations
-	Limits      Limits
-}
-
-// Defines the actual configuration struct for the environment with all of the settings
-// defined within it.
-type Configuration struct {
-	mu sync.RWMutex
-
-	environmentVariables []string
-	settings             Settings
-}
-
-// Returns a new environment configuration with the given settings and environment variables
-// defined within it.
-func NewConfiguration(s Settings, envVars []string) *Configuration {
-	return &Configuration{
-		environmentVariables: envVars,
-		settings:             s,
-	}
-}
-
-// Updates the settings struct for this environment on the fly. This allows modified servers to
-// automatically push those changes to the environment.
-func (c *Configuration) SetSettings(s Settings) {
-	c.mu.Lock()
-	c.settings = s
-	c.mu.Unlock()
-}
-
-// Updates the environment variables associated with this environment by replacing the entire
-// array of them with a new one.
-func (c *Configuration) SetEnvironmentVariables(ev []string) {
-	c.mu.Lock()
-	c.environmentVariables = ev
-	c.mu.Unlock()
-}
-
-// Returns the limits assigned to this environment.
-func (c *Configuration) Limits() Limits {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return c.settings.Limits
-}
-
-// Returns the allocations associated with this environment.
-func (c *Configuration) Allocations() Allocations {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return c.settings.Allocations
-}
-
-// Returns all of the mounts associated with this environment.
-func (c *Configuration) Mounts() []Mount {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return c.settings.Mounts
-}
-
-// Returns the environment variables associated with this instance.
-func (c *Configuration) EnvironmentVariables() []string {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return c.environmentVariables
-}

environment/docker.go

@@ -2,106 +2,95 @@ package environment
 
 import (
 	"context"
-	"strconv"
-	"sync"
 
-	"emperror.dev/errors"
-	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/config"
+	"go.uber.org/zap"
 )
 
-var (
+// Configures the required network for the docker environment.
-	_conce  sync.Once
+func ConfigureDocker(c *config.DockerConfiguration) error {
-	_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
-// function.
-func Docker() (*client.Client, error) {
-	var err error
-	_conce.Do(func() {
-		_client, err = client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-	})
-	return _client, errors.Wrap(err, "environment/docker: could not create client")
-}
-
-// ConfigureDocker configures the required network for the docker environment.
-func ConfigureDocker(ctx context.Context) error {
 	// Ensure the required docker network exists on the system.
-	cli, err := Docker()
+	cli, err := client.NewClientWithOpts(client.FromEnv)
 	if err != nil {
 		return err
 	}
 
-	nw := config.Get().Docker.Network
+	resource, err := cli.NetworkInspect(context.Background(), c.Network.Name, types.NetworkInspectOptions{})
-	resource, err := cli.NetworkInspect(ctx, nw.Name, types.NetworkInspectOptions{})
+	if err != nil && client.IsErrNotFound(err) {
-	if err != nil {
+		zap.S().Infow("creating missing pterodactyl0 interface, this could take a few seconds...")
-		if !client.IsErrNotFound(err) {
+		return createDockerNetwork(cli, c)
-			return err
+	} else if err != nil {
-		}
+		zap.S().Fatalw("failed to create required docker network for containers", zap.Error(err))
-
+	}
-		log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
+
-		if err := createDockerNetwork(ctx, cli); err != nil {
+	switch resource.Driver {
-			return err
+	case "host":
-		}
+		c.Network.Interface = "127.0.0.1"
+		c.Network.ISPN = false
+		return nil
+	case "overlay":
+	case "weavemesh":
+		c.Network.Interface = ""
+		c.Network.ISPN = true
+		return nil
+	default:
+		c.Network.ISPN = false
 	}
 
-	config.Update(func(c *config.Configuration) {
-		c.Docker.Network.Driver = resource.Driver
-		switch c.Docker.Network.Driver {
-		case "host":
-			c.Docker.Network.Interface = "127.0.0.1"
-			c.Docker.Network.ISPN = false
-		case "overlay":
-			fallthrough
-		case "weavemesh":
-			c.Docker.Network.Interface = ""
-			c.Docker.Network.ISPN = true
-		default:
-			c.Docker.Network.ISPN = false
-		}
-	})
 	return nil
 }
 
 // Creates a new network on the machine if one does not exist already.
-func createDockerNetwork(ctx context.Context, cli *client.Client) error {
+func createDockerNetwork(cli *client.Client, c *config.DockerConfiguration) error {
-	nw := config.Get().Docker.Network
+	_, err := cli.NetworkCreate(context.Background(), c.Network.Name, types.NetworkCreate{
-	_, err := cli.NetworkCreate(ctx, nw.Name, types.NetworkCreate{
+		Driver:     c.Network.Driver,
-		Driver:     nw.Driver,
 		EnableIPv6: true,
-		Internal:   nw.IsInternal,
+		Internal:   c.Network.IsInternal,
 		IPAM: &network.IPAM{
-			Config: []network.IPAMConfig{{
+			Config: []network.IPAMConfig{
-				Subnet:  nw.Interfaces.V4.Subnet,
+				{
-				Gateway: nw.Interfaces.V4.Gateway,
+					Subnet:  c.Network.Interfaces.V4.Subnet,
-			}, {
+					Gateway: c.Network.Interfaces.V4.Gateway,
-				Subnet:  nw.Interfaces.V6.Subnet,
+				},
-				Gateway: nw.Interfaces.V6.Gateway,
+				{
-			}},
+					Subnet:  c.Network.Interfaces.V6.Subnet,
+					Gateway: c.Network.Interfaces.V6.Gateway,
+				},
+			},
 		},
 		Options: map[string]string{
 			"encryption": "false",
 			"com.docker.network.bridge.default_bridge":       "false",
-			"com.docker.network.bridge.enable_icc":           strconv.FormatBool(nw.EnableICC),
+			"com.docker.network.bridge.enable_icc":           "true",
 			"com.docker.network.bridge.enable_ip_masquerade": "true",
 			"com.docker.network.bridge.host_binding_ipv4":    "0.0.0.0",
 			"com.docker.network.bridge.name":                 "pterodactyl0",
-			"com.docker.network.driver.mtu":                  strconv.FormatInt(nw.NetworkMTU, 10),
+			"com.docker.network.driver.mtu":                  "1500",
 		},
 	})
+
 	if err != nil {
 		return err
 	}
-	if nw.Driver != "host" && nw.Driver != "overlay" && nw.Driver != "weavemesh" {
+
-		config.Update(func(c *config.Configuration) {
+	switch c.Network.Driver {
-			c.Docker.Network.Interface = c.Docker.Network.Interfaces.V4.Gateway
+	case "host":
-		})
+		c.Network.Interface = "127.0.0.1"
+		c.Network.ISPN = false
+		break
+	case "overlay":
+	case "weavemesh":
+		c.Network.Interface = ""
+		c.Network.ISPN = true
+		break
+	default:
+		c.Network.Interface = c.Network.Interfaces.V4.Gateway
+		c.Network.ISPN = false
+		break
 	}
+
 	return nil
 }

environment/docker/api.go

@@ -1,119 +0,0 @@
-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

@@ -1,512 +0,0 @@
-package docker
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-	"time"
-
-	"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/local"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/system"
-)
-
-var ErrNotAttached = errors.Sentinel("not attached to instance")
-
-// A custom console writer that allows us to keep a function blocked until the
-// given stream is properly closed. This does nothing special, only exists to
-// make a noop io.Writer.
-type noopWriter struct{}
-
-var _ io.Writer = noopWriter{}
-
-// Implement the required Write function to satisfy the io.Writer interface.
-func (nw noopWriter) Write(b []byte) (int, error) {
-	return len(b), nil
-}
-
-// Attach attaches to the docker container itself and ensures that we can pipe
-// 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 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
-	}
-
-	if err := e.followOutput(); err != nil {
-		return err
-	}
-
-	opts := types.ContainerAttachOptions{
-		Stdin:  true,
-		Stdout: true,
-		Stderr: true,
-		Stream: true,
-	}
-
-	// Set the stream again with the container.
-	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
-		return err
-	} else {
-		e.SetStream(&st)
-	}
-
-	go func() {
-		// 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() {
-			e.SetState(environment.ProcessOfflineState)
-			e.SetStream(nil)
-		}()
-
-		go func() {
-			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 {
-					e.log().Warn("stopping server resource polling: context canceled")
-				}
-			}
-		}()
-
-		// Block the completion of this routine until the container is no longer running. This allows
-		// the pollResources function to run until it needs to be stopped. Because the container
-		// can be polled for resource usage, even when stopped, we need to have this logic present
-		// in order to cancel the context and therefore stop the routine that is spawned.
-		//
-		// For now, DO NOT use client#ContainerWait from the Docker package. There is a nasty
-		// bug causing containers to hang on deletion and cause servers to lock up on the system.
-		//
-		// This weird code isn't intuitive, but it keeps the function from ending until the container
-		// is stopped and therefore the stream reader ends up closed.
-		// @see https://github.com/moby/moby/issues/41827
-		c := new(noopWriter)
-		if _, err := io.Copy(c, e.stream.Reader); err != nil {
-			e.log().WithField("error", err).Error("could not copy from environment stream to noop writer")
-		}
-	}()
-
-	return nil
-}
-
-// InSituUpdate performs an in-place update of the Docker container's resource
-// limits without actually making any changes to the operational state of the
-// container. This allows memory, cpu, and IO limitations to be adjusted on the
-// fly for individual instances.
-func (e *Environment) InSituUpdate() error {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
-	defer cancel()
-
-	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
-		// to the disk.
-		//
-		// We'll let a boot process make modifications to the container if needed at this point.
-		if client.IsErrNotFound(err) {
-			return nil
-		}
-		return errors.Wrap(err, "environment/docker: could not inspect container")
-	}
-
-	// CPU pinning cannot be removed once it is applied to a container. The same is true
-	// for removing memory limits, a container must be re-created.
-	//
-	// @see https://github.com/moby/moby/issues/41946
-	if _, err := e.client.ContainerUpdate(ctx, e.Id, container.UpdateConfig{
-		Resources: e.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 the data that is
-// currently available for it. If the container already exists it will be
-// returned.
-func (e *Environment) Create() error {
-	ctx := context.Background()
-
-	// 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.ContainerInspect(ctx); err == nil {
-		return nil
-	} else if !client.IsErrNotFound(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 errors.WithStackIf(err)
-	}
-
-	a := e.Configuration.Allocations()
-
-	evs := e.Configuration.EnvironmentVariables()
-	for i, v := range evs {
-		// Convert 127.0.0.1 to the pterodactyl0 network interface if the environment is Docker
-		// so that the server operates as expected.
-		if v == "SERVER_IP=127.0.0.1" {
-			evs[i] = "SERVER_IP=" + config.Get().Docker.Network.Interface
-		}
-	}
-
-	conf := &container.Config{
-		Hostname:     e.Id,
-		Domainname:   config.Get().Docker.Domainname,
-		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:        strings.TrimPrefix(e.meta.Image, "~"),
-		Env:          e.Configuration.EnvironmentVariables(),
-		Labels: map[string]string{
-			"Service":       "Pterodactyl",
-			"ContainerType": "server_process",
-		},
-	}
-
-	networkMode := container.NetworkMode(config.Get().Docker.Network.Mode)
-	if a.ForceOutgoingIP {
-		e.log().Debug("environment/docker: forcing outgoing IP address")
-		networkName := strings.ReplaceAll(e.Id, "-", "")
-		networkMode = container.NetworkMode(networkName)
-
-		if _, err := e.client.NetworkInspect(ctx, networkName, types.NetworkInspectOptions{}); err != nil {
-			if !client.IsErrNotFound(err) {
-				return err
-			}
-
-			if _, err := e.client.NetworkCreate(ctx, networkName, types.NetworkCreate{
-				Driver:     "bridge",
-				EnableIPv6: false,
-				Internal:   false,
-				Attachable: false,
-				Ingress:    false,
-				ConfigOnly: false,
-				Options: map[string]string{
-					"encryption": "false",
-					"com.docker.network.bridge.default_bridge": "false",
-					"com.docker.network.host_ipv4":             a.DefaultMapping.Ip,
-				},
-			}); err != nil {
-				return err
-			}
-		}
-	}
-
-	hostConf := &container.HostConfig{
-		PortBindings: a.DockerBindings(),
-
-		// Configure the mounts for this container. First mount the server data directory
-		// into the container as an r/w bind.
-		Mounts: e.convertMounts(),
-
-		// Configure the /tmp folder mapping in containers. This is necessary for some
-		// games that need to make use of it for downloads and other installation processes.
-		Tmpfs: map[string]string{
-			"/tmp": "rw,exec,nosuid,size=" + strconv.Itoa(int(config.Get().Docker.TmpfsSize)) + "M",
-		},
-
-		// Define resource limits for the container based on the data passed through
-		// from the Panel.
-		Resources: e.Configuration.Limits().AsContainerResources(),
-
-		DNS: config.Get().Docker.Network.Dns,
-
-		// Configure logging for the container to make it easier on the Daemon to grab
-		// the server output. Ensure that we don't use too much space on the host machine
-		// 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: local.Name,
-			Config: map[string]string{
-				"max-size": "5m",
-				"max-file": "1",
-				"compress": "false",
-				"mode":     "non-blocking",
-			},
-		},
-
-		SecurityOpt:    []string{"no-new-privileges"},
-		ReadonlyRootfs: true,
-		CapDrop: []string{
-			"setpcap", "mknod", "audit_write", "net_raw", "dac_override",
-			"fowner", "fsetid", "net_bind_service", "sys_chroot", "setfcap",
-		},
-		NetworkMode: networkMode,
-		UsernsMode:  container.UsernsMode(config.Get().Docker.UsernsMode),
-	}
-
-	if _, err := e.client.ContainerCreate(ctx, conf, hostConf, nil, nil, e.Id); err != nil {
-		return errors.Wrap(err, "environment/docker: failed to create container")
-	}
-
-	return nil
-}
-
-// Destroy will remove the Docker container from the server. If the container
-// is currently running it will be forcibly stopped by Docker.
-func (e *Environment) Destroy() error {
-	// We set it to stopping than offline to prevent crash detection from being triggered.
-	e.SetState(environment.ProcessStoppingState)
-
-	err := e.client.ContainerRemove(context.Background(), e.Id, types.ContainerRemoveOptions{
-		RemoveVolumes: true,
-		RemoveLinks:   false,
-		Force:         true,
-	})
-
-	e.SetState(environment.ProcessOfflineState)
-
-	// Don't trigger a destroy failure if we try to delete a container that does not
-	// exist on the system. We're just a step ahead of ourselves in that case.
-	//
-	// @see https://github.com/pterodactyl/panel/issues/2001
-	if err != nil && client.IsErrNotFound(err) {
-		return nil
-	}
-
-	return err
-}
-
-// SendCommand sends the specified command to the stdin of the running container
-// instance. There is no confirmation that this data is sent successfully, only
-// that it gets pushed into the stdin.
-func (e *Environment) SendCommand(c string) error {
-	if !e.IsAttached() {
-		return errors.Wrap(ErrNotAttached, "environment/docker: cannot send command to container")
-	}
-
-	e.mu.RLock()
-	defer e.mu.RUnlock()
-
-	// If the command being processed is the same as the process stop command then we
-	// want to mark the server as entering the stopping state otherwise the process will
-	// stop and Wings will think it has crashed and attempt to restart it.
-	if e.meta.Stop.Type == "command" && c == e.meta.Stop.Value {
-		e.SetState(environment.ProcessStoppingState)
-	}
-
-	_, err := e.stream.Conn.Write([]byte(c + "\n"))
-
-	return errors.Wrap(err, "environment/docker: could not write to container stream")
-}
-
-// Readlog reads the log file for the server. This does not care if the server
-// is running or not, it will simply try to read the last X bytes of the file
-// and return them.
-func (e *Environment) Readlog(lines int) ([]string, error) {
-	r, err := e.client.ContainerLogs(context.Background(), e.Id, types.ContainerLogsOptions{
-		ShowStdout: true,
-		ShowStderr: true,
-		Tail:       strconv.Itoa(lines),
-	})
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-	defer r.Close()
-
-	var out []string
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		out = append(out, scanner.Text())
-	}
-
-	return out, nil
-}
-
-// Attaches to the log for the container. This avoids us missing crucial output
-// that happens in the split seconds before the code moves from 'Starting' to
-// 'Attaching' on the process.
-func (e *Environment) followOutput() error {
-	if exists, err := e.Exists(); !exists {
-		if err != nil {
-			return err
-		}
-		return errors.New(fmt.Sprintf("no such container: %s", e.Id))
-	}
-
-	opts := types.ContainerLogsOptions{
-		ShowStderr: true,
-		ShowStdout: true,
-		Follow:     true,
-		Since:      time.Now().Format(time.RFC3339),
-	}
-
-	reader, err := e.client.ContainerLogs(context.Background(), e.Id, opts)
-	if err != nil {
-		return err
-	}
-
-	go e.scanOutput(reader)
-
-	return nil
-}
-
-func (e *Environment) scanOutput(reader io.ReadCloser) {
-	defer reader.Close()
-
-	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
-	}
-
-	// Return here if the server is offline or currently stopping.
-	if e.State() == environment.ProcessStoppingState || e.State() == environment.ProcessOfflineState {
-		return
-	}
-
-	// 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()
-
-	// Start following the output of the server again.
-	go e.followOutput()
-}
-
-// Pulls the image from Docker. If there is an error while pulling the image
-// from the source but the image already exists locally, we will report that
-// error to the logger but continue with the process.
-//
-// The reasoning behind this is that Quay has had some serious outages as of
-// 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 {
-	e.Events().Publish(environment.DockerImagePullStarted, "")
-	defer e.Events().Publish(environment.DockerImagePullCompleted, "")
-
-	// Images prefixed with a ~ are local images that we do not need to try and pull.
-	if strings.HasPrefix(image, "~") {
-		return nil
-	}
-
-	// Give it up to 15 minutes to pull the image. I think this should cover 99.8% of cases where an
-	// image pull might fail. I can't imagine it will ever take more than 15 minutes to fully pull
-	// an image. Let me know when I am inevitably wrong here...
-	ctx, cancel := context.WithTimeout(context.Background(), time.Minute*15)
-	defer cancel()
-
-	// Get a registry auth configuration from the config.
-	var registryAuth *config.RegistryConfiguration
-	for registry, c := range config.Get().Docker.Registries {
-		if !strings.HasPrefix(image, registry) {
-			continue
-		}
-
-		log.WithField("registry", registry).Debug("using authentication for registry")
-		registryAuth = &c
-		break
-	}
-
-	// Get the ImagePullOptions.
-	imagePullOptions := types.ImagePullOptions{All: false}
-	if registryAuth != nil {
-		b64, err := registryAuth.Base64()
-		if err != nil {
-			log.WithError(err).Error("failed to get registry auth credentials")
-		}
-
-		// b64 is a string so if there is an error it will just be empty, not nil.
-		imagePullOptions.RegistryAuth = b64
-	}
-
-	out, err := e.client.ImagePull(ctx, image, imagePullOptions)
-	if err != nil {
-		images, ierr := e.client.ImageList(ctx, 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.
-			return errors.Wrap(ierr, "environment/docker: failed to list images")
-		}
-
-		for _, img := range images {
-			for _, t := range img.RepoTags {
-				if t != image {
-					continue
-				}
-
-				log.WithFields(log.Fields{
-					"image":        image,
-					"container_id": e.Id,
-					"err":          err.Error(),
-				}).Warn("unable to pull requested image from remote source, however the image exists locally")
-
-				// Okay, we found a matching container image, in that case just go ahead and return
-				// from this function, since there is nothing else we need to do here.
-				return nil
-			}
-		}
-
-		return errors.Wrapf(err, "environment/docker: failed to pull \"%s\" image for server", image)
-	}
-	defer out.Close()
-
-	log.WithField("image", image).Debug("pulling docker image... this could take a bit of time")
-
-	// I'm not sure what the best approach here is, but this will block execution until the image
-	// is done being pulled, which is what we need.
-	scanner := bufio.NewScanner(out)
-
-	for scanner.Scan() {
-		b := scanner.Bytes()
-		status, _ := jsonparser.GetString(b, "status")
-		progress, _ := jsonparser.GetString(b, "progress")
-
-		e.Events().Publish(environment.DockerImagePullStatus, status+" "+progress)
-	}
-
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
-	log.WithField("image", image).Debug("completed docker image pull")
-
-	return nil
-}
-
-func (e *Environment) convertMounts() []mount.Mount {
-	var out []mount.Mount
-
-	for _, m := range e.Configuration.Mounts() {
-		out = append(out, mount.Mount{
-			Type:     mount.TypeBind,
-			Source:   m.Source,
-			Target:   m.Target,
-			ReadOnly: m.ReadOnly,
-		})
-	}
-
-	return out
-}

environment/docker/environment.go

@@ -1,219 +0,0 @@
-package docker
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"sync"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/client"
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/events"
-	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/system"
-)
-
-type Metadata struct {
-	Image string
-	Stop  remote.ProcessStopConfiguration
-}
-
-// 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
-
-	// 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.
-	Id string
-
-	// The environment configuration.
-	Configuration *environment.Configuration
-
-	meta *Metadata
-
-	// The Docker client being used for this instance.
-	client *client.Client
-
-	// Controls the hijacked response stream which exists only when we're attached to
-	// the running container instance.
-	stream *types.HijackedResponse
-
-	// Holds the stats stream used by the polling commands so that we can easily close it out.
-	stats io.ReadCloser
-
-	emitter *events.Bus
-
-	logCallbackMx sync.Mutex
-	logCallback   func([]byte)
-
-	// Tracks the environment state.
-	st *system.AtomicString
-}
-
-// New creates a new base Docker environment. The ID passed through will be the
-// ID that is used to reference the container from here on out. This should be
-// unique per-server (we use the UUID by default). The container does not need
-// to exist at this point.
-func New(id string, m *Metadata, c *environment.Configuration) (*Environment, error) {
-	cli, err := environment.Docker()
-	if err != nil {
-		return nil, err
-	}
-
-	e := &Environment{
-		Id:            id,
-		Configuration: c,
-		meta:          m,
-		client:        cli,
-		st:            system.NewAtomicString(environment.ProcessOfflineState),
-		emitter:       events.NewBus(),
-	}
-
-	return e, nil
-}
-
-func (e *Environment) log() *log.Entry {
-	return log.WithField("environment", e.Type()).WithField("container_id", e.Id)
-}
-
-func (e *Environment) Type() string {
-	return "docker"
-}
-
-// 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()
-	e.stream = s
-	e.mu.Unlock()
-}
-
-// 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
-}
-
-// Events returns an event bus for the environment.
-func (e *Environment) Events() *events.Bus {
-	return e.emitter
-}
-
-// 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.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
-}
-
-// 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.
-//
-// @see docker/client/errors.go
-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
-}
-
-// 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.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
-		// created a new container for it.
-		//
-		// However, someone reported an error in Discord about this scenario happening,
-		// so I guess this should prevent it? They didn't tell me how they caused it though
-		// so that's a mystery that will have to go unsolved.
-		//
-		// @see https://github.com/pterodactyl/panel/issues/2003
-		if client.IsErrNotFound(err) {
-			return 1, false, nil
-		}
-		return 0, false, err
-	}
-	return uint32(c.State.ExitCode), c.State.OOMKilled, nil
-}
-
-// 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()
-
-	return e.Configuration
-}
-
-// SetStopConfiguration sets the stop configuration for the environment.
-func (e *Environment) SetStopConfiguration(c remote.ProcessStopConfiguration) {
-	e.mu.Lock()
-	e.meta.Stop = c
-	e.mu.Unlock()
-}
-
-func (e *Environment) SetImage(i string) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	e.meta.Image = i
-}
-
-func (e *Environment) State() string {
-	return e.st.Load()
-}
-
-// SetState sets the state of the environment. This emits an event that server's
-// can hook into to take their own actions and track their own state based on
-// the environment.
-func (e *Environment) SetState(state string) {
-	if state != environment.ProcessOfflineState &&
-		state != environment.ProcessStartingState &&
-		state != environment.ProcessRunningState &&
-		state != environment.ProcessStoppingState {
-		panic(errors.New(fmt.Sprintf("invalid server state received: %s", state)))
-	}
-
-	// Emit the event to any listeners that are currently registered.
-	if e.State() != state {
-		// If the state changed make sure we update the internal tracking to note that.
-		e.st.Store(state)
-		e.Events().Publish(environment.StateChangeEvent, state)
-	}
-}
-
-func (e *Environment) SetLogCallback(f func([]byte)) {
-	e.logCallbackMx.Lock()
-	defer e.logCallbackMx.Unlock()
-
-	e.logCallback = f
-}

environment/docker/power.go

@@ -1,300 +0,0 @@
-package docker
-
-import (
-	"context"
-	"os"
-	"strings"
-	"syscall"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/client"
-
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/remote"
-)
-
-// 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(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(ctx, e.Id, types.ContainerRemoveOptions{RemoveVolumes: true}); err != nil {
-		if !client.IsErrNotFound(err) {
-			return errors.WrapIf(err, "environment/docker: failed to remove container during pre-boot")
-		}
-	}
-
-	// The Create() function will check if the container exists in the first place, and if
-	// so just silently return without an error. Otherwise, it will try to create the necessary
-	// container and data storage directory.
-	//
-	// This won't actually run an installation process however, it is just here to ensure the
-	// environment gets created properly if it is missing and the server is started. We're making
-	// an assumption that all of the files will still exist at this point.
-	if err := e.Create(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// 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
-	// got passed up, but we also want to ensure we set the server to be offline at
-	// that point.
-	defer func() {
-		if sawError {
-			// If we don't set it to stopping first, you'll trigger crash detection which
-			// we don't want to do at this point since it'll just immediately try to do the
-			// exact same action that lead to it crashing in the first place...
-			e.SetState(environment.ProcessStoppingState)
-			e.SetState(environment.ProcessOfflineState)
-		}
-	}()
-
-	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 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(ctx)
-		}
-
-		// 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 errors.Wrap(err, "environment/docker: failed to truncate instance logs")
-			}
-		}
-	}
-
-	e.SetState(environment.ProcessStartingState)
-
-	// Set this to true for now, we will set it to false once we reach the
-	// end of this chain.
-	sawError = true
-
-	// 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(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
-	}
-
-	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 nil
-}
-
-// Stop stops the container that the server is running in. This will allow up to
-// 30 seconds to pass before the container is forcefully terminated if we are
-// trying to stop it without using a command sent into the instance.
-//
-// You most likely want to be using WaitForStop() rather than this function,
-// since this will return as soon as the command is sent, rather than waiting
-// for the process to be completed stopped.
-func (e *Environment) Stop(ctx context.Context) error {
-	e.mu.RLock()
-	s := e.meta.Stop
-	e.mu.RUnlock()
-
-	// A native "stop" as the Type field value will just skip over all of this
-	// logic and end up only executing the container stop command (which may or
-	// may not work as expected).
-	if s.Type == "" || s.Type == remote.ProcessStopSignal {
-		if s.Type == "" {
-			log.WithField("container_id", e.Id).Warn("no stop configuration detected for environment, using termination procedure")
-		}
-
-		signal := os.Kill
-		// Handle a few common cases, otherwise just fall through and just pass along
-		// the os.Kill signal to the process.
-		switch strings.ToUpper(s.Value) {
-		case "SIGABRT":
-			signal = syscall.SIGABRT
-		case "SIGINT":
-			signal = syscall.SIGINT
-		case "SIGTERM":
-			signal = syscall.SIGTERM
-		}
-		return e.Terminate(ctx, signal)
-	}
-
-	// If the process is already offline don't switch it back to stopping. Just leave it how
-	// it is and continue through to the stop handling for the process.
-	if e.st.Load() != environment.ProcessOfflineState {
-		e.SetState(environment.ProcessStoppingState)
-	}
-
-	// Only attempt to send the stop command to the instance if we are actually attached to
-	// the instance. If we are not for some reason, just send the container stop event.
-	if e.IsAttached() && s.Type == remote.ProcessStopCommand {
-		return e.SendCommand(s.Value)
-	}
-
-	// 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) {
-			e.SetStream(nil)
-			e.SetState(environment.ProcessOfflineState)
-			return nil
-		}
-		return errors.Wrap(err, "environment/docker: cannot stop container")
-	}
-
-	return nil
-}
-
-// WaitForStop attempts to gracefully stop a server using the defined stop
-// command. If the server does not stop after seconds have passed, an error will
-// be returned, or the instance will be terminated forcefully depending on the
-// value of the second argument.
-//
-// 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)
-	}
-
-	// 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(tctx, e.Id, container.WaitConditionNotRunning)
-	select {
-	case <-ctx.Done():
-		if err := ctx.Err(); err != nil {
-			if terminate {
-				return doTermination("parent-context")
-			}
-			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) {
-			return nil
-		}
-		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:
-	}
-
-	return nil
-}
-
-// Terminate forcefully terminates the container using the signal provided.
-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.
-		if client.IsErrNotFound(err) {
-			return nil
-		}
-		return errors.WithStack(err)
-	}
-
-	if !c.State.Running {
-		// 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 {
-			e.SetState(environment.ProcessStoppingState)
-			e.SetState(environment.ProcessOfflineState)
-		}
-
-		return nil
-	}
-
-	// 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(ctx, e.Id, sig); err != nil && !client.IsErrNotFound(err) {
-		return errors.WithStack(err)
-	}
-	e.SetState(environment.ProcessOfflineState)
-
-	return nil
-}

environment/docker/stats.go

@@ -1,141 +0,0 @@
-package docker
-
-import (
-	"context"
-	"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 {
-	if e.st.Load() == environment.ProcessOfflineState {
-		return errors.New("cannot enable resource polling on a stopped server")
-	}
-
-	e.log().Info("starting resource polling for container")
-	defer e.log().Debug("stopped resource polling for container")
-
-	stats, err := e.client.ContainerStats(ctx, e.Id, true)
-	if err != nil {
-		return err
-	}
-	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 {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-			var v types.StatsJSON
-			if err := dec.Decode(&v); err != nil {
-				if err != io.EOF && !errors.Is(err, context.Canceled) {
-					e.log().WithField("error", err).Warn("error while processing Docker stats output for container")
-				} else {
-					e.log().Debug("io.EOF encountered during stats decode, stopping polling...")
-				}
-				return nil
-			}
-
-			// Disable collection if the server is in an offline state and this process is still running.
-			if e.st.Load() == environment.ProcessOfflineState {
-				e.log().Debug("process in offline state while resource polling is still active; stopping poll")
-				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),
-				Network:     environment.NetworkStats{},
-			}
-
-			for _, nw := range v.Networks {
-				st.Network.RxBytes += nw.RxBytes
-				st.Network.TxBytes += nw.TxBytes
-			}
-
-			e.Events().Publish(environment.ResourceEvent, st)
-		}
-	}
-}
-
-// The "docker stats" CLI call does not return the same value as the types.MemoryStats.Usage
-// value which can be rather confusing to people trying to compare panel usage to
-// their stats output.
-//
-// 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 {
-	if v, ok := stats.Stats["total_inactive_file"]; ok && v < stats.Usage {
-		return stats.Usage - v
-	}
-
-	if v := stats.Stats["inactive_file"]; v < stats.Usage {
-		return stats.Usage - v
-	}
-
-	return stats.Usage
-}
-
-// Calculates the absolute CPU usage used by the server process on the system, not constrained
-// by the defined CPU limits on the container.
-//
-// @see https://github.com/docker/cli/blob/aa097cf1aa19099da70930460250797c8920b709/cli/command/container/stats_helpers.go#L166
-func calculateDockerAbsoluteCpu(pStats types.CPUStats, stats types.CPUStats) float64 {
-	// Calculate the change in CPU usage between the current and previous reading.
-	cpuDelta := float64(stats.CPUUsage.TotalUsage) - float64(pStats.CPUUsage.TotalUsage)
-
-	// Calculate the change for the entire system's CPU usage between current and previous reading.
-	systemDelta := float64(stats.SystemUsage) - float64(pStats.SystemUsage)
-
-	// Calculate the total number of CPU cores being used.
-	cpus := float64(stats.OnlineCPUs)
-	if cpus == 0.0 {
-		cpus = float64(len(stats.CPUUsage.PercpuUsage))
-	}
-
-	percent := 0.0
-	if systemDelta > 0.0 && cpuDelta > 0.0 {
-		percent = (cpuDelta / systemDelta) * cpus * 100.0
-	}
-
-	return math.Round(percent*1000) / 1000
-}

environment/environment.go

@@ -1,116 +0,0 @@
-package environment
-
-import (
-	"context"
-	"os"
-	"time"
-
-	"github.com/pterodactyl/wings/events"
-)
-
-const (
-	StateChangeEvent         = "state change"
-	ResourceEvent            = "resources"
-	DockerImagePullStarted   = "docker image pull started"
-	DockerImagePullStatus    = "docker image pull status"
-	DockerImagePullCompleted = "docker image pull completed"
-)
-
-const (
-	ProcessOfflineState  = "offline"
-	ProcessStartingState = "starting"
-	ProcessRunningState  = "running"
-	ProcessStoppingState = "stopping"
-)
-
-// Defines the basic interface that all environments need to implement so that
-// a server can be properly controlled.
-type ProcessEnvironment interface {
-	// Returns the name of the environment.
-	Type() string
-
-	// Returns the environment configuration to the caller.
-	Config() *Configuration
-
-	// 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.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)
-
-	// 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
-	// a no-op.
-	InSituUpdate() error
-
-	// Runs before the environment is started. If an error is returned starting will
-	// not occur, otherwise proceeds as normal.
-	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(ctx context.Context) 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
-
-	// 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
-
-	// 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).
-	Destroy() error
-
-	// Returns the exit state of the process. The first result is the exit code, the second
-	// determines if the process was killed by the system OOM killer.
-	ExitState() (uint32, bool, error)
-
-	// Creates the necessary environment for running the server process. For example,
-	// in the Docker environment create will create a new container instance for the
-	// server.
-	Create() error
-
-	// 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(ctx context.Context) error
-
-	// Sends the provided command to the running server instance.
-	SendCommand(string) error
-
-	// Reads the log file for the process from the end backwards until the provided
-	// number of lines is met.
-	Readlog(int) ([]string, error)
-
-	// Returns the current state of the environment.
-	State() string
-
-	// Sets the current state of the environment. In general you should let the environment
-	// 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

@@ -1,169 +0,0 @@
-package environment
-
-import (
-	"fmt"
-	"math"
-	"strconv"
-
-	"github.com/apex/log"
-	"github.com/docker/docker/api/types/container"
-
-	"github.com/pterodactyl/wings/config"
-)
-
-type Mount struct {
-	// In Docker environments this makes no difference, however in a non-Docker environment you
-	// should treat the "Default" mount as the root directory for the server. All other mounts
-	// are just in addition to that one, and generally things like shared maps or timezone data.
-	Default bool `json:"-"`
-
-	// The target path on the system. This is "/home/container" for all server's Default mount
-	// but in non-container environments you can likely ignore the target and just work with the
-	// source.
-	Target string `json:"target"`
-
-	// The directory from which the files will be read. In Docker environments this is the directory
-	// that we're mounting into the container at the Target location.
-	Source string `json:"source"`
-
-	// 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"`
-}
-
-// 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.
-	MemoryLimit int64 `json:"memory_limit"`
-
-	// The amount of additional swap space to be provided to a container instance.
-	Swap int64 `json:"swap"`
-
-	// The relative weight for IO operations in a container. This is relative to other
-	// containers on the system and should be a value between 10 and 1000.
-	IoWeight uint16 `json:"io_weight"`
-
-	// The percentage of CPU that this instance is allowed to consume relative to
-	// the host. A value of 200% represents complete utilization of two cores. This
-	// should be a value between 1 and THREAD_COUNT * 100.
-	CpuLimit int64 `json:"cpu_limit"`
-
-	// The amount of disk space in megabytes that a server is allowed to use.
-	DiskSpace int64 `json:"disk_space"`
-
-	// Sets which CPU threads can be used by the docker instance.
-	Threads string `json:"threads"`
-
-	OOMDisabled bool `json:"oom_disabled"`
-}
-
-// 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 l.CpuLimit * 1000
-}
-
-// 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)
-}
-
-func (l Limits) BoundedMemoryLimit() int64 {
-	return int64(math.Round(float64(l.MemoryLimit) * l.MemoryOverheadMultiplier() * 1_000_000))
-}
-
-// 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 (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
-}
-
-// AsContainerResources returns the available resources for a container in a format
-// that Docker understands.
-func (l Limits) AsContainerResources() container.Resources {
-	pids := l.ProcessLimit()
-	resources := container.Resources{
-		Memory:            l.BoundedMemoryLimit(),
-		MemoryReservation: l.MemoryLimit * 1_000_000,
-		MemorySwap:        l.ConvertedSwap(),
-		BlkioWeight:       l.IoWeight,
-		OomKillDisable:    &l.OOMDisabled,
-		PidsLimit:         &pids,
-	}
-
-	// If the CPU Limit is not set, don't send any of these fields through. Providing
-	// them seems to break some Java services that try to read the available processors.
-	//
-	// @see https://github.com/pterodactyl/panel/issues/3988
-	if l.CpuLimit > 0 {
-		resources.CPUQuota = l.CpuLimit * 1_000
-		resources.CPUPeriod = 100_000
-		resources.CPUShares = 1024
-	}
-
-	// Similar to above, don't set the specific assigned CPUs if we didn't actually limit
-	// the server to any of them.
-	if l.Threads != "" {
-		resources.CpusetCpus = l.Threads
-	}
-
-	return resources
-}
-
-type Variables map[string]interface{}
-
-// 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 {
-		return ""
-	}
-
-	switch val.(type) {
-	case int:
-		return strconv.Itoa(val.(int))
-	case int32:
-		return strconv.FormatInt(val.(int64), 10)
-	case int64:
-		return strconv.FormatInt(val.(int64), 10)
-	case float32:
-		return fmt.Sprintf("%f", val.(float32))
-	case float64:
-		return fmt.Sprintf("%f", val.(float64))
-	case bool:
-		return strconv.FormatBool(val.(bool))
-	case string:
-		return val.(string)
-	}
-
-	// TODO: I think we can add a check for val == nil and return an empty string for those
-	//  and this warning should theoretically never happen?
-	log.Warn(fmt.Sprintf("failed to marshal environment variable \"%s\" of type %+v into string", key, val))
-
-	return ""
-}

environment/stats.go

@@ -1,30 +0,0 @@
-package environment
-
-// 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
-	// return from the container, so please check the code setting this value for how that
-	// is calculated.
-	Memory uint64 `json:"memory_bytes"`
-
-	// 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 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"`
-
-	// 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 {
-	RxBytes uint64 `json:"rx_bytes"`
-	TxBytes uint64 `json:"tx_bytes"`
-}

events/events.go

@@ -1,70 +0,0 @@
-package events
-
-import (
-	"strings"
-
-	"emperror.dev/errors"
-	"github.com/goccy/go-json"
-	"github.com/pterodactyl/wings/system"
-)
-
-// Event represents an Event sent over a Bus.
-type Event struct {
-	Topic string
-	Data  interface{}
-}
-
-// Bus represents an Event Bus.
-type Bus struct {
-	*system.SinkPool
-}
-
-// 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 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 send the event using the standard listener
-	// name of "backup completed".
-	if strings.Contains(topic, ":") {
-		parts := strings.SplitN(topic, ":", 2)
-		if len(parts) == 2 {
-			topic = parts[0]
-		}
-	}
-
-	enc, err := json.Marshal(Event{Topic: topic, Data: data})
-	if err != nil {
-		panic(errors.WithStack(err))
-	}
-	b.Push(enc)
-}
-
-// 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
-}

events/events_test.go

@@ -1,98 +0,0 @@
-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)
-			})
-		})
-	})
-}

go.mod

@@ -1,124 +1,74 @@
 module github.com/pterodactyl/wings
 
-go 1.18
+go 1.13
+
+// Uncomment this in development environments to make changes to the core SFTP
+// server software. This assumes you're using the official Pterodactyl Environment
+// otherwise this path will not work.
+//
+// @see https://github.com/pterodactyl/development
+//
+// replace github.com/pterodactyl/sftp-server => ../sftp-server
 
 require (
-	emperror.dev/errors v0.8.1
+	github.com/AlecAivazis/survey/v2 v2.0.7
-	github.com/AlecAivazis/survey/v2 v2.3.6
+	github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 // indirect
-	github.com/Jeffail/gabs/v2 v2.6.1
+	github.com/Jeffail/gabs/v2 v2.2.0
-	github.com/NYTimes/logrotate v1.0.0
+	github.com/Microsoft/go-winio v0.4.7 // indirect
-	github.com/apex/log v1.9.0
+	github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 // indirect
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
+	github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a
+	github.com/aws/aws-sdk-go v1.30.14 // indirect
 	github.com/beevik/etree v1.1.0
-	github.com/buger/jsonparser v1.1.1
+	github.com/buger/jsonparser v0.0.0-20191204142016-1a29609e0929
-	github.com/cenkalti/backoff/v4 v4.1.3
 	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
-	github.com/creasty/defaults v1.6.0
+	github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448 // indirect
-	github.com/docker/docker v20.10.18+incompatible
+	github.com/creasty/defaults v1.3.0
+	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/docker v0.0.0-20180422163414-57142e89befe
 	github.com/docker/go-connections v0.4.0
-	github.com/fatih/color v1.13.0
+	github.com/docker/go-units v0.3.3 // indirect
-	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
+	github.com/gabriel-vasile/mimetype v0.1.4
-	github.com/gabriel-vasile/mimetype v1.4.1
+	github.com/gbrlsnchs/jwt/v3 v3.0.0-rc.0
-	github.com/gammazero/workerpool v1.1.3
+	github.com/ghodss/yaml v1.0.0
-	github.com/gbrlsnchs/jwt/v3 v3.0.1
+	github.com/gin-gonic/gin v1.6.2
-	github.com/gin-gonic/gin v1.8.1
+	github.com/golang/protobuf v1.3.5 // indirect
-	github.com/glebarez/sqlite v1.4.8
+	github.com/google/uuid v1.1.1
-	github.com/go-co-op/gocron v1.17.0
+	github.com/gorilla/websocket v1.4.0
-	github.com/goccy/go-json v0.9.11
+	github.com/gotestyourself/gotestyourself v2.2.0+incompatible // indirect
-	github.com/google/uuid v1.3.0
+	github.com/iancoleman/strcase v0.0.0-20191112232945-16388991a334
-	github.com/gorilla/websocket v1.5.0
+	github.com/icza/dyno v0.0.0-20200205103839-49cb13720835
-	github.com/iancoleman/strcase v0.2.0
+	github.com/imdario/mergo v0.3.8
-	github.com/icza/dyno v0.0.0-20220812133438-f0b6f8a18845
+	github.com/klauspost/pgzip v1.2.3
-	github.com/juju/ratelimit v1.0.2
+	github.com/magiconair/properties v1.8.1
-	github.com/karrick/godirwalk v1.17.0
+	github.com/mattn/go-shellwords v1.0.10 // indirect
-	github.com/klauspost/compress v1.15.11
+	github.com/mholt/archiver/v3 v3.3.0
-	github.com/klauspost/pgzip v1.2.5
-	github.com/magiconair/properties v1.8.6
-	github.com/mattn/go-colorable v0.1.13
-	github.com/mholt/archiver/v3 v3.5.1
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
-	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pkg/sftp v1.13.5
-	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/spf13/cobra v1.5.0
-	github.com/stretchr/testify v1.8.0
-	golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be
-	golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0
-	gopkg.in/ini.v1 v1.67.0
-	gopkg.in/yaml.v2 v2.4.0
-	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/gorm v1.23.10
-)
-
-require (
-	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
-	github.com/Microsoft/go-winio v0.6.0 // indirect
-	github.com/Microsoft/hcsshim v0.9.4 // 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/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.5.0 // indirect
-	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
-	github.com/fsnotify/fsnotify v1.5.4 // indirect
-	github.com/gammazero/deque v0.2.0 // indirect
-	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/glebarez/go-sqlite v1.19.1 // 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.11.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/inconshreveable/mousetrap v1.0.1 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/kr/fs v0.1.0 // indirect
-	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/magefile/mage v1.14.0 // indirect
-	github.com/mattn/go-isatty v0.0.16 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.2 // indirect
-	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/modern-go/reflect2 v1.0.1 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/nwaples/rardecode v1.1.3 // indirect
+	github.com/opencontainers/go-digest v1.0.0-rc1 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.0.1 // indirect
-	github.com/opencontainers/image-spec v1.1.0-rc2 // indirect
+	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
+	github.com/pkg/errors v0.9.1
-	github.com/pierrec/lz4/v4 v4.1.17 // indirect
+	github.com/pkg/profile v1.4.0
-	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pkg/sftp v1.11.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/pterodactyl/sftp-server v1.1.2
-	github.com/prometheus/client_golang v1.13.0 // indirect
+	github.com/remeh/sizedwaitgroup v0.0.0-20180822144253-5e7302b12cce
-	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94
-	github.com/prometheus/common v0.37.0 // indirect
+	github.com/smartystreets/goconvey v1.6.4 // indirect
-	github.com/prometheus/procfs v0.8.0 // indirect
+	github.com/spf13/cobra v0.0.7
-	github.com/remyoudompheng/bigfft v0.0.0-20220927061507-ef77025ab5aa // indirect
+	github.com/stretchr/objx v0.2.0 // indirect
-	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/yuin/goldmark v1.1.30 // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
+	go.uber.org/zap v1.15.0
-	github.com/spf13/pflag v1.0.5 // indirect
+	golang.org/x/crypto v0.0.0-20200429183012-4b2356b1ed79 // indirect
-	github.com/ugorji/go/codec v1.2.7 // indirect
+	golang.org/x/lint v0.0.0-20200302205851-738671d3881b // indirect
-	github.com/ulikunitz/xz v0.5.10 // indirect
+	golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0 // indirect
-	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
-	go.uber.org/atomic v1.10.0 // indirect
+	golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f // indirect
-	go.uber.org/multierr v1.8.0 // indirect
+	golang.org/x/tools v0.0.0-20200509030707-2212a7e161a5 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
-	golang.org/x/net v0.0.0-20221004154528-8021a29435af // indirect
+	gopkg.in/ini.v1 v1.51.0
-	golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec // indirect
+	gopkg.in/yaml.v2 v2.2.8
-	golang.org/x/term v0.0.0-20220919170432-7a66f970e087 // indirect
+	gotest.tools v2.2.0+incompatible // indirect
-	golang.org/x/text v0.3.7 // indirect
+	honnef.co/go/tools v0.0.1-2020.1.3 // indirect
-	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af // indirect
-	golang.org/x/tools v0.1.12 // indirect
-	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
-	modernc.org/libc v1.20.0 // indirect
-	modernc.org/mathutil v1.5.0 // indirect
-	modernc.org/memory v1.4.0 // indirect
-	modernc.org/sqlite v1.19.1 // indirect
 )

installer/installer.go

@@ -1,51 +1,143 @@
 package installer
 
 import (
-	"context"
+	"encoding/json"
-
-	"emperror.dev/errors"
 	"github.com/asaskevich/govalidator"
-	"github.com/pterodactyl/wings/remote"
+	"github.com/buger/jsonparser"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/server"
+	"go.uber.org/zap"
+	"os"
+	"path"
 )
 
 type Installer struct {
-	server            *server.Server
+	server *server.Server
-	StartOnCompletion bool
 }
 
-type ServerDetails struct {
+// Validates the received data to ensure that all of the required fields
-	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, details ServerDetails) (*Installer, error) {
+func New(data []byte) (*Installer, error) {
-	if !govalidator.IsUUIDv4(details.UUID) {
+	if !govalidator.IsUUIDv4(getString(data, "uuid")) {
 		return nil, NewValidationError("uuid provided was not in a valid format")
 	}
 
-	c, err := manager.Client().GetServerConfiguration(ctx, details.UUID)
+	if !govalidator.IsUUIDv4(getString(data, "service", "egg")) {
-	if err != nil {
+		return nil, NewValidationError("service egg provided was not in a valid format")
-		if !remote.IsRequestError(err) {
-			return nil, errors.WithStackIf(err)
-		}
-		return nil, errors.WrapIf(err, "installer: could not get server configuration from remote API")
 	}
 
+	s := &server.Server{
+		Uuid:       getString(data, "uuid"),
+		Suspended:  false,
+		State:      server.ProcessOfflineState,
+		Invocation: getString(data, "invocation"),
+		EnvVars:    make(map[string]string),
+		Build: server.BuildSettings{
+			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"),
+		},
+		Allocations: server.Allocations{
+			Mappings: make(map[string][]int),
+		},
+	}
+
+	s.Allocations.DefaultMapping.Ip = getString(data, "allocations", "default", "ip")
+	s.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.WithStack(err)
+	} else {
+		s.EnvVars = make(map[string]string)
+		if err := json.Unmarshal(b, &s.EnvVars); err != nil {
+			return nil, errors.WithStack(err)
+		}
+	}
+
+	// Unmarshal the allocation mappings from the request into the server struct.
+	if b, _, _, err := jsonparser.Get(data, "allocations", "mappings"); err != nil {
+		return nil, errors.WithStack(err)
+	} else {
+		s.Allocations.Mappings = make(map[string][]int)
+		if err := json.Unmarshal(b, &s.Allocations.Mappings); err != nil {
+			return nil, errors.WithStack(err)
+		}
+	}
+
+	s.Container.Image = getString(data, "container", "image")
+
+	c, rerr, err := api.NewRequester().GetServerConfiguration(s.Uuid)
+	if err != nil || rerr != nil {
+		if err != nil {
+			return nil, errors.WithStack(err)
+		}
+
+		return nil, errors.New(rerr.String())
+	}
+
+	// Destroy the temporary server instance.
+	s = nil
+
 	// Create a new server instance using the configuration we wrote to the disk
 	// so that everything gets instantiated correctly on the struct.
-	s, err := manager.InitServer(c)
+	s2, err := server.FromConfiguration(c)
-	if err != nil {
+
-		return nil, errors.WrapIf(err, "installer: could not init server instance")
+	return &Installer{
-	}
+		server: s2,
-	i := Installer{server: s, StartOnCompletion: details.StartOnCompletion}
+	}, err
-	return &i, nil
 }
 
-// Server returns the server instance.
+// Returns the UUID associated with this installer instance.
+func (i *Installer) Uuid() string {
+	return i.server.Uuid
+}
+
+// Return the server instance.
 func (i *Installer) Server() *server.Server {
 	return i.server
 }
+
+// Executes the installer process, creating the server and running through the
+// associated installation process based on the parameters passed through for
+// the server instance.
+func (i *Installer) Execute() {
+	zap.S().Debugw("creating required server data directory", zap.String("server", i.Uuid()))
+	if err := os.MkdirAll(path.Join(config.Get().System.Data, i.Uuid()), 0755); err != nil {
+		zap.S().Errorw("failed to create server data directory", zap.String("server", i.Uuid()), zap.Error(errors.WithStack(err)))
+		return
+	}
+
+	if err := os.Chown(path.Join(config.Get().System.Data, i.Uuid()), config.Get().System.User.Uid, config.Get().System.User.Gid); err != nil {
+		zap.S().Errorw("failed to chown server data directory", zap.String("server", i.Uuid()), zap.Error(errors.WithStack(err)))
+		return
+	}
+
+	zap.S().Debugw("creating required environment for server instance", zap.String("server", i.Uuid()))
+	if err := i.server.Environment.Create(); err != nil {
+		zap.S().Errorw("failed to create environment for server", zap.String("server", i.Uuid()), zap.Error(err))
+		return
+	}
+
+	zap.S().Debugw("created environment for server during install process", zap.String("server", i.Uuid()))
+}
+
+// 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
+}

internal/cron/activity_cron.go

@@ -1,57 +0,0 @@
-package cron
-
-import (
-	"context"
-	"emperror.dev/errors"
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-)
-
-type activityCron struct {
-	mu      *system.AtomicBool
-	manager *server.Manager
-	max     int
-}
-
-// Run executes the cronjob and ensures we fetch and send all of the stored activity to the
-// Panel instance. Once activity is sent it is deleted from the local database instance. Any
-// SFTP specific events are not handled in this cron, they're handled seperately to account
-// for de-duplication and event merging.
-func (ac *activityCron) Run(ctx context.Context) error {
-	// Don't execute this cron if there is currently one running. Once this task is completed
-	// go ahead and mark it as no longer running.
-	if !ac.mu.SwapIf(true) {
-		return errors.WithStack(ErrCronRunning)
-	}
-	defer ac.mu.Store(false)
-
-	var activity []models.Activity
-	tx := database.Instance().WithContext(ctx).
-		Where("event NOT LIKE ?", "server:sftp.%").
-		Limit(ac.max).
-		Find(&activity)
-
-	if tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if len(activity) == 0 {
-		return nil
-	}
-
-	if err := ac.manager.Client().SendActivityLogs(ctx, activity); err != nil {
-		return errors.WrapIf(err, "cron: failed to send activity events to Panel")
-	}
-
-	var ids []int
-	for _, v := range activity {
-		ids = append(ids, v.ID)
-	}
-
-	tx = database.Instance().WithContext(ctx).Where("id IN ?", ids).Delete(&models.Activity{})
-	if tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	return nil
-}

internal/cron/cron.go

@@ -1,71 +0,0 @@
-package cron
-
-import (
-	"context"
-	"emperror.dev/errors"
-	log2 "github.com/apex/log"
-	"github.com/go-co-op/gocron"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-	"time"
-)
-
-const ErrCronRunning = errors.Sentinel("cron: job already running")
-
-var o system.AtomicBool
-
-// Scheduler configures the internal cronjob system for Wings and returns the scheduler
-// instance to the caller. This should only be called once per application lifecycle, additional
-// calls will result in an error being returned.
-func Scheduler(ctx context.Context, m *server.Manager) (*gocron.Scheduler, error) {
-	if !o.SwapIf(true) {
-		return nil, errors.New("cron: cannot call scheduler more than once in application lifecycle")
-	}
-	l, err := time.LoadLocation(config.Get().System.Timezone)
-	if err != nil {
-		return nil, errors.Wrap(err, "cron: failed to parse configured system timezone")
-	}
-
-	activity := activityCron{
-		mu:      system.NewAtomicBool(false),
-		manager: m,
-		max:     config.Get().System.ActivitySendCount,
-	}
-
-	sftp := sftpCron{
-		mu:      system.NewAtomicBool(false),
-		manager: m,
-		max:     config.Get().System.ActivitySendCount,
-	}
-
-	s := gocron.NewScheduler(l)
-	log := log2.WithField("subsystem", "cron")
-
-	interval := time.Duration(config.Get().System.ActivitySendInterval) * time.Second
-	log.WithField("interval", interval).Info("configuring system crons")
-
-	_, _ = s.Tag("activity").Every(interval).Do(func() {
-		log.WithField("cron", "activity").Debug("sending internal activity events to Panel")
-		if err := activity.Run(ctx); err != nil {
-			if errors.Is(err, ErrCronRunning) {
-				log.WithField("cron", "activity").Warn("activity process is already running, skipping...")
-			} else {
-				log.WithField("cron", "activity").WithField("error", err).Error("activity process failed to execute")
-			}
-		}
-	})
-
-	_, _ = s.Tag("sftp").Every(interval).Do(func() {
-		log.WithField("cron", "sftp").Debug("sending sftp events to Panel")
-		if err := sftp.Run(ctx); err != nil {
-			if errors.Is(err, ErrCronRunning) {
-				log.WithField("cron", "sftp").Warn("sftp events process already running, skipping...")
-			} else {
-				log.WithField("cron", "sftp").WithField("error", err).Error("sftp events process failed to execute")
-			}
-		}
-	})
-
-	return s, nil
-}

internal/cron/sftp_cron.go

@@ -1,175 +0,0 @@
-package cron
-
-import (
-	"context"
-	"emperror.dev/errors"
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-	"reflect"
-)
-
-type sftpCron struct {
-	mu      *system.AtomicBool
-	manager *server.Manager
-	max     int
-}
-
-type mapKey struct {
-	User      string
-	Server    string
-	IP        string
-	Event     models.Event
-	Timestamp string
-}
-
-type eventMap struct {
-	max int
-	ids []int
-	m   map[mapKey]*models.Activity
-}
-
-// Run executes the SFTP reconciliation cron. This job will pull all of the SFTP specific events
-// and merge them together across user, server, ip, and event. This allows a SFTP event that deletes
-// tens or hundreds of files to be tracked as a single "deletion" event so long as they all occur
-// within the same one minute period of time (starting at the first timestamp for the group). Without
-// this we'd end up flooding the Panel event log with excessive data that is of no use to end users.
-func (sc *sftpCron) Run(ctx context.Context) error {
-	if !sc.mu.SwapIf(true) {
-		return errors.WithStack(ErrCronRunning)
-	}
-	defer sc.mu.Store(false)
-
-	var o int
-	activity, err := sc.fetchRecords(ctx, o)
-	if err != nil {
-		return err
-	}
-	o += len(activity)
-
-	events := &eventMap{
-		m:   map[mapKey]*models.Activity{},
-		ids: []int{},
-		max: sc.max,
-	}
-
-	for {
-		if len(activity) == 0 {
-			break
-		}
-		slen := len(events.ids)
-		for _, a := range activity {
-			events.Push(a)
-		}
-		if len(events.ids) > slen {
-			// Execute the query again, we found some events so we want to continue
-			// with this. Start at the next offset.
-			activity, err = sc.fetchRecords(ctx, o)
-			if err != nil {
-				return errors.WithStack(err)
-			}
-			o += len(activity)
-		} else {
-			break
-		}
-	}
-
-	if len(events.m) == 0 {
-		return nil
-	}
-	if err := sc.manager.Client().SendActivityLogs(ctx, events.Elements()); err != nil {
-		return errors.Wrap(err, "failed to send sftp activity logs to Panel")
-	}
-	if tx := database.Instance().Where("id IN ?", events.ids).Delete(&models.Activity{}); tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	return nil
-}
-
-// fetchRecords returns a group of activity events starting at the given offset. This is used
-// since we might need to make multiple database queries to select enough events to properly
-// fill up our request to the given maximum. This is due to the fact that this cron merges any
-// activity that line up across user, server, ip, and event into a single activity record when
-// sending the data to the Panel.
-func (sc *sftpCron) fetchRecords(ctx context.Context, offset int) (activity []models.Activity, err error) {
-	tx := database.Instance().WithContext(ctx).
-		Where("event LIKE ?", "server:sftp.%").
-		Order("event DESC").
-		Offset(offset).
-		Limit(sc.max).
-		Find(&activity)
-	if tx.Error != nil {
-		err = errors.WithStack(tx.Error)
-	}
-	return
-}
-
-// Push adds an activity to the event mapping, or de-duplicates it and merges the files metadata
-// into the existing entity that exists.
-func (em *eventMap) Push(a models.Activity) {
-	m := em.forActivity(a)
-	// If no activity entity is returned we've hit the cap for the number of events to
-	// send along to the Panel. Just skip over this record and we'll account for it in
-	// the next iteration.
-	if m == nil {
-		return
-	}
-	em.ids = append(em.ids, a.ID)
-	// Always reduce this to the first timestamp that was recorded for the set
-	// of events, and not
-	if a.Timestamp.Before(m.Timestamp) {
-		m.Timestamp = a.Timestamp
-	}
-	list := m.Metadata["files"].([]interface{})
-	if s, ok := a.Metadata["files"]; ok {
-		v := reflect.ValueOf(s)
-		if v.Kind() != reflect.Slice || v.IsNil() {
-			return
-		}
-		for i := 0; i < v.Len(); i++ {
-			list = append(list, v.Index(i).Interface())
-		}
-		// You must set it again at the end of the process, otherwise you've only updated the file
-		// slice in this one loop since it isn't passed by reference. This is just shorter than having
-		// to explicitly keep casting it to the slice.
-		m.Metadata["files"] = list
-	}
-}
-
-// Elements returns the finalized activity models.
-func (em *eventMap) Elements() (out []models.Activity) {
-	for _, v := range em.m {
-		out = append(out, *v)
-	}
-	return
-}
-
-// forActivity returns an event entity from our map which allows existing matches to be
-// updated with additional files.
-func (em *eventMap) forActivity(a models.Activity) *models.Activity {
-	key := mapKey{
-		User:   a.User.String,
-		Server: a.Server,
-		IP:     a.IP,
-		Event:  a.Event,
-		// We group by the minute, don't care about the seconds for this logic.
-		Timestamp: a.Timestamp.Format("2006-01-02_15:04"),
-	}
-	if v, ok := em.m[key]; ok {
-		return v
-	}
-	// Cap the size of the events map at the defined maximum events to send to the Panel. Just
-	// return nil and let the caller handle it.
-	if len(em.m) >= em.max {
-		return nil
-	}
-	// Doesn't exist in our map yet, create a copy of the activity passed into this
-	// function and then assign it into the map with an empty metadata value.
-	v := a
-	v.Metadata = models.ActivityMeta{
-		"files": make([]interface{}, 0),
-	}
-	em.m[key] = &v
-	return &v
-}

internal/database/database.go

@@ -1,57 +0,0 @@
-package database
-
-import (
-	"emperror.dev/errors"
-	"github.com/glebarez/sqlite"
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/system"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-	"path/filepath"
-	"time"
-)
-
-var o system.AtomicBool
-var db *gorm.DB
-
-// Initialize configures the local SQLite database for Wings and ensures that the models have
-// been fully migrated.
-func Initialize() error {
-	if !o.SwapIf(true) {
-		panic("database: attempt to initialize more than once during application lifecycle")
-	}
-	p := filepath.Join(config.Get().System.RootDirectory, "wings.db")
-	instance, err := gorm.Open(sqlite.Open(p), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		return errors.Wrap(err, "database: could not open database file")
-	}
-	db = instance
-	if sql, err := db.DB(); err != nil {
-		return errors.WithStack(err)
-	} else {
-		sql.SetMaxOpenConns(1)
-		sql.SetConnMaxLifetime(time.Hour)
-	}
-	if tx := db.Exec("PRAGMA synchronous = OFF"); tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if tx := db.Exec("PRAGMA journal_mode = MEMORY"); tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if err := db.AutoMigrate(&models.Activity{}); err != nil {
-		return errors.WithStack(err)
-	}
-	return nil
-}
-
-// Instance returns the gorm database instance that was configured when the application was
-// booted.
-func Instance() *gorm.DB {
-	if db == nil {
-		panic("database: attempt to access instance before initialized")
-	}
-	return db
-}

internal/models/activity.go

@@ -1,67 +0,0 @@
-package models
-
-import (
-	"github.com/pterodactyl/wings/system"
-	"gorm.io/gorm"
-	"time"
-)
-
-type Event string
-
-type ActivityMeta map[string]interface{}
-
-// Activity defines an activity log event for a server entity performed by a user. This is
-// used for tracking commands, power actions, and SFTP events so that they can be reconciled
-// and sent back to the Panel instance to be displayed to the user.
-type Activity struct {
-	ID int `gorm:"primaryKey;not null" json:"-"`
-	// User is UUID of the user that triggered this event, or an empty string if the event
-	// cannot be tied to a specific user, in which case we will assume it was the system
-	// user.
-	User JsonNullString `gorm:"type:uuid" json:"user"`
-	// Server is the UUID of the server this event is associated with.
-	Server string `gorm:"type:uuid;not null" json:"server"`
-	// Event is a string that describes what occurred, and is used by the Panel instance to
-	// properly associate this event in the activity logs.
-	Event Event `gorm:"index;not null" json:"event"`
-	// Metadata is either a null value, string, or a JSON blob with additional event specific
-	// metadata that can be provided.
-	Metadata ActivityMeta `gorm:"serializer:json" json:"metadata"`
-	// IP is the IP address that triggered this event, or an empty string if it cannot be
-	// determined properly. This should be the connecting user's IP address, and not the
-	// internal system IP.
-	IP        string    `gorm:"not null" json:"ip"`
-	Timestamp time.Time `gorm:"not null" json:"timestamp"`
-}
-
-// SetUser sets the current user that performed the action. If an empty string is provided
-// it is cast into a null value when stored.
-func (a Activity) SetUser(u string) *Activity {
-	var ns JsonNullString
-	if u == "" {
-		if err := ns.Scan(nil); err != nil {
-			panic(err)
-		}
-	} else {
-		if err := ns.Scan(u); err != nil {
-			panic(err)
-		}
-	}
-	a.User = ns
-	return &a
-}
-
-// BeforeCreate executes before we create any activity entry to ensure the IP address
-// is trimmed down to remove any extraneous data, and the timestamp is set to the current
-// system time and then stored as UTC.
-func (a *Activity) BeforeCreate(_ *gorm.DB) error {
-	a.IP = system.TrimIPSuffix(a.IP)
-	if a.Timestamp.IsZero() {
-		a.Timestamp = time.Now()
-	}
-	a.Timestamp = a.Timestamp.UTC()
-	if a.Metadata == nil {
-		a.Metadata = ActivityMeta{}
-	}
-	return nil
-}

internal/models/models.go

@@ -1,31 +0,0 @@
-package models
-
-import (
-	"database/sql"
-	"emperror.dev/errors"
-	"github.com/goccy/go-json"
-)
-
-type JsonNullString struct {
-	sql.NullString
-}
-
-func (v JsonNullString) MarshalJSON() ([]byte, error) {
-	if v.Valid {
-		return json.Marshal(v.String)
-	} else {
-		return json.Marshal(nil)
-	}
-}
-
-func (v *JsonNullString) UnmarshalJSON(data []byte) error {
-	var s *string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return errors.WithStack(err)
-	}
-	if s != nil {
-		v.String = *s
-	}
-	v.Valid = s != nil
-	return nil
-}

loggers/cli/cli.go

@@ -1,132 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"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)
-	bold    = color2.New(color2.Bold)
-	boldred = color2.New(color2.Bold, color2.FgRed)
-)
-
-var Strings = [...]string{
-	log.DebugLevel: "DEBUG",
-	log.InfoLevel:  " INFO",
-	log.WarnLevel:  " WARN",
-	log.ErrorLevel: "ERROR",
-	log.FatalLevel: "FATAL",
-}
-
-type Handler struct {
-	mu      sync.Mutex
-	Writer  io.Writer
-	Padding int
-}
-
-func New(w io.Writer, useColors bool) *Handler {
-	if f, ok := w.(*os.File); ok {
-		if useColors {
-			return &Handler{Writer: colorable.NewColorable(f), Padding: 2}
-		}
-	}
-
-	return &Handler{Writer: colorable.NewNonColorable(w), Padding: 2}
-}
-
-// HandleLog implements log.Handler.
-func (h *Handler) HandleLog(e *log.Entry) error {
-	color := cli.Colors[e.Level]
-	level := Strings[e.Level]
-	names := e.Fields.Names()
-
-	h.mu.Lock()
-	defer h.mu.Unlock()
-
-	color.Fprintf(h.Writer, "%s: [%s] %-25s", bold.Sprintf("%*s", h.Padding+1, level), time.Now().Format(time.StampMilli), e.Message)
-
-	for _, name := range names {
-		if name == "source" {
-			continue
-		}
-		fmt.Fprintf(h.Writer, " %s=%v", color.Sprint(name), e.Fields.Get(name))
-	}
-
-	fmt.Fprintln(h.Writer)
-
-	for _, name := range names {
-		if name != "error" {
-			continue
-		}
-
-		if err, ok := e.Fields.Get("error").(error); ok {
-			// Attach the stacktrace if it is missing at this point, but don't point
-			// it specifically to this line since that is irrelevant.
-			err = errors.WithStackDepthIf(err, 4)
-			formatted := fmt.Sprintf("\n%s\n%+v\n\n", boldred.Sprintf("Stacktrace:"), err)
-
-			if !strings.Contains(formatted, "runtime.goexit") {
-				_, _ = fmt.Fprint(h.Writer, formatted)
-				break
-			}
-
-			// Inserts a new-line between sections of a stack.
-			// When wrapping errors, you get multiple separate stacks that start with their message,
-			// this allows us to separate them with a new-line and view them more easily.
-			//
-			// For example:
-			//
-			// Stacktrace:
-			// readlink test: no such file or directory
-			// failed to read symlink target for 'test'
-			// github.com/pterodactyl/wings/server/filesystem.(*Archive).addToArchive
-			//         github.com/pterodactyl/wings/server/filesystem/archive.go:166
-			// ... (Truncated the stack for easier reading)
-			// runtime.goexit
-			//         runtime/asm_amd64.s:1374
-			// **NEW LINE INSERTED HERE**
-			// backup: error while generating server backup
-			// github.com/pterodactyl/wings/server.(*Server).Backup
-			//         github.com/pterodactyl/wings/server/backup.go:84
-			// ... (Truncated the stack for easier reading)
-			// runtime.goexit
-			//         runtime/asm_amd64.s:1374
-			//
-			var b strings.Builder
-			var endOfStack bool
-			for _, s := range strings.Split(formatted, "\n") {
-				b.WriteString(s + "\n")
-
-				if s == "runtime.goexit" {
-					endOfStack = true
-					continue
-				}
-
-				if !endOfStack {
-					continue
-				}
-
-				b.WriteString("\n")
-				endOfStack = false
-			}
-
-			_, _ = fmt.Fprint(h.Writer, b.String())
-		}
-
-		// Only one key with the name "error" can be in the map.
-		break
-	}
-
-	return nil
-}

parser/helpers.go

@@ -2,17 +2,16 @@ package parser
 
 import (
 	"bytes"
-	"io"
+	"github.com/Jeffail/gabs/v2"
+	"github.com/buger/jsonparser"
+	"github.com/iancoleman/strcase"
+	"github.com/pkg/errors"
+	"go.uber.org/zap"
+	"io/ioutil"
 	"os"
 	"regexp"
 	"strconv"
 	"strings"
-
-	"emperror.dev/errors"
-	"github.com/Jeffail/gabs/v2"
-	"github.com/apex/log"
-	"github.com/buger/jsonparser"
-	"github.com/iancoleman/strcase"
 )
 
 // Regex to match anything that has a value matching the format of {{ config.$1 }} which
@@ -38,29 +37,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, 0o644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 
-	return io.ReadAll(file)
+	return ioutil.ReadAll(file)
 }
 
 // Gets the value of a key based on the value type defined.
-func (cfr *ConfigurationFileReplacement) getKeyValue(value string) interface{} {
+func (cfr *ConfigurationFileReplacement) getKeyValue(value []byte) interface{} {
 	if cfr.ReplaceWith.Type() == jsonparser.Boolean {
-		v, _ := strconv.ParseBool(value)
+		v, _ := strconv.ParseBool(string(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(value); err == nil {
+	if v, err := strconv.Atoi(string(value)); err == nil {
 		return v
 	}
 
-	return value
+	return string(value)
 }
 
 // Iterate over an unstructured JSON/YAML/etc. interface and set all of the required
@@ -98,141 +97,66 @@ func (f *ConfigurationFile) IterateOverJson(data []byte) (*gabs.Container, error
 			// 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], "."), value); err != nil {
-					if errors.Is(err, gabs.ErrNotFound) {
+					return nil, err
-						continue
-					}
-					return nil, errors.WithMessage(err, "failed to set config value of array child")
 				}
 			}
-			continue
+		} else {
-		}
+			if err = v.SetAtPathway(parsed, v.Match, value); err != nil {
-
+				return nil, err
-		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)
 		}
 	}
 
 	return parsed, nil
 }
 
-// Regex used to check if there is an array element present in the given pathway by looking for something
-// along the lines of "something[1]" or "something[1].nestedvalue" as the path.
-var checkForArrayElement = regexp.MustCompile(`^([^\[\]]+)\[([\d]+)](\..+)?$`)
-
-// Attempt to set the value of the path depending on if it is an array or not. Gabs cannot handle array
-// values as "something[1]" but can parse them just fine. This is basically just overly complex code
-// to handle that edge case and ensure the value gets set correctly.
-//
-// Bless thee who has to touch these most unholy waters.
-func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
-	var err error
-
-	matches := checkForArrayElement.FindStringSubmatch(path)
-
-	// Check if we are **NOT** updating an array element.
-	if len(matches) < 3 {
-		_, err = c.SetP(value, path)
-		return err
-	}
-
-	i, _ := strconv.Atoi(matches[2])
-	// Find the array element "i" or try to create it if "i" is equal to 0 and is not found
-	// at the given path.
-	ct, err := c.ArrayElementP(i, matches[1])
-	if err != nil {
-		if i != 0 || (!errors.Is(err, gabs.ErrNotArray) && !errors.Is(err, gabs.ErrNotFound)) {
-			return errors.WithMessage(err, "error while parsing array element at path")
-		}
-
-		t := make([]interface{}, 1)
-		// If the length of matches is 4 it means we're trying to access an object down in this array
-		// key, so make sure we generate the array as an array of objects, and not just a generic nil
-		// array.
-		if len(matches) == 4 {
-			t = []interface{}{map[string]interface{}{}}
-		}
-
-		// If the error is because this isn't an array or isn't found go ahead and create the array with
-		// an empty object if we have additional things to set on the array, or just an empty array type
-		// if there is not an object structure detected (no matches[3] available).
-		if _, err = c.SetP(t, matches[1]); err != nil {
-			return errors.WithMessage(err, "failed to create empty array for missing element")
-		}
-
-		// Set our cursor to be the array element we expect, which in this case is just the first element
-		// since we won't run this code unless the array element is 0. There is too much complexity in trying
-		// to match additional elements. In those cases the server will just have to be rebooted or something.
-		ct, err = c.ArrayElementP(0, matches[1])
-		if err != nil {
-			return errors.WithMessage(err, "failed to find array element at path")
-		}
-	}
-
-	// Try to set the value. If the path does not exist an error will be raised to the caller which will
-	// then check if the error is because the path is missing. In those cases we just ignore the error since
-	// we don't want to do anything specifically when that happens.
-	//
-	// If there are four matches in the regex it means that we managed to also match a trailing pathway
-	// for the key, which should be found in the given array key item and modified further.
-	if len(matches) == 4 {
-		_, err = ct.SetP(value, strings.TrimPrefix(matches[3], "."))
-	} else {
-		_, err = ct.Set(value)
-	}
-
-	if err != nil {
-		return errors.WithMessage(err, "failed to set value at config path: "+path)
-	}
-
-	return nil
-}
-
 // 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 string) error {
+func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value []byte) error {
-	if cfr.IfValue == "" {
+	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.Exists(path) && strings.HasPrefix(cfr.IfValue, "regex:") {
+			// We're doing some regex here.
+			r, err := regexp.Compile(strings.TrimPrefix(cfr.IfValue, "regex:"))
+			if err != nil {
+				zap.S().Warnw(
+					"configuration if_value using invalid regexp, cannot do replacement",
+					zap.String("if_value", strings.TrimPrefix(cfr.IfValue, "regex:")),
+					zap.Error(err),
+				)
+				return nil
+			}
 
-	// Check if we are replacing instead of overwriting.
+			// If the path exists and there is a regex match, go ahead and attempt the replacement
-	if strings.HasPrefix(cfr.IfValue, "regex:") {
+			// using the value we got from the key. This will only replace the one match.
-		// Doing a regex replacement requires an existing value.
+			v := strings.Trim(string(c.Path(path).Bytes()), "\"")
-		// TODO: Do we try passing an empty string to the regex?
+			if r.Match([]byte(v)) {
-		if c.ExistsP(path) {
+				_, err := c.SetP(r.ReplaceAllString(v, string(value)), path)
-			return gabs.ErrNotFound
+
-		}
+				return err
+			}
 
-		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
+		} else {
+			if !c.Exists(path) || (c.Exists(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue))) {
+				return nil
+			}
 		}
-
-		v := strings.Trim(c.Path(path).String(), "\"")
-		if r.Match([]byte(v)) {
-			return setValueAtPath(c, path, r.ReplaceAllString(v, value))
-		}
-		return nil
 	}
 
-	if c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue)) {
+	_, err := c.SetP(cfr.getKeyValue(value), path)
-		return nil
-	}
 
-	return setValueAtPath(c, path, cfr.getKeyValue(value))
+	return err
 }
 
 // Looks up a configuration value on the Daemon given a dot-notated syntax.
-func (f *ConfigurationFile) LookupConfigurationValue(cfr ConfigurationFileReplacement) (string, error) {
+func (f *ConfigurationFile) LookupConfigurationValue(cfr ConfigurationFileReplacement) ([]byte, error) {
 	// If this is not something that we can do a regex lookup on then just continue
 	// on our merry way. If the value isn't a string, we're not going to be doing anything
 	// with it anyways.
 	if cfr.ReplaceWith.Type() != jsonparser.String || !configMatchRegex.Match(cfr.ReplaceWith.Value()) {
-		return cfr.ReplaceWith.String(), nil
+		return cfr.ReplaceWith.Value(), nil
 	}
 
 	// If there is a match, lookup the value in the configuration for the Daemon. If no key
@@ -252,15 +176,21 @@ func (f *ConfigurationFile) LookupConfigurationValue(cfr ConfigurationFileReplac
 	match, _, _, err := jsonparser.Get(f.configuration, path...)
 	if err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return string(match), err
+			return match, errors.WithStack(err)
 		}
 
-		log.WithFields(log.Fields{"path": path, "filename": f.FileName}).Debug("attempted to load a configuration value that does not exist")
+		zap.S().Debugw(
+			"attempted to load a configuration value that does not exist",
+			zap.Strings("path", path),
+			zap.String("filename", f.FileName),
+		)
 
 		// If there is no key, keep the original value intact, that way it is obvious there
 		// is a replace issue at play.
-		return string(match), nil
+		return match, nil
 	} else {
-		return configMatchRegex.ReplaceAllString(cfr.ReplaceWith.String(), string(match)), nil
+		replaced := []byte(configMatchRegex.ReplaceAllString(cfr.ReplaceWith.String(), string(match)))
+
+		return replaced, nil
 	}
 }

parser/parser.go

@@ -2,22 +2,20 @@ package parser
 
 import (
 	"bufio"
-	"os"
+	"encoding/json"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"emperror.dev/errors"
-	"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"
-	"gopkg.in/ini.v1"
+	"github.com/pkg/errors"
-	"gopkg.in/yaml.v3"
-
 	"github.com/pterodactyl/wings/config"
+	"go.uber.org/zap"
+	"gopkg.in/ini.v1"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strings"
 )
 
 // The file parsing options that are available for a server configuration file.
@@ -30,58 +28,10 @@ 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 {
+// Defines a configuration file for the server startup. These will be looped over
-	return string(cp)
+// 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"`
@@ -92,10 +42,12 @@ type ConfigurationFile struct {
 	configuration []byte
 }
 
-// UnmarshalJSON is a custom unmarshaler for configuration files. If there is an
+// Custom unmarshaler for configuration files. If there is an error while parsing out the
-// error while parsing out the replacements, don't fail the entire operation,
+// replacements, don't fail the entire operation, just log a global warning so someone can
-// just log a global warning so someone can find the issue, and return an empty
+// find the issue, and return an empty array of replacements.
-// array of replacements.
+//
+// I imagine people will notice configuration replacement isn't working correctly and then
+// the logs should help better expose that issue.
 func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	var m map[string]*json.RawMessage
 	if err := json.Unmarshal(data, &m); err != nil {
@@ -111,7 +63,11 @@ func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	}
 
 	if err := json.Unmarshal(*m["replace"], &f.Replace); err != nil {
-		log.WithField("file", f.FileName).WithField("error", err).Warn("failed to unmarshal configuration file replacement")
+		zap.S().Warnw(
+			"failed to unmarshal configuration file replacement",
+			zap.String("file", f.FileName),
+			zap.Error(err),
+		)
 
 		f.Replace = []ConfigurationFileReplacement{}
 	}
@@ -119,23 +75,28 @@ func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// ConfigurationFileReplacement defines a single find/replace instance for a
+// Regex to match paths such as foo[1].bar[2] and convert them into a format that
-// given server configuration file.
+// gabs can work with, such as foo.1.bar.2 in this case. This is applied when creating
+// the struct for the configuration file replacements.
+var cfrMatchReplacement = regexp.MustCompile(`\[(\d+)]`)
+
+// 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"`
 }
 
-// UnmarshalJSON handles unmarshaling the JSON representation into a struct that
+// Handles unmarshaling the JSON representation into a struct that provides more useful
-// provides more useful data to this functionality.
+// data to this functionality.
 func (cfr *ConfigurationFileReplacement) UnmarshalJSON(data []byte) error {
 	m, err := jsonparser.GetString(data, "match")
 	if err != nil {
 		return err
 	}
 
-	cfr.Match = m
+	// See comment on the replacement regex to understand what exactly this is doing.
+	cfr.Match = cfrMatchReplacement.ReplaceAllString(m, ".$1")
 
 	iv, err := jsonparser.GetString(data, "if_value")
 	// We only check keypath here since match & replace_with should be present on all of
@@ -170,7 +131,7 @@ func (cfr *ConfigurationFileReplacement) UnmarshalJSON(data []byte) error {
 // Parses a given configuration file and updates all of the values within as defined
 // in the API response from the Panel.
 func (f *ConfigurationFile) Parse(path string, internal bool) error {
-	log.WithField("path", path).WithField("parser", f.Parser.String()).Debug("parsing server configuration file")
+	zap.S().Debugw("parsing configuration file", zap.String("path", path), zap.String("parser", string(f.Parser)))
 
 	if mb, err := json.Marshal(config.Get()); err != nil {
 		return err
@@ -201,32 +162,27 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 		break
 	}
 
-	if errors.Is(err, os.ErrNotExist) {
+	if os.IsNotExist(err) {
 		// File doesn't exist, we tried creating it, and same error is returned? Pretty
 		// sure this pathway is impossible, but if not, abort here.
 		if internal {
 			return nil
 		}
 
-		b := strings.TrimSuffix(path, filepath.Base(path))
+		if _, err := os.Create(path); err != nil {
-		if err := os.MkdirAll(b, 0o755); err != nil {
+			return errors.WithStack(err)
-			return errors.WithMessage(err, "failed to create base directory for missing configuration file")
-		} else {
-			if _, err := os.Create(path); err != nil {
-				return errors.WithMessage(err, "failed to create missing configuration file")
-			}
 		}
 
 		return f.Parse(path, true)
 	}
 
-	return err
+	return errors.WithStack(err)
 }
 
 // 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, 0o644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
 	if err != nil {
 		return err
 	}
@@ -263,7 +219,7 @@ func (f *ConfigurationFile) parseXmlFile(path string) error {
 			parts := strings.Split(replacement.Match, ".")
 
 			// Set the initial element to be the root element, and then work from there.
-			element := doc.Root()
+			var element = doc.Root()
 
 			// Iterate over the path to create the required structure for the given element's path.
 			// This does not set a value, only ensures that the base structure exists. We start at index
@@ -280,13 +236,13 @@ func (f *ConfigurationFile) parseXmlFile(path string) error {
 
 		// Iterate over the elements we found and update their values.
 		for _, element := range doc.FindElements(path) {
-			if xmlValueMatchRegex.MatchString(value) {
+			if xmlValueMatchRegex.Match(value) {
-				k := xmlValueMatchRegex.ReplaceAllString(value, "$1")
+				k := xmlValueMatchRegex.ReplaceAllString(string(value), "$1")
-				v := xmlValueMatchRegex.ReplaceAllString(value, "$2")
+				v := xmlValueMatchRegex.ReplaceAllString(string(value), "$2")
 
 				element.CreateAttr(k, v)
 			} else {
-				element.SetText(value)
+				element.SetText(string(value))
 			}
 		}
 	}
@@ -317,13 +273,12 @@ func (f *ConfigurationFile) parseXmlFile(path string) error {
 // Parses an ini file.
 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
+	// by creating it if not exists.
-	// 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
 	}
-	file.Close()
+	defer file.Close()
 
 	cfg, err := ini.Load(path)
 	if err != nil {
@@ -331,29 +286,7 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	}
 
 	for _, replacement := range f.Replace {
-		var (
+		path := strings.SplitN(replacement.Match, ".", 2)
-			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 {
@@ -380,15 +313,24 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 		// If the key exists in the file go ahead and set the value, otherwise try to
 		// create it in the section.
 		if s.HasKey(k) {
-			s.Key(k).SetValue(value)
+			s.Key(k).SetValue(string(value))
 		} else {
-			if _, err := s.NewKey(k, value); err != nil {
+			if _, err := s.NewKey(k, string(value)); err != nil {
 				return err
 			}
 		}
 	}
 
-	return cfg.SaveTo(path)
+	// Truncate the file before attempting to write the changes.
+	if err := os.Truncate(path, 0); err != nil {
+		return err
+	}
+
+	if _, err := cfg.WriteTo(file); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // Parses a json file updating any matching key/value pairs. If a match is not found, the
@@ -406,7 +348,7 @@ func (f *ConfigurationFile) parseJsonFile(path string) error {
 	}
 
 	output := []byte(data.StringIndent("", "    "))
-	return os.WriteFile(path, output, 0o644)
+	return ioutil.WriteFile(path, output, 0644)
 }
 
 // Parses a yaml file and updates any matching key/value pairs before persisting
@@ -424,7 +366,7 @@ func (f *ConfigurationFile) parseYamlFile(path string) error {
 
 	// Unmarshal the yaml data into a JSON interface such that we can work with
 	// any arbitrary data structure. If we don't do this, I can't use gabs which
-	// makes working with unknown JSON significantly easier.
+	// makes working with unknown JSON signficiantly easier.
 	jsonBytes, err := json.Marshal(dyno.ConvertMapI2MapS(i))
 	if err != nil {
 		return err
@@ -443,98 +385,63 @@ func (f *ConfigurationFile) parseYamlFile(path string) error {
 		return err
 	}
 
-	return os.WriteFile(path, marshaled, 0o644)
+	return ioutil.WriteFile(path, marshaled, 0644)
 }
 
 // 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 := os.ReadFile(path)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
 	if err != nil {
 		return err
 	}
+	defer file.Close()
 
-	lines := strings.Split(string(input), "\n")
+	scanner := bufio.NewScanner(file)
-	for i, line := range lines {
+	for scanner.Scan() {
+		hasReplaced := false
+		t := scanner.Text()
+
+		// Iterate over the potential replacements for the line and check if there are
+		// any matches.
 		for _, replace := range f.Replace {
-			// If this line doesn't match what we expect for the replacement, move on to the next
+			if !strings.HasPrefix(t, replace.Match) {
-			// line. Otherwise, update the line to have the replacement value.
-			if !strings.HasPrefix(line, replace.Match) {
 				continue
 			}
 
-			lines[i] = replace.ReplaceWith.String()
+			hasReplaced = true
+			t = strings.Replace(t, replace.Match, replace.ReplaceWith.String(), 1)
+		}
+
+		// If there was a replacement that occurred on this specific line, do a write to the file
+		// immediately to write that modified content to the disk.
+		if hasReplaced {
+			if _, err := file.WriteAt([]byte(t), int64(len(scanner.Bytes()))); err != nil {
+				return err
+			}
 		}
 	}
 
-	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
+	if err := scanner.Err(); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-// parsePropertiesFile parses a properties file and updates the values within it
+// Parses a properties file and updates the values within it to match those that
-// to match those that are passed. Once completed the new file is written to the
+// are passed. Writes the file once completed.
-// 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 {
-	var s strings.Builder
-	// Open the file and attempt to load any comments that currenty exist at the start
-	// of the file. This is kind of a hack, but should work for a majority of users for
-	// the time being.
-	if fd, err := os.Open(path); err != nil {
-		return errors.Wrap(err, "parser: could not open file for reading")
-	} else {
-		scanner := bufio.NewScanner(fd)
-		// Scan until we hit a line that is not a comment that actually has content
-		// on it. Keep appending the comments until that time.
-		for scanner.Scan() {
-			text := scanner.Text()
-			if len(text) > 0 && text[0] != '#' {
-				break
-			}
-			s.WriteString(text + "\n")
-		}
-		_ = fd.Close()
-		if err := scanner.Err(); err != nil {
-			return errors.WithStackIf(err)
-		}
-	}
-
 	p, err := properties.LoadFile(path, properties.UTF8)
 	if err != nil {
-		return errors.Wrap(err, "parser: could not load properties file for configuration update")
+		return err
 	}
 
-	// Replace any values that need to be replaced.
 	for _, replace := range f.Replace {
 		data, err := f.LookupConfigurationValue(replace)
 		if err != nil {
-			return errors.Wrap(err, "parser: failed to lookup configuration value")
+			return err
 		}
 
 		v, ok := p.Get(replace.Match)
@@ -545,35 +452,17 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 			continue
 		}
 
-		if _, _, err := p.Set(replace.Match, data); err != nil {
+		if _, _, err := p.Set(replace.Match, string(data)); err != nil {
-			return errors.Wrap(err, "parser: failed to set replacement value")
+			return err
 		}
 	}
 
-	// Add the new file content to the string builder.
+	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
-	for _, key := range p.Keys() {
-		value, ok := p.Get(key)
-		if !ok {
-			continue
-		}
-		// 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, 0o644)
 	if err != nil {
 		return err
 	}
-	defer w.Close()
 
-	// Write the data to the file.
+	_, err = p.Write(w, properties.UTF8)
-	if _, err := w.Write([]byte(s.String())); err != nil {
-		return errors.Wrap(err, "parser: failed to write properties file to disk")
-	}
 
-	return nil
+	return err
 }

parser/value.go

@@ -0,0 +1,22 @@
+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 {
+	return string(cv.value)
+}
+
+func (cv *ReplaceValue) Type() jsonparser.ValueType {
+	return cv.valueType
+}

remote/errors.go

@@ -1,64 +0,0 @@
-package remote
-
-import (
-	"fmt"
-	"net/http"
-
-	"emperror.dev/errors"
-)
-
-type RequestErrors struct {
-	Errors []RequestError `json:"errors"`
-}
-
-type RequestError struct {
-	response *http.Response
-	Code     string `json:"code"`
-	Status   string `json:"status"`
-	Detail   string `json:"detail"`
-}
-
-// IsRequestError checks if the given error is of the RequestError type.
-func IsRequestError(err error) bool {
-	var rerr *RequestError
-	if err == nil {
-		return false
-	}
-	return errors.As(err, &rerr)
-}
-
-// 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 {
-		c = re.response.StatusCode
-	}
-
-	return fmt.Sprintf("Error response from Panel: %s: %s (HTTP/%d)", re.Code, re.Detail, c)
-}
-
-// 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

@@ -1,304 +0,0 @@
-package remote
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"github.com/pterodactyl/wings/internal/models"
-	"io"
-	"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"
-)
-
-type Client interface {
-	GetBackupRemoteUploadURLs(ctx context.Context, backup string, size int64) (BackupRemoteUploadResponse, error)
-	GetInstallationScript(ctx context.Context, uuid string) (InstallationScript, error)
-	GetServerConfiguration(ctx context.Context, uuid string) (ServerConfigurationResponse, error)
-	GetServers(context context.Context, perPage int) ([]RawServerData, error)
-	ResetServersState(ctx context.Context) error
-	SetArchiveStatus(ctx context.Context, uuid string, successful bool) error
-	SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error
-	SendRestorationStatus(ctx context.Context, backup string, successful bool) error
-	SetInstallationStatus(ctx context.Context, uuid string, successful bool) error
-	SetTransferStatus(ctx context.Context, uuid string, successful bool) error
-	ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error)
-	SendActivityLogs(ctx context.Context, activity []models.Activity) error
-}
-
-type client struct {
-	httpClient  *http.Client
-	baseUrl     string
-	tokenId     string
-	token       string
-	maxAttempts int
-}
-
-// New returns a new HTTP request client that is used for making authenticated
-// requests to the Panel that this instance is running under.
-func New(base string, opts ...ClientOption) Client {
-	c := client{
-		baseUrl: strings.TrimSuffix(base, "/") + "/api/remote",
-		httpClient: &http.Client{
-			Timeout: time.Second * 15,
-		},
-		maxAttempts: 0,
-	}
-	for _, opt := range opts {
-		opt(&c)
-	}
-	return &c
-}
-
-// WithCredentials sets the credentials to use when making request to the remote
-// API endpoint.
-func WithCredentials(id, token string) ClientOption {
-	return func(c *client) {
-		c.tokenId = id
-		c.token = token
-	}
-}
-
-// WithHttpClient sets the underlying HTTP client instance to use when making
-// requests to the Panel API.
-func WithHttpClient(httpClient *http.Client) ClientOption {
-	return func(c *client) {
-		c.httpClient = httpClient
-	}
-}
-
-// 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.NewRequestWithContext(ctx, method, c.baseUrl+path, body)
-	if err != nil {
-		return nil, err
-	}
-
-	req.Header.Set("User-Agent", fmt.Sprintf("Pterodactyl Wings/v%s (id:%s)", system.Version, c.tokenId))
-	req.Header.Set("Accept", "application/vnd.pterodactyl.v1+json")
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s.%s", c.tokenId, c.token))
-
-	// Call all opts functions to allow modifying the request
-	for _, o := range opts {
-		o(req)
-	}
-
-	debugLogRequest(req)
-
-	res, err := c.httpClient.Do(req)
-	return &Response{res}, err
-}
-
-// 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 *bytes.Buffer, opts ...func(r *http.Request)) (*Response, error) {
-	var res *Response
-	err := backoff.Retry(func() error {
-		var b bytes.Buffer
-		if body != nil {
-			// We have to create a copy of the body, otherwise attempting this request again will
-			// send no data if there was initially a body since the "requestOnce" method will read
-			// the whole buffer, thus leaving it empty at the end.
-			if _, err := b.Write(body.Bytes()); err != nil {
-				return backoff.Permanent(errors.Wrap(err, "http: failed to copy body buffer"))
-			}
-		}
-		r, err := c.requestOnce(ctx, method, path, &b, opts...)
-		if err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return backoff.Permanent(err)
-			}
-			return errors.WrapIf(err, "http: request creation failed")
-		}
-		res = r
-		if r.HasError() {
-			// Close the request body after returning the error to free up resources.
-			defer r.Body.Close()
-			// Don't keep attempting to access this endpoint if the response is a 4XX
-			// level error which indicates a client mistake. Only retry when the error
-			// is due to a server issue (5XX error).
-			if r.StatusCode >= 400 && r.StatusCode < 500 {
-				return backoff.Permanent(r.Error())
-			}
-			return r.Error()
-		}
-		return nil
-	}, c.backoff(ctx))
-	if err != nil {
-		if v, ok := err.(*backoff.PermanentError); ok {
-			return nil, v.Unwrap()
-		}
-		return nil, err
-	}
-	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
-// handling and response parsing from the Panel API. This just embeds the normal
-// HTTP response from Go and we attach a few helper functions to it.
-type Response struct {
-	*http.Response
-}
-
-// HasError determines if the API call encountered an error. If no request has
-// been made the response will be false. This function will evaluate to true if
-// the response code is anything 300 or higher.
-func (r *Response) HasError() bool {
-	if r.Response == nil {
-		return false
-	}
-
-	return r.StatusCode >= 300 || r.StatusCode < 200
-}
-
-// Reads the body from the response and returns it, then replaces it on the response
-// so that it can be read again later. This does not close the response body, so any
-// functions calling this should be sure to manually defer a Body.Close() call.
-func (r *Response) Read() ([]byte, error) {
-	var b []byte
-	if r.Response == nil {
-		return nil, errors.New("remote: attempting to read missing response")
-	}
-	if r.Response.Body != nil {
-		b, _ = io.ReadAll(r.Response.Body)
-	}
-	r.Response.Body = io.NopCloser(bytes.NewBuffer(b))
-	return b, nil
-}
-
-// BindJSON binds a given interface with the data returned in the response. This
-// is a shortcut for calling Read and then manually calling json.Unmarshal on
-// the raw bytes.
-func (r *Response) BindJSON(v interface{}) error {
-	b, err := r.Read()
-	if err != nil {
-		return err
-	}
-	if err := json.Unmarshal(b, &v); err != nil {
-		return errors.Wrap(err, "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. 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 {
-	if !r.HasError() {
-		return nil
-	}
-
-	var errs RequestErrors
-	_ = r.BindJSON(&errs)
-
-	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 errors.WithStackDepth(e, 1)
-}
-
-// Logs the request into the debug log with all of the important request bits.
-// The authorization key will be cleaned up before being output.
-func debugLogRequest(req *http.Request) {
-	if l, ok := log.Log.(*log.Logger); ok && l.Level != log.DebugLevel {
-		return
-	}
-	headers := make(map[string][]string)
-	for k, v := range req.Header {
-		if k != "Authorization" || len(v) == 0 || len(v[0]) == 0 {
-			headers[k] = v
-			continue
-		}
-
-		headers[k] = []string{"(redacted)"}
-	}
-
-	log.WithFields(log.Fields{
-		"method":   req.Method,
-		"endpoint": req.URL.String(),
-		"headers":  headers,
-	}).Debug("making request to external HTTP endpoint")
-}

remote/http_test.go

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

remote/servers.go

@@ -1,213 +0,0 @@
-package remote
-
-import (
-	"context"
-	"fmt"
-	"strconv"
-	"sync"
-
-	"github.com/pterodactyl/wings/internal/models"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"golang.org/x/sync/errgroup"
-)
-
-const (
-	ProcessStopCommand    = "command"
-	ProcessStopSignal     = "signal"
-	ProcessStopNativeStop = "stop"
-)
-
-// GetServers returns all of the servers that are present on the Panel making
-// parallel API calls to the endpoint if more than one page of servers is
-// returned.
-func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, error) {
-	servers, meta, err := c.getServersPaged(ctx, 0, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	var mu sync.Mutex
-	if meta.LastPage > 1 {
-		g, ctx := errgroup.WithContext(ctx)
-		for page := meta.CurrentPage + 1; page <= meta.LastPage; page++ {
-			page := page
-			g.Go(func() error {
-				ps, _, err := c.getServersPaged(ctx, int(page), limit)
-				if err != nil {
-					return err
-				}
-				mu.Lock()
-				servers = append(servers, ps...)
-				mu.Unlock()
-				return nil
-			})
-		}
-		if err := g.Wait(); err != nil {
-			return nil, err
-		}
-	}
-
-	return servers, nil
-}
-
-// ResetServersState updates the state of all servers on the node that are
-// currently marked as "installing" or "restoring from backup" to be marked as
-// a normal successful install state.
-//
-// This handles Wings exiting during either of these processes which will leave
-// things in a bad state within the Panel. This API call is executed once Wings
-// has fully booted all of the servers.
-func (c *client) ResetServersState(ctx context.Context) error {
-	res, err := c.Post(ctx, "/servers/reset", nil)
-	if err != nil {
-		return errors.WrapIf(err, "remote: failed to reset server state on Panel")
-	}
-	_ = res.Body.Close()
-	return nil
-}
-
-func (c *client) GetServerConfiguration(ctx context.Context, uuid string) (ServerConfigurationResponse, error) {
-	var config ServerConfigurationResponse
-	res, err := c.Get(ctx, fmt.Sprintf("/servers/%s", uuid), nil)
-	if err != nil {
-		return config, err
-	}
-	defer res.Body.Close()
-
-	err = res.BindJSON(&config)
-	return config, err
-}
-
-func (c *client) GetInstallationScript(ctx context.Context, uuid string) (InstallationScript, error) {
-	res, err := c.Get(ctx, fmt.Sprintf("/servers/%s/install", uuid), nil)
-	if err != nil {
-		return InstallationScript{}, err
-	}
-	defer res.Body.Close()
-
-	var config InstallationScript
-	err = res.BindJSON(&config)
-	return config, err
-}
-
-func (c *client) SetInstallationStatus(ctx context.Context, uuid string, successful bool) error {
-	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), d{"successful": successful})
-	if err != nil {
-		return err
-	}
-	_ = 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})
-	if err != nil {
-		return err
-	}
-	_ = resp.Body.Close()
-	return nil
-}
-
-func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful bool) error {
-	state := "failure"
-	if successful {
-		state = "success"
-	}
-	resp, err := c.Get(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
-	if err != nil {
-		return err
-	}
-	_ = resp.Body.Close()
-	return nil
-}
-
-// ValidateSftpCredentials makes a request to determine if the username and
-// password combination provided is associated with a valid server on the instance
-// using the Panel's authentication control mechanisms. This will get itself
-// throttled if too many requests are made, allowing us to completely offload
-// all of the authorization security logic to the Panel.
-func (c *client) ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error) {
-	var auth SftpAuthResponse
-	res, err := c.Post(ctx, "/sftp/auth", request)
-	if err != nil {
-		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()
-
-	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)})
-	if err != nil {
-		return data, err
-	}
-	defer res.Body.Close()
-	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)
-	if err != nil {
-		return err
-	}
-	_ = 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})
-	if err != nil {
-		return err
-	}
-	_ = resp.Body.Close()
-	return nil
-}
-
-// SendActivityLogs sends activity logs back to the Panel for processing.
-func (c *client) SendActivityLogs(ctx context.Context, activity []models.Activity) error {
-	resp, err := c.Post(ctx, "/activity", d{"data": activity})
-	if err != nil {
-		return errors.WithStackIf(err)
-	}
-	_ = resp.Body.Close()
-	return nil
-}
-
-// getServersPaged returns a subset of servers from the Panel API using the
-// pagination query parameters.
-func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawServerData, Pagination, error) {
-	var r struct {
-		Data []RawServerData `json:"data"`
-		Meta Pagination      `json:"meta"`
-	}
-
-	res, err := c.Get(ctx, "/servers", q{
-		"page":     strconv.Itoa(page),
-		"per_page": strconv.Itoa(limit),
-	})
-	if err != nil {
-		return nil, r.Meta, err
-	}
-	defer res.Body.Close()
-	if err := res.BindJSON(&r); err != nil {
-		return nil, r.Meta, err
-	}
-	return r.Data, r.Meta, nil
-}

remote/types.go

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

router/downloader/downloader.go

@@ -1,361 +0,0 @@
-package downloader
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"mime"
-	"net"
-	"net/http"
-	"net/url"
-	"path/filepath"
-	"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 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.
-	//
-	// This specific error response just causes the client to not follow the redirect and
-	// returns the actual redirect response to the caller. Not perfect, but simple and most
-	// people won't be using URLs that redirect anyways hopefully?
-	//
-	// We'll re-evaluate this down the road if needed.
-	CheckRedirect: func(req *http.Request, via []*http.Request) error {
-		return http.ErrUseLastResponse
-	},
-}
-
-var instance = &Downloader{
-	// Tracks all the active downloads.
-	downloadCache: make(map[string]*Download),
-	// 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),
-}
-
-// Internal IP ranges that should be blocked if the resource requested resolves within.
-var internalRanges = []*net.IPNet{
-	mustParseCIDR("127.0.0.1/8"),
-	mustParseCIDR("10.0.0.0/8"),
-	mustParseCIDR("172.16.0.0/12"),
-	mustParseCIDR("192.168.0.0/16"),
-	mustParseCIDR("169.254.0.0/16"),
-	mustParseCIDR("::1/128"),
-	mustParseCIDR("fe80::/10"),
-	mustParseCIDR("fc00::/7"),
-}
-
-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
-	onWrite func(total int)
-}
-
-func (c *Counter) Write(p []byte) (int, error) {
-	n := len(p)
-	c.total += n
-	c.onWrite(c.total)
-	return n, nil
-}
-
-type DownloadRequest struct {
-	Directory string
-	URL       *url.URL
-	FileName  string
-	UseHeader bool
-}
-
-type Download struct {
-	Identifier string
-	path       string
-	mu         sync.RWMutex
-	req        DownloadRequest
-	server     *server.Server
-	progress   float64
-	cancelFunc *context.CancelFunc
-}
-
-// 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{
-		Identifier: uuid.Must(uuid.NewRandom()).String(),
-		req:        r,
-		server:     s,
-	}
-	instance.track(&dl)
-	return &dl
-}
-
-// 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, ok := instance.downloadCache[id]; ok {
-				downloads = append(downloads, dl)
-			}
-		}
-	}
-	return downloads
-}
-
-// 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)
-}
-
-//goland:noinspection GoVetCopyLock
-func (dl Download) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Identifier string
-		Progress   float64
-	}{
-		Identifier: dl.Identifier,
-		Progress:   dl.Progress(),
-	})
-}
-
-// 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)
-	dl.cancelFunc = &cancel
-	defer dl.Cancel()
-
-	// Always ensure that we're checking the destination for the download to avoid a malicious
-	// user from accessing internal network resources.
-	if err := dl.isExternalNetwork(ctx); err != nil {
-		return err
-	}
-
-	// At this point we have verified the destination is not within the local network, so we can
-	// now make a request to that URL and pull down the file, saving it to the server's data
-	// directory.
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, dl.req.URL.String(), nil)
-	if err != nil {
-		return errors.WrapIf(err, "downloader: failed to create request")
-	}
-
-	req.Header.Set("User-Agent", "Pterodactyl Panel (https://pterodactyl.io)")
-	res, err := client.Do(req)
-	if err != nil {
-		return ErrDownloadFailed
-	}
-	defer res.Body.Close()
-	if res.StatusCode != http.StatusOK {
-		return errors.New("downloader: got bad response status from endpoint: " + res.Status)
-	}
-
-	// If there is a Content-Length header on this request go ahead and check that we can
-	// even write the whole file before beginning this process. If there is no header present
-	// we'll just have to give it a spin and see how it goes.
-	if res.ContentLength > 0 {
-		if err := dl.server.Filesystem().HasSpaceFor(res.ContentLength); err != nil {
-			return errors.WrapIf(err, "downloader: failed to write file: not enough space")
-		}
-	}
-
-	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))
-	if err := dl.server.Filesystem().Writefile(p, r); err != nil {
-		return errors.WrapIf(err, "downloader: failed to write file to server directory")
-	}
-	return nil
-}
-
-// 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 {
-		(*dl.cancelFunc)()
-	}
-	instance.remove(dl.Identifier)
-}
-
-// 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()
-}
-
-// 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()
-	defer dl.mu.RUnlock()
-	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 {
-	onWrite := func(t int) {
-		dl.mu.Lock()
-		defer dl.mu.Unlock()
-		dl.progress = float64(t) / float64(contentLength)
-	}
-	return &Counter{
-		onWrite: onWrite,
-	}
-}
-
-// Verifies that a given download resolves to a location not within the current local
-// network for the machine. If the final destination of a resource is within the local
-// network an ErrInternalResolution error is returned.
-func (dl *Download) isExternalNetwork(ctx context.Context) error {
-	dialer := &net.Dialer{
-		LocalAddr: nil,
-	}
-
-	host := dl.req.URL.Host
-
-	// This cluster-fuck of math and integer shit converts an integer IP into a proper IPv4.
-	// For example: 16843009 would become 1.1.1.1
-	//if i, err := strconv.ParseInt(host, 10, 64); err == nil {
-	//	host = strconv.FormatInt((i>>24)&0xFF, 10) + "." + strconv.FormatInt((i>>16)&0xFF, 10) + "." + strconv.FormatInt((i>>8)&0xFF, 10) + "." + strconv.FormatInt(i&0xFF, 10)
-	//}
-
-	if _, _, 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"
-		}
-	}
-
-	c, err := dialer.DialContext(ctx, "tcp", host)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	_ = c.Close()
-
-	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)
-	}
-	if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsInterfaceLocalMulticast() {
-		return errors.WithStack(ErrInternalResolution)
-	}
-	for _, block := range internalRanges {
-		if block.Contains(ip) {
-			return errors.WithStack(ErrInternalResolution)
-		}
-	}
-	return nil
-}
-
-// Downloader represents a global downloader that keeps track of all currently processing downloads
-// for the machine.
-type Downloader struct {
-	mu            sync.RWMutex
-	downloadCache map[string]*Download
-	serverCache   map[string][]string
-}
-
-// 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()
-	if _, ok := d.downloadCache[dl.Identifier]; !ok {
-		d.downloadCache[dl.Identifier] = dl
-		if _, ok := d.serverCache[sid]; !ok {
-			d.serverCache[sid] = []string{}
-		}
-		d.serverCache[sid] = append(d.serverCache[sid], dl.Identifier)
-	}
-}
-
-// 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()
-	if entry, ok := d.downloadCache[dlid]; ok {
-		return entry
-	}
-	return nil
-}
-
-// 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) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	if _, ok := d.downloadCache[dlID]; !ok {
-		return
-	}
-	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 {
-				out = append(out, k)
-			}
-		}
-		d.serverCache[sID] = out
-	}
-}
-
-func mustParseCIDR(ip string) *net.IPNet {
-	_, block, err := net.ParseCIDR(ip)
-	if err != nil {
-		panic(fmt.Errorf("downloader: failed to parse CIDR: %s", err))
-	}
-	return block
-}

router/error.go

@@ -2,65 +2,47 @@ package router
 
 import (
 	"fmt"
-	"net/http"
-	"os"
-	"strings"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
-
+	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/filesystem"
+	"go.uber.org/zap"
+	"net/http"
+	"os"
 )
 
 type RequestError struct {
-	err     error
+	Err     error
-	uuid    string
+	Uuid    string
-	message string
+	Message string
 	server  *server.Server
 }
 
-// Attaches an error to the gin.Context object for the request and ensures that it
-// has a proper stacktrace associated with it when doing so.
-//
-// If you just call c.Error(err) without using this function you'll likely end up
-// with an error that has no annotated stack on it.
-func WithError(c *gin.Context, err error) error {
-	return c.Error(errors.WithStackDepthIf(err, 1))
-}
-
 // Generates a new tracked error, which simply tracks the specific error that
 // is being passed in, and also assigned a UUID to the error so that it can be
 // cross referenced in the logs.
-func NewTrackedError(err error) *RequestError {
+func TrackedError(err error) *RequestError {
 	return &RequestError{
-		err:  err,
+		Err:     err,
-		uuid: uuid.Must(uuid.NewRandom()).String(),
+		Uuid:    uuid.Must(uuid.NewRandom()).String(),
+		Message: "",
 	}
 }
 
-// Same as NewTrackedError, except this will also attach the server instance that
+// Same as TrackedError, except this will also attach the server instance that
 // generated this server for the purposes of logging.
-func NewServerError(err error, s *server.Server) *RequestError {
+func TrackedServerError(err error, s *server.Server) *RequestError {
 	return &RequestError{
-		err:    err,
+		Err:     err,
-		uuid:   uuid.Must(uuid.NewRandom()).String(),
+		Uuid:    uuid.Must(uuid.NewRandom()).String(),
-		server: s,
+		Message: "",
+		server:  s,
 	}
 }
 
-func (e *RequestError) logger() *log.Entry {
-	if e.server != nil {
-		return e.server.Log().WithField("error_id", e.uuid).WithField("error", e.err)
-	}
-	return log.WithField("error_id", e.uuid).WithField("error", e.err)
-}
-
 // Sets the output message to display to the user in the error.
 func (e *RequestError) SetMessage(msg string) *RequestError {
-	e.message = msg
+	e.Message = msg
 	return e
 }
 
@@ -68,90 +50,50 @@ func (e *RequestError) SetMessage(msg string) *RequestError {
 // will also include the error UUID in the output so that the user can report that
 // and link the response to a specific error in the logs.
 func (e *RequestError) AbortWithStatus(status int, c *gin.Context) {
-	// In instances where the status has already been set just use that existing status
-	// since we cannot change it at this point, and trying to do so will emit a gin warning
-	// into the program output.
-	if c.Writer.Status() != 200 {
-		status = c.Writer.Status()
-	}
-
 	// If this error is because the resource does not exist, we likely do not need to log
 	// the error anywhere, just return a 404 and move on with our lives.
-	if errors.Is(e.err, os.ErrNotExist) {
+	if os.IsNotExist(e.Err) {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on the system.",
 		})
 		return
 	}
 
-	if strings.HasPrefix(e.err.Error(), "invalid URL escape") {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "Some of the data provided in the request appears to be escaped improperly.",
-		})
-		return
-	}
-
-	// If this is a Filesystem error just return it without all of the tracking code nonsense
-	// since we don't need to be logging it into the logs or anything, its just a normal error
-	// that the user can solve on their end.
-	if st, msg := e.getAsFilesystemError(); st != 0 {
-		c.AbortWithStatusJSON(st, gin.H{"error": msg})
-		return
-	}
-
 	// Otherwise, log the error to zap, and then report the error back to the user.
 	if status >= 500 {
-		e.logger().Error("unexpected error while handling HTTP request")
+		if e.server != nil {
+			zap.S().Errorw("encountered error while handling HTTP request", zap.String("server", e.server.Uuid), zap.String("error_id", e.Uuid), zap.Error(e.Err))
+		} else {
+			zap.S().Errorw("encountered error while handling HTTP request", zap.String("error_id", e.Uuid), zap.Error(e.Err))
+		}
+
+		c.Error(errors.WithStack(e))
 	} else {
-		e.logger().Debug("non-server error encountered while handling HTTP request")
+		if e.server != nil {
+			zap.S().Debugw("encountered error while handling HTTP request", zap.String("server", e.server.Uuid), zap.String("error_id", e.Uuid), zap.Error(e.Err))
+		} else {
+			zap.S().Debugw("encountered error while handling HTTP request", zap.String("error_id", e.Uuid), zap.Error(e.Err))
+		}
 	}
 
-	if e.message == "" {
+	msg := "An unexpected error was encountered while processing this request."
-		e.message = "An unexpected error was encountered while processing this request."
+	if e.Message != "" {
+		msg = e.Message
 	}
 
-	c.AbortWithStatusJSON(status, gin.H{"error": e.message, "error_id": e.uuid})
+	c.AbortWithStatusJSON(status, gin.H{
+		"error":    msg,
+		"error_id": e.Uuid,
+	})
 }
 
 // Helper function to just abort with an internal server error. This is generally the response
 // from most errors encountered by the API.
-func (e *RequestError) Abort(c *gin.Context) {
+func (e *RequestError) AbortWithServerError(c *gin.Context) {
 	e.AbortWithStatus(http.StatusInternalServerError, c)
 }
 
-// Looks at the given RequestError and determines if it is a specific filesystem error that
-// we can process and return differently for the user.
-func (e *RequestError) getAsFilesystemError() (int, string) {
-	// Some external things end up calling fmt.Errorf() on our filesystem errors
-	// which ends up just unleashing chaos on the system. For the sake of this
-	// fallback to using text checks...
-	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDenylistFile) || strings.Contains(e.err.Error(), "filesystem: file access prohibited") {
-		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
-	}
-	if filesystem.IsErrorCode(e.err, filesystem.ErrCodePathResolution) || strings.Contains(e.err.Error(), "resolves to a location outside the server root") {
-		return http.StatusNotFound, "The requested resource was not found on the system."
-	}
-	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeIsDirectory) || strings.Contains(e.err.Error(), "filesystem: is a directory") {
-		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
-	}
-	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDiskSpace) || strings.Contains(e.err.Error(), "filesystem: not enough disk space") {
-		return http.StatusBadRequest, "Cannot perform that action: not enough disk space available."
-	}
-	if strings.HasSuffix(e.err.Error(), "file name too long") {
-		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
-	}
-	if e, ok := e.err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
-		return http.StatusNotFound, "The requested directory does not exist."
-	}
-	return 0, ""
-}
-
-// Handle specific filesystem errors for a server.
-func (e *RequestError) AbortFilesystemError(c *gin.Context) {
-	e.Abort(c)
-}
-
 // Format the error to a string and include the UUID.
 func (e *RequestError) Error() string {
-	return fmt.Sprintf("%v (uuid: %s)", e.err, e.uuid)
+	return fmt.Sprintf("%v (uuid: %s)", e.Err, e.Uuid)
 }

router/middleware.go

@@ -2,16 +2,66 @@ package router
 
 import (
 	"github.com/gin-gonic/gin"
-
+	"github.com/google/uuid"
-	"github.com/pterodactyl/wings/router/middleware"
+	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/server"
+	"net/http"
+	"strings"
 )
 
-// ExtractServer returns the server instance from the gin context. If there is
+// Set the access request control headers on all of the requests.
-// no server set in the context (e.g. calling from a controller not protected
+func SetAccessControlHeaders(c *gin.Context) {
-// by ServerExists) this function will panic.
+	c.Header("Access-Control-Allow-Origin", config.Get().PanelLocation)
-//
+	c.Header("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
-// This function is deprecated. Use middleware.ExtractServer.
+	c.Next()
-func ExtractServer(c *gin.Context) *server.Server {
+}
-	return middleware.ExtractServer(c)
+
+// Authenticates the request token against the given permission string, ensuring that
+// if it is a server permission, the token has control over that server. If it is a global
+// token, this will ensure that the request is using a properly signed global token.
+func AuthorizationMiddleware(c *gin.Context) {
+	auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
+
+	if len(auth) != 2 || auth[0] != "Bearer" {
+		c.Header("WWW-Authenticate", "Bearer")
+		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+			"error": "The required authorization heads were not present in the request.",
+		})
+
+		return
+	}
+
+	// Try to match the request against the global token for the Daemon, regardless
+	// of the permission type. If nothing is matched we will fall through to the Panel
+	// API to try and validate permissions for a server.
+	if auth[1] == config.Get().AuthenticationToken {
+		c.Next()
+
+		return
+	}
+
+	c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+		"error": "You are not authorized to access this endpoint.",
+	})
+}
+
+// Helper function to fetch a server out of the servers collection stored in memory.
+func GetServer(uuid string) *server.Server {
+	return server.GetServers().Find(func(s *server.Server) bool {
+		return uuid == s.Uuid
+	})
+}
+
+// Ensure that the requested server exists in this setup. Returns a 404 if we cannot
+// locate it.
+func ServerExists(c *gin.Context) {
+	u, err := uuid.Parse(c.Param("server"))
+	if err != nil || GetServer(u.String()) == nil {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
+			"error": "The resource you requested does not exist.",
+		})
+		return
+	}
+
+	c.Next()
 }

router/middleware/middleware.go

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

router/router.go

@@ -1,58 +1,35 @@
 package router
 
 import (
-	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/router/middleware"
-	wserver "github.com/pterodactyl/wings/server"
 )
 
-// Configure configures the routing infrastructure for this daemon instance.
+// Configures the routing infrastructure for this daemon instance.
-func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
+func Configure() *gin.Engine {
-	gin.SetMode("release")
+	router := gin.Default()
+	router.Use(SetAccessControlHeaders)
 
-	router := gin.New()
+	router.OPTIONS("/api/system", func(c *gin.Context) {
-	router.Use(gin.Recovery())
+		c.Status(200)
-	router.SetTrustedProxies(config.Get().Api.TrustedProxies)
+	})
-	router.Use(middleware.AttachRequestID(), middleware.CaptureErrors(), middleware.SetAccessControlHeaders())
-	router.Use(middleware.AttachServerManager(m), middleware.AttachApiClient(client))
-	// @todo log this into a different file so you can setup IP blocking for abusive requests and such.
-	// This should still dump requests in debug mode since it does help with understanding the request
-	// lifecycle and quickly seeing what was called leading to the logs. However, it isn't feasible to mix
-	// this output in production and still get meaningful logs from it since they'll likely just be a huge
-	// spamfest.
-	router.Use(gin.LoggerWithFormatter(func(params gin.LogFormatterParams) string {
-		log.WithFields(log.Fields{
-			"client_ip":  params.ClientIP,
-			"status":     params.StatusCode,
-			"latency":    params.Latency,
-			"request_id": params.Keys["request_id"],
-		}).Debugf("%s %s", params.MethodColor()+params.Method+params.ResetColor(), params.Path)
-
-		return ""
-	}))
 
 	// These routes use signed URLs to validate access to the resource being requested.
 	router.GET("/download/backup", getDownloadBackup)
 	router.GET("/download/file", getDownloadFile)
-	router.POST("/upload/file", postServerUploadFiles)
 
 	// This route is special it sits above all of the other requests because we are
 	// using a JWT to authorize access to it, therefore it needs to be publicly
 	// accessible.
-	router.GET("/api/servers/:server/ws", middleware.ServerExists(), getServerWebsocket)
+	router.GET("/api/servers/:server/ws", ServerExists, getServerWebsocket)
 
 	// This request is called by another daemon when a server is going to be transferred out.
 	// This request does not need the AuthorizationMiddleware as the panel should never call it
 	// and requests are authenticated through a JWT the panel issues to the other daemon.
-	router.GET("/api/servers/:server/archive", middleware.ServerExists(), getServerArchive)
+	router.GET("/api/servers/:server/archive", ServerExists, getServerArchive)
 
 	// All of the routes beyond this mount will use an authorization middleware
 	// and will not be accessible without the correct Authorization header provided.
-	protected := router.Use(middleware.RequireAuthorization())
+	protected := router.Use(AuthorizationMiddleware)
 	protected.POST("/api/update", postUpdateConfiguration)
 	protected.GET("/api/system", getSystemInformation)
 	protected.GET("/api/servers", getAllServers)
@@ -62,9 +39,10 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	// These are server specific routes, and require that the request be authorized, and
 	// that the server exist on the Daemon.
 	server := router.Group("/api/servers/:server")
-	server.Use(middleware.RequireAuthorization(), middleware.ServerExists())
+	server.Use(AuthorizationMiddleware, ServerExists)
 	{
 		server.GET("", getServer)
+		server.PATCH("", patchServer)
 		server.DELETE("", deleteServer)
 
 		server.GET("/logs", getServerLogs)
@@ -72,8 +50,6 @@ func Configure(m *wserver.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
 		// this should only be triggered by the panel.
@@ -83,24 +59,16 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 		{
 			files.GET("/contents", getServerFileContents)
 			files.GET("/list-directory", getServerListDirectory)
-			files.PUT("/rename", putServerRenameFiles)
+			files.PUT("/rename", putServerRenameFile)
 			files.POST("/copy", postServerCopyFile)
 			files.POST("/write", postServerWriteFile)
 			files.POST("/create-directory", postServerCreateDirectory)
-			files.POST("/delete", postServerDeleteFiles)
+			files.POST("/delete", postServerDeleteFile)
-			files.POST("/compress", postServerCompressFiles)
-			files.POST("/decompress", postServerDecompressFiles)
-			files.POST("/chmod", postServerChmodFile)
-
-			files.GET("/pull", middleware.RemoteDownloadEnabled(), getServerPullingFiles)
-			files.POST("/pull", middleware.RemoteDownloadEnabled(), postServerPullRemoteFile)
-			files.DELETE("/pull/:download", middleware.RemoteDownloadEnabled(), deleteServerPullRemoteFile)
 		}
 
 		backup := server.Group("/backup")
 		{
 			backup.POST("", postServerBackup)
-			backup.POST("/:backup/restore", postServerRestoreBackup)
 			backup.DELETE("/:backup", deleteServerBackup)
 		}
 	}

router/router_download.go

@@ -2,59 +2,52 @@ package router
 
 import (
 	"bufio"
-	"errors"
+	"github.com/gin-gonic/gin"
+	"github.com/pterodactyl/wings/router/tokens"
+	"github.com/pterodactyl/wings/server/backup"
 	"net/http"
 	"os"
 	"strconv"
-
-	"github.com/gin-gonic/gin"
-
-	"github.com/pterodactyl/wings/router/middleware"
-	"github.com/pterodactyl/wings/router/tokens"
-	"github.com/pterodactyl/wings/server/backup"
 )
 
 // Handle a download request for a server backup.
 func getDownloadBackup(c *gin.Context) {
-	client := middleware.ExtractApiClient(c)
-	manager := middleware.ExtractManager(c)
-
 	token := tokens.BackupPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		TrackedError(err).AbortWithServerError(c)
 		return
 	}
 
-	s, ok := manager.Get(token.ServerUuid)
+	s := GetServer(token.ServerUuid)
-	if !ok || !token.IsUniqueRequest() {
+	if s == nil || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
 		return
 	}
 
-	b, st, err := backup.LocateLocal(client, token.BackupUuid)
+	b, st, err := backup.LocateLocal(token.BackupUuid)
 	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
+		if os.IsNotExist(err) {
 			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 				"error": "The requested backup was not found on this server.",
 			})
 			return
 		}
 
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
 
 	f, err := os.Open(b.Path())
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
 	defer f.Close()
 
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
+	c.Header("Content-Disposition", "attachment; filename="+st.Name())
 	c.Header("Content-Type", "application/octet-stream")
 
 	bufio.NewReader(f).WriteTo(c.Writer)
@@ -62,27 +55,26 @@ func getDownloadBackup(c *gin.Context) {
 
 // Handles downloading a specific file for a server.
 func getDownloadFile(c *gin.Context) {
-	manager := middleware.ExtractManager(c)
 	token := tokens.FilePayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		TrackedError(err).AbortWithServerError(c)
 		return
 	}
 
-	s, ok := manager.Get(token.ServerUuid)
+	s := GetServer(token.ServerUuid)
-	if !ok || !token.IsUniqueRequest() {
+	if s == nil || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
 		return
 	}
 
-	p, _ := s.Filesystem().SafePath(token.FilePath)
+	p, _ := s.Filesystem.SafePath(token.FilePath)
 	st, err := os.Stat(p)
 	// If there is an error or we're somehow trying to download a directory, just
 	// respond with the appropriate error.
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	} else if st.IsDir() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
@@ -93,12 +85,12 @@ func getDownloadFile(c *gin.Context) {
 
 	f, err := os.Open(p)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
 
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
+	c.Header("Content-Disposition", "attachment; filename="+st.Name())
 	c.Header("Content-Type", "application/octet-stream")
 
 	bufio.NewReader(f).WriteTo(c.Writer)

router/router_server.go

@@ -1,39 +1,33 @@
 package router
 
 import (
-	"context"
+	"bytes"
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/server"
+	"go.uber.org/zap"
 	"net/http"
 	"os"
 	"strconv"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/gin-gonic/gin"
-	"github.com/pterodactyl/wings/router/downloader"
-	"github.com/pterodactyl/wings/router/middleware"
-	"github.com/pterodactyl/wings/router/tokens"
-	"github.com/pterodactyl/wings/server"
 )
 
 // Returns a single server from the collection of servers.
 func getServer(c *gin.Context) {
-	c.JSON(http.StatusOK, ExtractServer(c).ToAPIResponse())
+	c.JSON(http.StatusOK, GetServer(c.Param("server")))
 }
 
 // Returns the logs for a given server instance.
 func getServerLogs(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
-	l, _ := strconv.Atoi(c.DefaultQuery("size", "100"))
+	l, _ := strconv.ParseInt(c.DefaultQuery("size", "8192"), 10, 64)
 	if l <= 0 {
-		l = 100
+		l = 2048
-	} else if l > 100 {
-		l = 100
 	}
 
 	out, err := s.ReadLogfile(l)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
 
@@ -49,18 +43,12 @@ func getServerLogs(c *gin.Context) {
 // things are happening, so theres no reason to sit and wait for a request to finish. We'll
 // just see over the socket if something isn't working correctly.
 func postServerPower(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
-	var data struct {
+	var data server.PowerAction
-		Action      server.PowerAction `json:"action"`
+	c.BindJSON(&data)
-		WaitSeconds int                `json:"wait_seconds"`
-	}
 
-	if err := c.BindJSON(&data); err != nil {
+	if !data.IsValid() {
-		return
-	}
-
-	if !data.Action.IsValid() {
 		c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
 			"error": "The power action provided was not valid, should be one of \"stop\", \"start\", \"restart\", \"kill\"",
 		})
@@ -73,41 +61,35 @@ func postServerPower(c *gin.Context) {
 	//
 	// We don't really care about any of the other actions at this point, they'll all result
 	// in the process being stopped, which should have happened anyways if the server is suspended.
-	if (data.Action == server.PowerActionStart || data.Action == server.PowerActionRestart) && s.IsSuspended() {
+	if (data.Action == "start" || data.Action == "restart") && s.Suspended {
 		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 			"error": "Cannot start or restart a server that is suspended.",
 		})
 		return
 	}
 
-	// Pass the actual heavy processing off to a separate thread to handle so that
+	// Pass the actual heavy processing off to a seperate thread to handle so that
 	// 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) {
+	go func() {
-		if data.WaitSeconds < 0 || data.WaitSeconds > 300 {
+		if err := s.HandlePowerAction(data); err != nil {
-			data.WaitSeconds = 30
+			zap.S().Errorw(
+				"encountered an error processing a server power action",
+				zap.String("server", s.Uuid),
+				zap.Error(err),
+			)
 		}
-		if err := s.HandlePowerAction(data.Action, data.WaitSeconds); err != nil {
+	}()
-			if errors.Is(err, context.DeadlineExceeded) {
-				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.Action, "wait_seconds": data.WaitSeconds, "error": err}).
-					Error("encountered error processing a server power action in the background")
-			}
-		}
-	}(s)
 
 	c.Status(http.StatusAccepted)
 }
 
 // Sends an array of commands to a running server instance.
 func postServerCommands(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
-	if running, err := s.Environment.IsRunning(c.Request.Context()); err != nil {
+	if running, err := s.Environment.IsRunning(); err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	} else if !running {
 		c.AbortWithStatusJSON(http.StatusBadGateway, gin.H{
@@ -116,44 +98,49 @@ func postServerCommands(c *gin.Context) {
 		return
 	}
 
-	var data struct {
+	var data struct{ Commands []string `json:"commands"` }
-		Commands []string `json:"commands"`
+	c.BindJSON(&data)
-	}
-	// BindJSON sends 400 if the request fails, all we need to do is return
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
 
 	for _, command := range data.Commands {
 		if err := s.Environment.SendCommand(command); err != nil {
-			s.Log().WithFields(log.Fields{"command": command, "error": err}).Warn("failed to send command to server instance")
+			zap.S().Warnw(
+				"failed to send command to server",
+				zap.String("server", s.Uuid),
+				zap.String("command", command),
+				zap.Error(err),
+			)
 		}
 	}
 
 	c.Status(http.StatusNoContent)
 }
 
-// postServerSync will accept a POST request and trigger a re-sync of the given
+// Updates information about a server internally.
-// server against the Panel. This can be manually triggered when needed by an
+func patchServer(c *gin.Context) {
-// external system, or triggered by the Panel itself when modifications are made
+	s := GetServer(c.Param("server"))
-// to the build of a server internally.
-func postServerSync(c *gin.Context) {
-	s := ExtractServer(c)
 
-	if err := s.Sync(); err != nil {
+	buf := bytes.Buffer{}
-		WithError(c, err)
+	buf.ReadFrom(c.Request.Body)
-	} else {
+
-		c.Status(http.StatusNoContent)
+	if err := s.UpdateDataStructure(buf.Bytes(), true); err != nil {
+		TrackedServerError(err, s).AbortWithServerError(c)
+		return
 	}
+
+	c.Status(http.StatusNoContent)
 }
 
 // Performs a server installation in a background thread.
 func postServerInstall(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
 	go func(serv *server.Server) {
-		if err := serv.Install(true); err != nil {
+		if err := serv.Install(); err != nil {
-			serv.Log().WithField("error", err).Error("failed to execute server installation process")
+			zap.S().Errorw(
+				"failed to execute server installation process",
+				zap.String("server", serv.Uuid),
+				zap.Error(err),
+			)
 		}
 	}(s)
 
@@ -162,44 +149,43 @@ func postServerInstall(c *gin.Context) {
 
 // Reinstalls a server.
 func postServerReinstall(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
-	if s.ExecutingPowerAction() {
+	go func(serv *server.Server) {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
+		if err := serv.Reinstall(); err != nil {
-			"error": "Cannot execute server reinstall event while another power action is running.",
+			zap.S().Errorw(
-		})
+				"failed to complete server reinstall process",
-		return
+				zap.String("server", serv.Uuid),
-	}
+				zap.Error(err),
-
+			)
-	go func(s *server.Server) {
-		if err := s.Reinstall(); err != nil {
-			s.Log().WithField("error", err).Error("failed to complete server re-install process")
 		}
 	}(s)
 
 	c.Status(http.StatusAccepted)
 }
 
-// Deletes a server from the wings daemon and dissociate its objects.
+// Deletes a server from the wings daemon and deassociates its objects.
 func deleteServer(c *gin.Context) {
-	s := middleware.ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
 	// Immediately suspend the server to prevent a user from attempting
 	// to start it while this process is running.
-	s.Config().SetSuspended(true)
+	s.Suspended = true
-	s.CleanupForDestroy()
 
-	// Remove any pending remote file downloads for the server.
+	// Delete the server's archive if it exists. We intentionally don't return
-	for _, dl := range downloader.ByServer(s.ID()) {
+	// here, if the archive fails to delete, the server can still be removed.
-		dl.Cancel()
+	if err := s.Archiver.DeleteIfExists(); err != nil {
+		zap.S().Warnw("failed to delete server archive during deletion process", zap.String("server", s.Uuid), zap.Error(err))
 	}
 
+	// Unsubscribe all of the event listeners.
+	s.Events().UnsubscribeAll()
+
 	// Destroy the environment; in Docker this will handle a running container and
 	// forcibly terminate it before removing the container, so we do not need to handle
 	// that here.
 	if err := s.Environment.Destroy(); err != nil {
-		WithError(c, err)
+		TrackedServerError(err, s).AbortWithServerError(c)
-		return
 	}
 
 	// Once the environment is terminated, remove the server files from the system. This is
@@ -210,12 +196,13 @@ func deleteServer(c *gin.Context) {
 	// so we don't want to block the HTTP call while waiting on this.
 	go func(p string) {
 		if err := os.RemoveAll(p); err != nil {
-			log.WithFields(log.Fields{"path": p, "error": err}).Warn("failed to remove server files during deletion process")
+			zap.S().Warnw("failed to remove server files during deletion process", zap.String("path", p), zap.Error(errors.WithStack(err)))
 		}
-	}(s.Filesystem().Path())
+	}(s.Filesystem.Path())
 
-	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
+	var uuid = s.Uuid
-		return server.ID() == s.ID()
+	server.GetServers().Remove(func(s2 *server.Server) bool {
+		return s2.Uuid == uuid
 	})
 
 	// Deallocate the reference to this server.
@@ -223,22 +210,3 @@ func deleteServer(c *gin.Context) {
 
 	c.Status(http.StatusNoContent)
 }
-
-// Adds any of the JTIs passed through in the body to the deny list for the websocket
-// preventing any JWT generated before the current time from being used to connect to
-// the socket or send along commands.
-func postServerDenyWSTokens(c *gin.Context) {
-	var data struct {
-		JTIs []string `json:"jtis"`
-	}
-
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	for _, jti := range data.JTIs {
-		tokens.DenyJTI(jti)
-	}
-
-	c.Status(http.StatusNoContent)
-}

router/router_server_backup.go

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

router/router_server_files.go

@@ -2,158 +2,104 @@ package router
 
 import (
 	"bufio"
-	"context"
+	"github.com/gin-gonic/gin"
-	"github.com/pterodactyl/wings/internal/models"
-	"io"
-	"mime/multipart"
 	"net/http"
 	"net/url"
 	"os"
-	"path"
-	"path/filepath"
 	"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"
 )
 
-// getServerFileContents returns the contents of a file on the server.
+// Returns the contents of a file on the server.
 func getServerFileContents(c *gin.Context) {
-	s := middleware.ExtractServer(c)
+	s := GetServer(c.Param("server"))
-	p := "/" + strings.TrimLeft(c.Query("file"), "/")
+
-	f, st, err := s.Filesystem().File(p)
+	p, err := url.QueryUnescape(c.Query("file"))
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
-	defer f.Close()
+	p = "/" + strings.TrimLeft(p, "/")
-	// Don't allow a named pipe to be opened.
+
-	//
+	cleaned, err := s.Filesystem.SafePath(p)
-	// @see https://github.com/pterodactyl/panel/issues/4059
+	if err != nil {
-	if st.Mode()&os.ModeNamedPipe != 0 {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": "The file requested could not be found.",
-			"error": "Cannot open files of this type.",
 		})
 		return
 	}
 
+	st, err := s.Filesystem.Stat(cleaned)
+	if err != nil {
+		TrackedServerError(err, s).AbortWithServerError(c)
+		return
+	}
+
+	if st.Info.IsDir() {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
+			"error": "The requested resource was not found on the system.",
+		})
+		return
+	}
+
+	f, err := os.Open(cleaned)
+	if err != nil {
+		TrackedServerError(err, s).AbortWithServerError(c)
+		return
+	}
+	defer f.Close()
+
 	c.Header("X-Mime-Type", st.Mimetype)
-	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
+	c.Header("Content-Length", strconv.Itoa(int(st.Info.Size())))
+
 	// If a download parameter is included in the URL go ahead and attach the necessary headers
 	// so that the file can be downloaded.
 	if c.Query("download") != "" {
-		c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
+		c.Header("Content-Disposition", "attachment; filename="+st.Info.Name())
 		c.Header("Content-Type", "application/octet-stream")
 	}
-	defer c.Writer.Flush()
+
-	// If you don't do a limited reader here you will trigger a panic on write when
+	bufio.NewReader(f).WriteTo(c.Writer)
-	// 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?
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
 }
 
 // Returns the contents of a directory for a server.
 func getServerListDirectory(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
-	dir := c.Query("directory")
+
-	if stats, err := s.Filesystem().ListDirectory(dir); err != nil {
+	d, err := url.QueryUnescape(c.Query("directory"))
-		WithError(c, err)
+	if err != nil {
-	} else {
+		TrackedServerError(err, s).AbortWithServerError(c)
-		c.JSON(http.StatusOK, stats)
+		return
 	}
+
+	stats, err := s.Filesystem.ListDirectory(d)
+	if err != nil {
+		TrackedServerError(err, s).AbortWithServerError(c)
+		return
+	}
+
+	c.JSON(http.StatusOK, stats)
 }
 
-type renameFile struct {
+// Renames (or moves) a file for a server.
-	To   string `json:"to"`
+func putServerRenameFile(c *gin.Context) {
-	From string `json:"from"`
+	s := GetServer(c.Param("server"))
-}
-
-// Renames (or moves) files for a server.
-func putServerRenameFiles(c *gin.Context) {
-	s := ExtractServer(c)
 
 	var data struct {
-		Root  string       `json:"root"`
+		RenameFrom string `json:"rename_from"`
-		Files []renameFile `json:"files"`
+		RenameTo   string `json:"rename_to"`
-	}
-	// BindJSON sends 400 if the request fails, all we need to do is return
-	if err := c.BindJSON(&data); err != nil {
-		return
 	}
+	c.BindJSON(&data)
 
-	if len(data.Files) == 0 {
+	if data.RenameFrom == "" || data.RenameTo == "" {
 		c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
-			"error": "No files to move or rename were provided.",
+			"error": "Invalid paths were provided, did you forget to provide both a new and old path?",
 		})
 		return
 	}
 
-	g, ctx := errgroup.WithContext(c.Request.Context())
+	if err := s.Filesystem.Rename(data.RenameFrom, data.RenameTo); err != nil {
-	// Loop over the array of files passed in and perform the move or rename action against each.
+		TrackedServerError(err, s).AbortWithServerError(c)
-	for _, p := range data.Files {
-		pf := path.Join(data.Root, p.From)
-		pt := path.Join(data.Root, p.To)
-
-		g.Go(func() error {
-			select {
-			case <-ctx.Done():
-				return ctx.Err()
-			default:
-				fs := s.Filesystem()
-				// Ignore renames on a file that is on the denylist (both as the rename from or
-				// the rename to value).
-				if err := fs.IsIgnored(pf, pt); err != nil {
-					return err
-				}
-				if err := fs.Rename(pf, pt); err != nil {
-					// Return nil if the error is an is not exists.
-					// NOTE: os.IsNotExist() does not work if the error is wrapped.
-					if errors.Is(err, os.ErrNotExist) {
-						s.Log().WithField("error", err).
-							WithField("from_path", pf).
-							WithField("to_path", pt).
-							Warn("failed to rename: source or target does not exist")
-						return nil
-					}
-					return err
-				}
-				return nil
-			}
-		})
-	}
-
-	if err := g.Wait(); err != nil {
-		if errors.Is(err, os.ErrExist) {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "Cannot move or rename file, destination already exists.",
-			})
-			return
-		}
-
-		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}
 
@@ -162,67 +108,32 @@ func putServerRenameFiles(c *gin.Context) {
 
 // Copies a server file.
 func postServerCopyFile(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
 	var data struct {
 		Location string `json:"location"`
 	}
-	// BindJSON sends 400 if the request fails, all we need to do is return
+	c.BindJSON(&data)
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
 
-	if err := s.Filesystem().IsIgnored(data.Location); err != nil {
+	if err := s.Filesystem.Copy(data.Location); err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
-		return
-	}
-	if err := s.Filesystem().Copy(data.Location); err != nil {
-		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}
 
 	c.Status(http.StatusNoContent)
 }
 
-// Deletes files from a server.
+// Deletes a server file.
-func postServerDeleteFiles(c *gin.Context) {
+func postServerDeleteFile(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
 	var data struct {
-		Root  string   `json:"root"`
+		Location string `json:"location"`
-		Files []string `json:"files"`
 	}
+	c.BindJSON(&data)
 
-	if err := c.BindJSON(&data); err != nil {
+	if err := s.Filesystem.Delete(data.Location); err != nil {
-		return
+		TrackedServerError(err, s).AbortWithServerError(c)
-	}
-
-	if len(data.Files) == 0 {
-		c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
-			"error": "No files were specified for deletion.",
-		})
-		return
-	}
-
-	g, ctx := errgroup.WithContext(context.Background())
-
-	// Loop over the array of files passed in and delete them. If any of the file deletions
-	// fail just abort the process entirely.
-	for _, p := range data.Files {
-		pi := path.Join(data.Root, p)
-
-		g.Go(func() error {
-			select {
-			case <-ctx.Done():
-				return ctx.Err()
-			default:
-				return s.Filesystem().Delete(pi)
-			}
-		})
-	}
-
-	if err := g.Wait(); err != nil {
-		NewServerError(err, s).Abort(c)
 		return
 	}
 
@@ -231,397 +142,37 @@ func postServerDeleteFiles(c *gin.Context) {
 
 // Writes the contents of the request to a file on a server.
 func postServerWriteFile(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
-	f := c.Query("file")
+	f, err := url.QueryUnescape(c.Query("file"))
+	if err != nil {
+		TrackedServerError(err, s).AbortWithServerError(c)
+		return
+	}
 	f = "/" + strings.TrimLeft(f, "/")
 
-	if err := s.Filesystem().IsIgnored(f); err != nil {
+	if err := s.Filesystem.Writefile(f, c.Request.Body); err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
-		return
-	}
-	if err := s.Filesystem().Writefile(f, c.Request.Body); err != nil {
-		if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "Cannot write file, name conflicts with an existing directory by the same name.",
-			})
-			return
-		}
-
-		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}
 
 	c.Status(http.StatusNoContent)
 }
 
-// Returns all of the currently in-progress file downloads and their current download
-// progress. The progress is also pushed out via a websocket event allowing you to just
-// call this once to get current downloads, and then listen to targeted websocket events
-// with the current progress for everything.
-func getServerPullingFiles(c *gin.Context) {
-	s := ExtractServer(c)
-	c.JSON(http.StatusOK, gin.H{
-		"downloads": downloader.ByServer(s.ID()),
-	})
-}
-
-// Writes the contents of the remote URL to a file on a server.
-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"`
-		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 {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "An error occurred while parsing that URL: " + e.Err.Error(),
-			})
-			return
-		}
-		WithError(c, err)
-		return
-	}
-
-	if err := s.Filesystem().HasSpaceErr(true); err != nil {
-		WithError(c, err)
-		return
-	}
-	// Do not allow more than three simultaneous remote file downloads at one time.
-	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.",
-		})
-		return
-	}
-
-	dl := downloader.New(s, downloader.DownloadRequest{
-		Directory: data.RootPath,
-		URL:       u,
-		FileName:  data.FileName,
-		UseHeader: data.UseHeader,
-	})
-
-	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.
-func deleteServerPullRemoteFile(c *gin.Context) {
-	s := ExtractServer(c)
-	if dl := downloader.ByID(c.Param("download")); dl != nil && dl.BelongsTo(s) {
-		dl.Cancel()
-	}
-	c.Status(http.StatusNoContent)
-}
-
 // Create a directory on a server.
 func postServerCreateDirectory(c *gin.Context) {
-	s := ExtractServer(c)
+	s := GetServer(c.Param("server"))
 
 	var data struct {
 		Name string `json:"name"`
 		Path string `json:"path"`
 	}
-	// BindJSON sends 400 if the request fails, all we need to do is return
+	c.BindJSON(&data)
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
 
-	if err := s.Filesystem().CreateDirectory(data.Name, data.Path); err != nil {
+	if err := s.Filesystem.CreateDirectory(data.Name, data.Path); err != nil {
-		if err.Error() == "not a directory" {
+		TrackedServerError(err, s).AbortWithServerError(c)
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "Part of the path being created is not a directory (ENOTDIR).",
-			})
-			return
-		}
-
-		NewServerError(err, s).Abort(c)
 		return
 	}
 
 	c.Status(http.StatusNoContent)
 }
-
-func postServerCompressFiles(c *gin.Context) {
-	s := ExtractServer(c)
-
-	var data struct {
-		RootPath string   `json:"root"`
-		Files    []string `json:"files"`
-	}
-
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	if len(data.Files) == 0 {
-		c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
-			"error": "No files were passed through to be compressed.",
-		})
-		return
-	}
-
-	if !s.Filesystem().HasSpaceAvailable(true) {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "This server does not have enough available disk space to generate a compressed archive.",
-		})
-		return
-	}
-
-	f, err := s.Filesystem().CompressFiles(data.RootPath, data.Files)
-	if err != nil {
-		NewServerError(err, s).AbortFilesystemError(c)
-		return
-	}
-
-	c.JSON(http.StatusOK, &filesystem.Stat{
-		FileInfo: f,
-		Mimetype: "application/tar+gzip",
-	})
-}
-
-// postServerDecompressFiles receives the HTTP request and starts the process
-// of unpacking an archive that exists on the server into the provided RootPath
-// for the server.
-func postServerDecompressFiles(c *gin.Context) {
-	var data struct {
-		RootPath string `json:"root"`
-		File     string `json:"file"`
-	}
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	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 {
-		if filesystem.IsErrorCode(err, filesystem.ErrCodeUnknownArchive) {
-			lg.WithField("error", err).Warn("failed to decompress file: unknown archive format")
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "The archive provided is in a format Wings does not understand."})
-			return
-		}
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	lg.Info("starting file decompression")
-	if err := s.Filesystem().DecompressFile(data.RootPath, data.File); err != nil {
-		// If the file is busy for some reason just return a nicer error to the user since there is not
-		// much we specifically can do. They'll need to stop the running server process in order to overwrite
-		// a file like this.
-		if strings.Contains(err.Error(), "text file busy") {
-			lg.WithField("error", errors.WithStackIf(err)).Warn("failed to decompress file: text file busy")
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "One or more files this archive is attempting to overwrite are currently in use by another process. Please try again.",
-			})
-			return
-		}
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-	c.Status(http.StatusNoContent)
-}
-
-type chmodFile struct {
-	File string `json:"file"`
-	Mode string `json:"mode"`
-}
-
-var errInvalidFileMode = errors.New("invalid file mode")
-
-func postServerChmodFile(c *gin.Context) {
-	s := ExtractServer(c)
-
-	var data struct {
-		Root  string      `json:"root"`
-		Files []chmodFile `json:"files"`
-	}
-
-	if err := c.BindJSON(&data); err != nil {
-		log.Debug(err.Error())
-		return
-	}
-
-	if len(data.Files) == 0 {
-		c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
-			"error": "No files to chmod were provided.",
-		})
-		return
-	}
-
-	g, ctx := errgroup.WithContext(context.Background())
-
-	// Loop over the array of files passed in and perform the move or rename action against each.
-	for _, p := range data.Files {
-		g.Go(func() error {
-			select {
-			case <-ctx.Done():
-				return ctx.Err()
-			default:
-				mode, err := strconv.ParseUint(p.Mode, 8, 32)
-				if err != nil {
-					return errInvalidFileMode
-				}
-
-				if err := s.Filesystem().Chmod(path.Join(data.Root, p.File), os.FileMode(mode)); err != nil {
-					// Return nil if the error is an is not exists.
-					// NOTE: os.IsNotExist() does not work if the error is wrapped.
-					if errors.Is(err, os.ErrNotExist) {
-						return nil
-					}
-
-					return err
-				}
-
-				return nil
-			}
-		})
-	}
-
-	if err := g.Wait(); err != nil {
-		if errors.Is(err, errInvalidFileMode) {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "Invalid file mode.",
-			})
-			return
-		}
-
-		NewServerError(err, s).AbortFilesystemError(c)
-		return
-	}
-
-	c.Status(http.StatusNoContent)
-}
-
-func postServerUploadFiles(c *gin.Context) {
-	manager := middleware.ExtractManager(c)
-
-	token := tokens.UploadPayload{}
-	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		NewTrackedError(err).Abort(c)
-		return
-	}
-
-	s, ok := manager.Get(token.ServerUuid)
-	if !ok || !token.IsUniqueRequest() {
-		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-			"error": "The requested resource was not found on this server.",
-		})
-		return
-	}
-
-	form, err := c.MultipartForm()
-	if err != nil {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "Failed to get multipart form data from request.",
-		})
-		return
-	}
-
-	headers, ok := form.File["files"]
-	if !ok {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "No files were found on the request body.",
-		})
-		return
-	}
-
-	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
-	}
-
-	for _, header := range headers {
-		p, err := s.Filesystem().SafePath(filepath.Join(directory, header.Filename))
-		if err != nil {
-			NewServerError(err, s).Abort(c)
-			return
-		}
-
-		// We run this in a different method so I can use defer without any of
-		// the consequences caused by calling it in a loop.
-		if err := handleFileUpload(p, s, header); err != nil {
-			NewServerError(err, s).Abort(c)
-			return
-		} else {
-			s.SaveActivity(s.NewRequestActivity(token.UserUuid, c.ClientIP()), server.ActivityFileUploaded, models.ActivityMeta{
-				"file":      header.Filename,
-				"directory": filepath.Clean(directory),
-			})
-		}
-	}
-}
-
-func handleFileUpload(p string, s *server.Server, header *multipart.FileHeader) error {
-	file, err := header.Open()
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	if err := s.Filesystem().IsIgnored(p); err != nil {
-		return err
-	}
-	if err := s.Filesystem().Writefile(p, file); err != nil {
-		return err
-	}
-	return nil
-}

router/router_server_ws.go

@@ -2,74 +2,45 @@ package router
 
 import (
 	"context"
-	"time"
+	"encoding/json"
-
 	"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"
+	"go.uber.org/zap"
 )
 
-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 := GetServer(c.Param("server"))
-	s, _ := manager.Get(c.Param("server"))
+	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
-
-	// 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, c)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		TrackedServerError(err, s).AbortWithServerError(c)
 		return
 	}
 	defer handler.Connection.Close()
 
-	// Track this open connection on the server so that we can close them all programmatically
+	// Create a context that can be canceled when the user disconnects from this
-	// if the server is deleted.
+	// socket that will also cancel listeners running in separate threads.
-	s.Websockets().Push(handler.Uuid(), &cancel)
+	ctx, cancel := context.WithCancel(context.Background())
-	handler.Logger().Debug("opening connection to server websocket")
+	defer cancel()
 
-	defer func() {
+	go handler.ListenForServerEvents(ctx)
-		s.Websockets().Remove(handler.Uuid())
+	go handler.ListenForExpiration(ctx)
-		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))
-			break
-		}
-	}()
 
 	for {
 		j := websocket.Message{}
 
 		_, p, err := handler.Connection.ReadMessage()
 		if err != nil {
-			if ws.IsUnexpectedCloseError(err, expectedCloseCodes...) {
+			if !ws.IsCloseError(
-				handler.Logger().WithField("error", err).Warn("error handling websocket message for server")
+				err,
+				ws.CloseNormalClosure,
+				ws.CloseGoingAway,
+				ws.CloseNoStatusReceived,
+				ws.CloseServiceRestart,
+				ws.CloseAbnormalClosure,
+			) {
+				zap.S().Warnw("error handling websocket message", zap.Error(err))
 			}
 			break
 		}
@@ -81,10 +52,9 @@ func getServerWebsocket(c *gin.Context) {
 			continue
 		}
 
-		go func(msg websocket.Message) {
+		if err := handler.HandleInbound(j); err != nil {
-			if err := handler.HandleInbound(ctx, msg); err != nil {
+			handler.SendErrorJson(err)
-				handler.SendErrorJson(msg, err)
+		}
-			}
-		}(j)
 	}
 }
+

router/router_system.go

@@ -1,26 +1,21 @@
 package router
 
 import (
-	"context"
+	"bytes"
-	"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"
+	"go.uber.org/zap"
+	"net/http"
 )
 
 // Returns information about the system that wings is running on.
 func getSystemInformation(c *gin.Context) {
 	i, err := system.GetSystemInformation()
 	if err != nil {
-		NewTrackedError(err).Abort(c)
+		TrackedError(err).AbortWithServerError(c)
 
 		return
 	}
@@ -31,25 +26,16 @@ 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) {
-	servers := middleware.ExtractManager(c).All()
+	c.JSON(http.StatusOK, server.GetServers().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)
 
-	details := installer.ServerDetails{}
+	install, err := installer.New(buf.Bytes())
-	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{
@@ -58,70 +44,50 @@ func postCreateServer(c *gin.Context) {
 			return
 		}
 
-		middleware.CaptureAndAbort(c, err)
+		TrackedError(err).AbortWithServerError(c)
 		return
 	}
 
 	// Plop that server instance onto the request so that it can be referenced in
 	// requests from here-on out.
-	manager.Add(install.Server())
+	server.GetServers().Add(install.Server())
 
 	// Begin the installation process in the background to not block the request
 	// cycle. If there are any errors they will be logged and communicated back
 	// to the Panel where a reinstall may take place.
 	go func(i *installer.Installer) {
-		if err := i.Server().CreateEnvironment(); err != nil {
+		i.Execute()
-			i.Server().Log().WithField("error", err).Error("failed to create server environment during install process")
-			return
-		}
 
-		if err := i.Server().Install(false); err != nil {
+		if err := i.Server().Install(); err != nil {
-			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
+			zap.S().Errorw(
-			return
+				"failed to run install process for server",
-		}
+				zap.String("server", i.Uuid()),
-
+				zap.Error(err),
-		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)
 
 	c.Status(http.StatusAccepted)
 }
 
-// Updates the running configuration for this Wings instance.
+// Updates the running configuration for this daemon instance.
 func postUpdateConfiguration(c *gin.Context) {
-	cfg := config.Get()
+	// A backup of the configuration for error purposes.
-	if err := c.BindJSON(&cfg); err != nil {
+	ccopy := *config.Get()
+	// A copy of the configuration we're using to bind the data recevied into.
+	cfg := *config.Get()
+
+	c.BindJSON(&cfg)
+
+	config.Set(&cfg)
+	if err := config.Get().WriteToDisk(); err != nil {
+		// If there was an error writing to the disk, revert back to the configuration we had
+		// before this code was run.
+		config.Set(&ccopy)
+
+		TrackedError(err).AbortWithServerError(c)
 		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 = 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 {
-		WithError(c, err)
-		return
-	}
-	// Since we wrote it to the disk successfully now update the global configuration
-	// state to use this new configuration struct.
-	config.Set(cfg)
 	c.Status(http.StatusNoContent)
 }

router/router_transfer.go

@@ -2,50 +2,29 @@ package router
 
 import (
 	"bufio"
-	"context"
+	"bytes"
 	"crypto/sha256"
 	"encoding/hex"
-	"fmt"
+	"errors"
+	"github.com/buger/jsonparser"
+	"github.com/gin-gonic/gin"
+	"github.com/mholt/archiver/v3"
+	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/installer"
+	"github.com/pterodactyl/wings/router/tokens"
+	"github.com/pterodactyl/wings/server"
+	"go.uber.org/zap"
 	"io"
+	"io/ioutil"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"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"
-	"github.com/pterodactyl/wings/router/middleware"
-	"github.com/pterodactyl/wings/router/tokens"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/filesystem"
 )
 
-const progressWidth = 25
-
-// Data passed over to initiate a server transfer.
-type serverTransferRequest struct {
-	ServerID string                  `binding:"required" json:"server_id"`
-	URL      string                  `binding:"required" json:"url"`
-	Token    string                  `binding:"required" json:"token"`
-	Server   installer.ServerDetails `json:"server"`
-}
-
-func getArchivePath(sID string) string {
-	return filepath.Join(config.Get().System.ArchiveDirectory, sID+".tar.gz")
-}
-
-// Returns the archive for a server so that it can be transferred to a new node.
 func getServerArchive(c *gin.Context) {
 	auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
 
@@ -59,81 +38,111 @@ func getServerArchive(c *gin.Context) {
 
 	token := tokens.TransferPayload{}
 	if err := tokens.ParseToken([]byte(auth[1]), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		TrackedError(err).AbortWithServerError(c)
 		return
 	}
 
-	s := ExtractServer(c)
+	if token.Subject != c.Param("server") {
-	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.",
+			"error": "( .. •˘___˘• .. )",
 		})
 		return
 	}
 
-	archivePath := getArchivePath(s.ID())
+	s := GetServer(c.Param("server"))
 
-	// Stat the archive file.
+	st, err := s.Archiver.Stat()
-	st, err := os.Lstat(archivePath)
 	if err != nil {
-		if !errors.Is(err, os.ErrNotExist) {
+		if !os.IsNotExist(err) {
-			_ = WithError(c, err)
+			TrackedServerError(err, s).SetMessage("failed to stat archive").AbortWithServerError(c)
 			return
 		}
+
 		c.AbortWithStatus(http.StatusNotFound)
 		return
 	}
 
-	// Compute sha256 checksum.
+	checksum, err := s.Archiver.Checksum()
-	h := sha256.New()
-	f, err := os.Open(archivePath)
 	if err != nil {
+		TrackedServerError(err, s).SetMessage("failed to calculate checksum").AbortWithServerError(c)
 		return
 	}
-	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
-		_ = f.Close()
-		_ = WithError(c, err)
-		return
-	}
-	if err := f.Close(); err != nil {
-		_ = WithError(c, err)
-		return
-	}
-	checksum := hex.EncodeToString(h.Sum(nil))
 
-	// Stream the file to the client.
+	file, err := os.Open(s.Archiver.ArchivePath())
-	f, err = os.Open(archivePath)
 	if err != nil {
-		_ = WithError(c, err)
+		tserr := TrackedServerError(err, s)
+		if !os.IsNotExist(err) {
+			tserr.SetMessage("failed to open archive for reading")
+		} else {
+			tserr.SetMessage("failed to open archive")
+		}
+
+		tserr.AbortWithServerError(c)
 		return
 	}
-	defer f.Close()
+	defer file.Close()
 
 	c.Header("X-Checksum", checksum)
-	c.Header("X-Mime-Type", "application/tar+gzip")
+	c.Header("X-Mime-Type", st.Mimetype)
-	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
+	c.Header("Content-Length", strconv.Itoa(int(st.Info.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(s.ID()+".tar.gz"))
+	c.Header("Content-Disposition", "attachment; filename="+s.Archiver.ArchiveName())
 	c.Header("Content-Type", "application/octet-stream")
 
-	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
+	bufio.NewReader(file).WriteTo(c.Writer)
 }
 
 func postServerArchive(c *gin.Context) {
-	s := middleware.ExtractServer(c)
+	s := GetServer(c.Param("server"))
-	manager := middleware.ExtractManager(c)
 
-	go func(s *server.Server) {
+	go func(server *server.Server) {
-		l := log.WithField("server", s.ID())
+		start := time.Now()
 
-		// This function automatically adds the Source Node prefix and Timestamp to the log
+		if err := server.Archiver.Archive(); err != nil {
-		// output before sending it over the websocket.
+			zap.S().Errorw("failed to get archive for server", zap.String("server", s.Uuid), zap.Error(err))
-		sendTransferLog := func(data string) {
+			return
-			output := colorstring.Color(fmt.Sprintf("[yellow][bold]%s [Pterodactyl Transfer System] [Source Node]:[default] %s", time.Now().Format(time.RFC1123), data))
-			s.Events().Publish(server.TransferLogsEvent, output)
 		}
 
-		s.Events().Publish(server.TransferStatusEvent, "starting")
+		zap.S().Debugw(
-		sendTransferLog("Attempting to archive server...")
+			"successfully created archive for server",
+			zap.String("server", server.Uuid),
+			zap.Duration("time", time.Now().Sub(start).Round(time.Microsecond)),
+		)
+
+		r := api.NewRequester()
+		rerr, err := r.SendArchiveStatus(server.Uuid, true)
+		if rerr != nil || err != nil {
+			if err != nil {
+				zap.S().Errorw("failed to notify panel with archive status", zap.String("server", server.Uuid), zap.Error(err))
+				return
+			}
+
+			zap.S().Errorw(
+				"panel returned an error when sending the archive status",
+				zap.String("server", server.Uuid),
+				zap.Error(errors.New(rerr.String())),
+			)
+			return
+		}
+
+		zap.S().Debugw("successfully notified panel about archive status", zap.String("server", server.Uuid))
+	}(s)
+
+	c.Status(http.StatusAccepted)
+}
+
+func postTransfer(c *gin.Context) {
+	zap.S().Debug("incoming transfer from panel")
+
+	buf := bytes.Buffer{}
+	buf.ReadFrom(c.Request.Body)
+
+	go func(data []byte) {
+		serverID, _ := jsonparser.GetString(data, "server_id")
+		url, _ := jsonparser.GetString(data, "url")
+		token, _ := jsonparser.GetString(data, "token")
+
+		// Create an http client with no timeout.
+		client := &http.Client{Timeout: 0}
 
 		hasError := true
 		defer func() {
@@ -141,366 +150,140 @@ func postServerArchive(c *gin.Context) {
 				return
 			}
 
-			// Mark the server as not being transferred so it can actually be used.
+			zap.S().Errorw("server transfer has failed", zap.String("server", serverID))
-			s.SetTransferring(false)
+			rerr, err := api.NewRequester().SendTransferFailure(serverID)
-			s.Events().Publish(server.TransferStatusEvent, "failure")
+			if rerr != nil || err != nil {
-
+				if err != nil {
-			sendTransferLog("Attempting to notify panel of archive failure..")
+					zap.S().Errorw("failed to notify panel with transfer failure", zap.String("server", serverID), zap.Error(err))
-			if err := manager.Client().SetArchiveStatus(s.Context(), s.ID(), false); err != nil {
-				if !remote.IsRequestError(err) {
-					sendTransferLog("Failed to notify panel of archive failure: " + err.Error())
-					l.WithField("error", err).Error("failed to notify panel of failed archive status")
 					return
 				}
 
-				sendTransferLog("Panel returned an error while notifying it of a failed archive: " + err.Error())
+				zap.S().Errorw("panel returned an error when notifying of a transfer failure", zap.String("server", serverID), zap.Error(errors.New(rerr.String())))
-				l.WithField("error", err.Error()).Error("panel returned an error when notifying it of a failed archive status")
 				return
 			}
 
-			sendTransferLog("Successfully notified panel of failed archive status")
+			zap.S().Debugw("successfully notified panel about transfer failure", zap.String("server", serverID))
-			l.Info("successfully notified panel of failed archive status")
 		}()
 
-		// Mark the server as transferring to prevent problems.
+		// Make a new GET request to the URL the panel gave us.
-		s.SetTransferring(true)
+		req, err := http.NewRequest("GET", url, nil)
-
-		// 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(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
-		}
-
-		// Get the disk usage of the server (used to calculate the progress of the archive process)
-		rawSize, err := s.Filesystem().DiskUsage(true)
 		if err != nil {
-			sendTransferLog("Failed to get disk usage for server, aborting transfer..")
+			zap.S().Errorw("failed to create http request", zap.Error(err))
-			l.WithField("error", err).Error("failed to get disk usage for server")
 			return
 		}
 
-		// Create an archive of the entire server's data directory.
+		// Add the authorization header.
-		a := &filesystem.Archive{
+		req.Header.Set("Authorization", token)
-			BasePath: s.Filesystem().Path(),
-			Progress: filesystem.NewProgress(rawSize),
-		}
 
-		// Send the archive progress to the websocket every 3 seconds.
+		// Execute the http request.
-		ctx, cancel := context.WithCancel(s.Context())
+		res, err := client.Do(req)
-		defer cancel()
-		go func(ctx context.Context, p *filesystem.Progress, t *time.Ticker) {
-			defer t.Stop()
-			for {
-				select {
-				case <-ctx.Done():
-					return
-				case <-t.C:
-					sendTransferLog("Archiving " + p.Progress(progressWidth))
-				}
-			}
-		}(ctx, a.Progress, time.NewTicker(5*time.Second))
-
-		// Attempt to get an archive of the server.
-		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
-		}
-
-		// Cancel the progress ticker.
-		cancel()
-
-		// Show 100% completion.
-		sendTransferLog("Archiving " + a.Progress.Progress(progressWidth))
-
-		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 !remote.IsRequestError(err) {
-				sendTransferLog("Failed to notify panel of archive success: " + err.Error())
-				l.WithField("error", err).Error("failed to notify panel of successful archive status")
-				return
-			}
-
-			sendTransferLog("Panel returned an error while notifying it of a successful archive: " + err.Error())
-			l.WithField("error", err.Error()).Error("panel returned an error when notifying it of a successful archive status")
-			return
-		}
-
-		hasError = false
-
-		// This log may not be displayed by the client due to the status event being sent before or at the same time.
-		sendTransferLog("Successfully notified panel of successful archive status")
-
-		l.Info("successfully notified panel of successful transfer archive status")
-		s.Events().Publish(server.TransferStatusEvent, "archived")
-	}(s)
-
-	c.Status(http.StatusAccepted)
-}
-
-// Log helper function to attach all errors and info output to a consistently formatted
-// log string for easier querying.
-func (str serverTransferRequest) log() *log.Entry {
-	return log.WithField("subsystem", "transfers").WithField("server_id", str.ServerID)
-}
-
-// Downloads an archive from the machine that the server currently lives on.
-func (str serverTransferRequest) downloadArchive() (*http.Response, error) {
-	client := http.Client{Timeout: 0}
-	req, err := http.NewRequest(http.MethodGet, str.URL, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", str.Token)
-	res, err := client.Do(req) // lgtm [go/request-forgery]
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-// Returns the path to the local archive on the system.
-func (str serverTransferRequest) path() string {
-	return getArchivePath(str.ServerID)
-}
-
-// Creates the archive location on this machine by first checking that the required file
-// does not already exist. If it does exist, the file is deleted and then re-created as
-// an empty file.
-func (str serverTransferRequest) createArchiveFile() (*os.File, error) {
-	p := str.path()
-	if _, err := os.Stat(p); err != nil {
-		if !os.IsNotExist(err) {
-			return nil, err
-		}
-	} else if err := os.Remove(p); err != nil {
-		return nil, err
-	}
-	return os.Create(p)
-}
-
-// Deletes the archive from the local filesystem. This is executed as a deferred function.
-func (str serverTransferRequest) removeArchivePath() {
-	p := str.path()
-	str.log().Debug("deleting temporary transfer archive")
-	if err := os.Remove(p); err != nil && !os.IsNotExist(err) {
-		str.log().WithField("path", p).WithField("error", err).Error("failed to delete temporary transfer archive file")
-		return
-	}
-	str.log().Debug("deleted temporary transfer archive successfully")
-}
-
-// Verifies that the SHA-256 checksum of the file on the local filesystem matches the
-// expected value from the transfer request. The string value returned is the computed
-// checksum on the system.
-func (str serverTransferRequest) verifyChecksum(matches string) (bool, string, error) {
-	f, err := os.Open(str.path())
-	if err != nil {
-		return false, "", err
-	}
-	defer f.Close()
-	h := sha256.New()
-	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
-		return false, "", err
-	}
-	checksum := hex.EncodeToString(h.Sum(nil))
-	return checksum == matches, checksum, nil
-}
-
-// Sends a notification to the Panel letting it know what the status of this transfer is.
-func (str serverTransferRequest) sendTransferStatus(client remote.Client, successful bool) error {
-	lg := str.log().WithField("transfer_successful", successful)
-	lg.Info("notifying Panel of server transfer state")
-	if err := client.SetTransferStatus(context.Background(), str.ServerID, successful); err != nil {
-		lg.WithField("error", err).Error("error notifying panel of transfer state")
-		return err
-	}
-	lg.Debug("notified panel of transfer state")
-	return nil
-}
-
-// Initiates a transfer between two nodes for a server by downloading an archive from the
-// remote node and then applying the server details to this machine.
-func postTransfer(c *gin.Context) {
-	var data serverTransferRequest
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	manager := middleware.ExtractManager(c)
-	u, err := uuid.Parse(data.ServerID)
-	if err != nil {
-		_ = WithError(c, err)
-		return
-	}
-	// Force the server ID to be a valid UUID string at this point. If it is not an error
-	// is returned to the caller. This limits injection vulnerabilities that would cause
-	// the str.path() function to return a location not within the server archive directory.
-	data.ServerID = u.String()
-
-	data.log().Info("handling incoming server transfer request")
-	go func(data *serverTransferRequest) {
-		ctx := context.Background()
-		hasError := true
-
-		// Create a new server installer. This will only configure the environment and not
-		// run the installer scripts.
-		i, err := installer.New(ctx, manager, data.Server)
 		if err != nil {
-			_ = data.sendTransferStatus(manager.Client(), false)
+			zap.S().Errorw("failed to send http request", zap.Error(err))
-			data.log().WithField("error", err).Error("failed to validate received server data")
-			return
-		}
-
-		// This function automatically adds the Target Node prefix and Timestamp to the log output before sending it
-		// over the websocket.
-		sendTransferLog := func(data string) {
-			output := colorstring.Color(fmt.Sprintf("[yellow][bold]%s [Pterodactyl Transfer System] [Target Node]:[default] %s", time.Now().Format(time.RFC1123), data))
-			i.Server().Events().Publish(server.TransferLogsEvent, output)
-		}
-
-		// Mark the server as transferring to prevent problems later on during the process and
-		// then push the server into the global server collection for this instance.
-		i.Server().SetTransferring(true)
-		manager.Add(i.Server())
-		defer func(s *server.Server) {
-			// In the event that this transfer call fails, remove the server from the global
-			// server tracking so that we don't have a dangling instance.
-			if err := data.sendTransferStatus(manager.Client(), !hasError); hasError || err != nil {
-				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()
-				})
-
-				// If the transfer status was successful but the request failed, act like the transfer failed.
-				if !hasError && err != nil {
-					// Delete all extracted files.
-					if err := os.RemoveAll(s.Filesystem().Path()); err != nil && !os.IsNotExist(err) {
-						data.log().WithField("error", err).Warn("failed to delete local server files directory")
-					}
-				}
-			} else {
-				s.SetTransferring(false)
-				s.Events().Publish(server.TransferStatusEvent, "success")
-				sendTransferLog("Transfer completed.")
-			}
-		}(i.Server())
-
-		data.log().Info("downloading server archive from current server node")
-		sendTransferLog("Received incoming transfer from Panel, attempting to download archive from source node...")
-		res, err := data.downloadArchive()
-		if err != nil {
-			sendTransferLog("Failed to retrieve server archive from remote node: " + err.Error())
-			data.log().WithField("error", err).Error("failed to download archive for server transfer")
 			return
 		}
 		defer res.Body.Close()
-		if res.StatusCode != http.StatusOK {
+
-			data.log().WithField("error", err).WithField("status", res.StatusCode).Error("unexpected error response from transfer endpoint")
+		// Handle non-200 status codes.
+		if res.StatusCode != 200 {
+			body, err := ioutil.ReadAll(res.Body)
+			if err != nil {
+				zap.S().Errorw("failed to read response body", zap.Int("status", res.StatusCode), zap.Error(err))
+				return
+			}
+
+			zap.S().Errorw("failed to request server archive", zap.Int("status", res.StatusCode), zap.String("body", string(body)))
 			return
 		}
 
-		size := res.ContentLength
+		// Get the path to the archive.
-		if size == 0 {
+		archivePath := filepath.Join(config.Get().System.ArchiveDirectory, serverID + ".tar.gz")
-			data.log().WithField("error", err).Error("received an archive response with Content-Length of 0")
+
-			return
+		// Check if the archive already exists and delete it if it does.
-		}
+		_, err = os.Stat(archivePath)
-		sendTransferLog("Got server archive response from remote node. (Content-Length: " + strconv.Itoa(int(size)) + ")")
-		sendTransferLog("Creating local archive file...")
-		file, err := data.createArchiveFile()
 		if err != nil {
-			data.log().WithField("error", err).Error("failed to create archive file on local filesystem")
+			if !os.IsNotExist(err) {
-			return
+				zap.S().Errorw("failed to stat file", zap.Error(err))
-		}
+				return
-
-		sendTransferLog("Writing archive to disk...")
-		data.log().Info("writing transfer archive to disk...")
-
-		progress := filesystem.NewProgress(size)
-
-		// Send the archive progress to the websocket every 3 seconds.
-		ctx, cancel := context.WithCancel(ctx)
-		defer cancel()
-		go func(ctx context.Context, p *filesystem.Progress, t *time.Ticker) {
-			defer t.Stop()
-			for {
-				select {
-				case <-ctx.Done():
-					return
-				case <-t.C:
-					sendTransferLog("Downloading " + p.Progress(progressWidth))
-				}
 			}
-		}(ctx, progress, time.NewTicker(5*time.Second))
-
-		var reader io.Reader
-		downloadLimit := float64(config.Get().System.Transfers.DownloadLimit) * 1024 * 1024
-		if downloadLimit > 0 {
-			// Wrap the body with a reader that is limited to the defined download limit speed.
-			reader = ratelimit.Reader(res.Body, ratelimit.NewBucketWithRate(downloadLimit, int64(downloadLimit)))
 		} else {
-			reader = res.Body
+			if err := os.Remove(archivePath); err != nil {
-		}
+				zap.S().Errorw("failed to delete old file", zap.Error(err))
-
+				return
-		buf := make([]byte, 1024*4)
-		if _, err := io.CopyBuffer(file, io.TeeReader(reader, progress), buf); err != nil {
-			_ = file.Close()
-
-			sendTransferLog("Failed while writing archive file to disk: " + err.Error())
-			data.log().WithField("error", err).Error("failed to copy archive file to disk")
-			return
-		}
-		cancel()
-
-		// Show 100% completion.
-		sendTransferLog("Downloading " + progress.Progress(progressWidth))
-
-		if err := file.Close(); err != nil {
-			data.log().WithField("error", err).Error("unable to close archive file on local filesystem")
-			return
-		}
-		data.log().Info("finished writing transfer archive to disk")
-		sendTransferLog("Successfully wrote archive to disk.")
-
-		// Whenever the transfer fails or succeeds, delete the temporary transfer archive that
-		// was created on the disk.
-		defer data.removeArchivePath()
-
-		sendTransferLog("Verifying checksum of downloaded archive...")
-		data.log().Info("computing checksum of downloaded archive file")
-		expected := res.Header.Get("X-Checksum")
-		if matches, computed, err := data.verifyChecksum(expected); err != nil {
-			data.log().WithField("error", err).Error("encountered an error while calculating local filesystem archive checksum")
-			return
-		} else if !matches {
-			sendTransferLog("@@@@@ CHECKSUM VERIFICATION FAILED @@@@@")
-			sendTransferLog("  -   Source Checksum: " + expected)
-			sendTransferLog("  - Computed Checksum: " + computed)
-			data.log().WithField("expected_sum", expected).WithField("computed_checksum", computed).Error("checksum mismatch when verifying integrity of local archive")
-			return
-		}
-
-		// Create the server's environment.
-		sendTransferLog("Creating server environment, this could take a while..")
-		data.log().Info("creating server environment")
-		if err := i.Server().CreateEnvironment(); err != nil {
-			data.log().WithField("error", err).Error("failed to create server environment")
-			return
-		}
-
-		sendTransferLog("Server environment has been created, extracting transfer archive..")
-		data.log().Info("server environment configured, extracting transfer archive")
-		if err := archiver.NewTarGz().Unarchive(data.path(), i.Server().Filesystem().Path()); err != nil {
-			// Un-archiving failed, delete the server's data directory.
-			if err := os.RemoveAll(i.Server().Filesystem().Path()); err != nil && !os.IsNotExist(err) {
-				data.log().WithField("error", err).Warn("failed to delete local server files directory")
 			}
-			data.log().WithField("error", err).Error("failed to extract server archive")
+		}
+
+		// Create the file.
+		file, err := os.Create(archivePath)
+		if err != nil {
+			zap.S().Errorw("failed to open file on disk", zap.Error(err))
+			return
+		}
+
+		// Copy the file.
+		_, err = io.Copy(file, res.Body)
+		if err != nil {
+			zap.S().Errorw("failed to copy file to disk", zap.Error(err))
+			return
+		}
+
+		// Close the file so it can be opened to verify the checksum.
+		if err := file.Close(); err != nil {
+			zap.S().Errorw("failed to close archive file", zap.Error(err))
+			return
+		}
+		zap.S().Debug("server archive has been downloaded, computing checksum..", zap.String("server", serverID))
+
+		// Open the archive file for computing a checksum.
+		file, err = os.Open(archivePath)
+		if err != nil {
+			zap.S().Errorw("failed to open file on disk", zap.Error(err))
+			return
+		}
+
+		// Compute the sha256 checksum of the file.
+		hash := sha256.New()
+		if _, err := io.Copy(hash, file); err != nil {
+			zap.S().Errorw("failed to copy file for checksum verification", zap.Error(err))
+			return
+		}
+
+		// Verify the two checksums.
+		if hex.EncodeToString(hash.Sum(nil)) != res.Header.Get("X-Checksum") {
+			zap.S().Errorw("checksum failed verification")
+			return
+		}
+
+		// Close the file.
+		if err := file.Close(); err != nil {
+			zap.S().Errorw("failed to close archive file", zap.Error(err))
+			return
+		}
+
+		zap.S().Infow("server archive transfer was successful", zap.String("server", serverID))
+
+		// Get the server data from the request.
+		serverData, t, _, _ := jsonparser.Get(data, "server")
+		if t != jsonparser.Object {
+			zap.S().Errorw("invalid server data passed in request")
+			return
+		}
+
+		// Create a new server installer (note this does not execute the install script)
+		i, err := installer.New(serverData)
+		if err != nil {
+			zap.S().Warnw("failed to validate the received server data", zap.Error(err))
+			return
+		}
+
+		// Add the server to the collection.
+		server.GetServers().Add(i.Server())
+
+		// Create the server's environment (note this does not execute the install script)
+		i.Execute()
+
+		// Un-archive the archive. That sounds weird..
+		if err := archiver.NewTarGz().Unarchive(archivePath, i.Server().Filesystem.Path()); err != nil {
+			zap.S().Errorw("failed to extract archive", zap.String("server", serverID), zap.Error(err))
 			return
 		}
 
@@ -511,9 +294,20 @@ func postTransfer(c *gin.Context) {
 		// hiccup or the fix of whatever error causing the success request to fail.
 		hasError = false
 
-		data.log().Info("archive extracted successfully, notifying Panel of status")
+		// Notify the panel that the transfer succeeded.
-		sendTransferLog("Archive extracted successfully.")
+		rerr, err := api.NewRequester().SendTransferSuccess(serverID)
-	}(&data)
+		if rerr != nil || err != nil {
+			if err != nil {
+				zap.S().Errorw("failed to notify panel with transfer success", zap.String("server", serverID), zap.Error(err))
+				return
+			}
+
+			zap.S().Errorw("panel returned an error when notifying of a transfer success", zap.String("server", serverID), zap.Error(errors.New(rerr.String())))
+			return
+		}
+
+		zap.S().Debugw("successfully notified panel about transfer success", zap.String("server", serverID))
+	}(buf.Bytes())
 
 	c.Status(http.StatusAccepted)
 }

router/tokens/backup.go

@@ -6,7 +6,6 @@ import (
 
 type BackupPayload struct {
 	jwt.Payload
-
 	ServerUuid string `json:"server_uuid"`
 	BackupUuid string `json:"backup_uuid"`
 	UniqueId   string `json:"unique_id"`

router/tokens/parser.go

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

router/tokens/token_store.go

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

router/tokens/upload.go

@@ -1,26 +0,0 @@
-package tokens
-
-import (
-	"github.com/gbrlsnchs/jwt/v3"
-)
-
-type UploadPayload struct {
-	jwt.Payload
-
-	ServerUuid string `json:"server_uuid"`
-	UserUuid   string `json:"user_uuid"`
-	UniqueId   string `json:"unique_id"`
-}
-
-// Returns the JWT payload.
-func (p *UploadPayload) GetPayload() *jwt.Payload {
-	return &p.Payload
-}
-
-// Determines if this JWT is valid for the given request cycle. If the
-// unique ID passed in the token has already been seen before this will
-// return false. This allows us to use this JWT as a one-time token that
-// validates all of the request.
-func (p *UploadPayload) IsUniqueRequest() bool {
-	return getTokenStore().IsValidToken(p.UniqueId)
-}

router/tokens/websocket.go

@@ -1,103 +1,30 @@
 package tokens
 
 import (
-	"strings"
+	"encoding/json"
-	"sync"
-	"time"
-
-	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
+	"strings"
 )
 
-// The time at which Wings was booted. No JWT's created before this time are allowed to
-// connect to the socket since they may have been marked as denied already and therefore
-// could be invalid at this point.
-//
-// By doing this we make it so that a user who gets disconnected from Wings due to a Wings
-// reboot just needs to request a new token as if their old token had expired naturally.
-var wingsBootTime = time.Now()
-
-// A map that contains any JTI's that have been denied by the Panel and the time at which
-// they were marked as denied. Therefore any JWT with the same JTI and an IssuedTime that
-// is the same as or before this time should be considered invalid.
-//
-// This is used to allow the Panel to revoke tokens en-masse for a given user & server
-// combination since the JTI for tokens is just MD5(user.id + server.uuid). When a server
-// is booted this listing is fetched from the panel and the Websocket is dynamically updated.
-var denylist sync.Map
-
-// Adds a JTI to the denylist by marking any JWTs generated before the current time as
-// being invalid if they use the same JTI.
-func DenyJTI(jti string) {
-	log.WithField("jti", jti).Debugf("adding \"%s\" to JTI denylist", jti)
-
-	denylist.Store(jti, time.Now())
-}
-
-// WebsocketPayload defines the JWT payload for a websocket connection. This JWT is passed along to
-// the websocket after it has been connected to by sending an "auth" event.
 type WebsocketPayload struct {
 	jwt.Payload
-	sync.RWMutex
+	UserID      json.Number `json:"user_id"`
-
+	ServerUUID  string      `json:"server_uuid"`
-	UserUUID    string   `json:"user_uuid"`
+	Permissions []string    `json:"permissions"`
-	ServerUUID  string   `json:"server_uuid"`
-	Permissions []string `json:"permissions"`
 }
 
 // Returns the JWT payload.
 func (p *WebsocketPayload) GetPayload() *jwt.Payload {
-	p.RLock()
-	defer p.RUnlock()
-
 	return &p.Payload
 }
 
-// Returns the UUID of the server associated with this JWT.
+// Checks if the given token payload has a permission string.
-func (p *WebsocketPayload) GetServerUuid() string {
+func (p *WebsocketPayload) HasPermission(permission string) bool {
-	p.RLock()
+	for _, k := range p.Permissions {
-	defer p.RUnlock()
+		if k == permission || (!strings.HasPrefix(permission, "admin") && k == "*") {
-
-	return p.ServerUUID
-}
-
-// Check if the JWT has been marked as denied by the instance due to either being issued
-// before Wings was booted, or because we have denied all tokens with the same JTI
-// occurring before a set time.
-func (p *WebsocketPayload) Denylisted() bool {
-	// If there is no IssuedAt present for the token, we cannot validate the token so
-	// just immediately mark it as not valid.
-	if p.IssuedAt == nil {
-		return true
-	}
-
-	// If the time that the token was issued is before the time at which Wings was booted
-	// then the token is invalid for our purposes, even if the token "has permission".
-	if p.IssuedAt.Time.Before(wingsBootTime) {
-		return true
-	}
-
-	// Finally, if the token was issued before a time that is currently denied for this
-	// token instance, ignore the permissions response.
-	if t, ok := denylist.Load(p.JWTID); ok {
-		if p.IssuedAt.Time.Before(t.(time.Time)) {
 			return true
 		}
 	}
 
 	return false
 }
-
-// Checks if the given token payload has a permission string.
-func (p *WebsocketPayload) HasPermission(permission string) bool {
-	p.RLock()
-	defer p.RUnlock()
-
-	for _, k := range p.Permissions {
-		if k == permission || (!strings.HasPrefix(permission, "admin") && k == "*") {
-			return !p.Denylisted()
-		}
-	}
-
-	return false
-}

router/websocket/listeners.go

@@ -2,50 +2,20 @@ package websocket
 
 import (
 	"context"
-	"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"
+	"time"
 )
 
-// RegisterListenerEvents will setup the server event listeners and expiration
+// Checks the time to expiration on the JWT every 30 seconds until the token has
-// timers. This is only triggered on first authentication with the websocket,
+// expired. If we are within 3 minutes of the token expiring, send a notice over
-// reconnections will not call it.
+// the socket that it is expiring soon. If it has expired, send that notice as well.
-//
+func (h *Handler) ListenForExpiration(ctx context.Context) {
-// 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 {
@@ -56,114 +26,46 @@ 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 {
+				} else if jwt.ExpirationTime.Unix()-time.Now().Unix() <= 180 {
-					_ = h.SendJson(Message{Event: TokenExpiringEvent})
+					h.SendJson(&Message{Event: TokenExpiringEvent})
 				}
 			}
 		}
 	}
 }
 
-var e = []string{
+// Listens for different events happening on a server and sends them along
-	server.StatsEvent,
+// to the connected websocket.
-	server.StatusEvent,
+func (h *Handler) ListenForServerEvents(ctx context.Context) {
-	server.ConsoleOutputEvent,
+	events := []string{
-	server.InstallOutputEvent,
+		server.StatsEvent,
-	server.InstallStartedEvent,
+		server.StatusEvent,
-	server.InstallCompletedEvent,
+		server.ConsoleOutputEvent,
-	server.DaemonMessageEvent,
+		server.InstallOutputEvent,
-	server.BackupCompletedEvent,
+		server.DaemonMessageEvent,
-	server.BackupRestoreCompletedEvent,
+		server.BackupCompletedEvent,
-	server.TransferLogsEvent,
-	server.TransferStatusEvent,
-}
-
-// 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()
 	}
 
-	for {
+	eventChannel := make(chan server.Event)
-		select {
+	for _, event := range events {
-		case <-ctx.Done():
+		h.server.Events().Subscribe(event, eventChannel)
-			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)}
-				}
-			}
 
-			if sendErr == nil {
+	select {
-				sendErr = h.SendJson(message)
+	case <-ctx.Done():
-				if sendErr == nil {
+		for _, event := range events {
-					continue
+			h.server.Events().Unsubscribe(event, eventChannel)
-				}
+		}
-			}
+
-			onError(message.Event, sendErr)
+		close(eventChannel)
+	default:
+		// Listen for different events emitted by the server and respond to them appropriately.
+		for d := range eventChannel {
+			h.SendJson(&Message{
+				Event: d.Topic,
+				Args:  []string{d.Data},
+			})
 		}
-		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/message.go

@@ -8,13 +8,16 @@ const (
 	SetStateEvent              = "set state"
 	SendServerLogsEvent        = "send logs"
 	SendCommandEvent           = "send command"
-	SendStatsEvent             = "send stats"
 	ErrorEvent                 = "daemon error"
-	JwtErrorEvent              = "jwt error"
 )
 
 type Message struct {
-	// The event to perform.
+	// The event to perform. Should be one of the following that are supported:
+	//
+	// - status : Returns the server's power state.
+	// - logs : Returns the server log data at the time of the request.
+	// - power : Performs a power action aganist the server based the data.
+	// - command : Performs a command on a server using the data field.
 	Event string `json:"event"`
 
 	// The data to pass along, only used by power/command currently. Other requests

router/websocket/websocket.go

@@ -1,28 +1,20 @@
 package websocket
 
 import (
-	"context"
 	"fmt"
-	"github.com/pterodactyl/wings/internal/models"
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/router/tokens"
+	"github.com/pterodactyl/wings/server"
+	"go.uber.org/zap"
 	"net/http"
+	"os"
 	"strings"
 	"sync"
 	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/gin-gonic/gin"
-	"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"
 )
 
 const (
@@ -33,68 +25,38 @@ const (
 	PermissionSendPowerRestart = "control.restart"
 	PermissionReceiveErrors    = "admin.websocket.errors"
 	PermissionReceiveInstall   = "admin.websocket.install"
-	PermissionReceiveTransfer  = "admin.websocket.transfer"
 	PermissionReceiveBackups   = "backup.read"
 )
 
 type Handler struct {
-	sync.RWMutex `json:"-"`
+	sync.RWMutex
-	Connection   *websocket.Conn `json:"-"`
+	Connection *websocket.Conn
-	jwt          *tokens.WebsocketPayload
+	jwt        *tokens.WebsocketPayload `json:"-"`
-	server       *server.Server
+	server     *server.Server
-	ra           server.RequestActivity
-	uuid         uuid.UUID
 }
 
-var (
+// Parses a JWT into a websocket token payload.
-	ErrJwtNotPresent    = errors.New("jwt: no jwt present")
-	ErrJwtNoConnectPerm = errors.New("jwt: missing connect permission")
-	ErrJwtUuidMismatch  = errors.New("jwt: server uuid mismatch")
-	ErrJwtOnDenylist    = errors.New("jwt: created too far in past (denylist)")
-)
-
-func IsJwtError(err error) bool {
-	return errors.Is(err, ErrJwtNotPresent) ||
-		errors.Is(err, ErrJwtNoConnectPerm) ||
-		errors.Is(err, ErrJwtUuidMismatch) ||
-		errors.Is(err, ErrJwtOnDenylist) ||
-		errors.Is(err, jwt.ErrExpValidation)
-}
-
-// NewTokenPayload parses a JWT into a websocket token payload.
 func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
-	var payload tokens.WebsocketPayload
+	payload := tokens.WebsocketPayload{}
-	if err := tokens.ParseToken(token, &payload); err != nil {
+	err := tokens.ParseToken(token, &payload)
+	if err != nil {
 		return nil, err
 	}
 
-	if payload.Denylisted() {
-		return nil, ErrJwtOnDenylist
-	}
-
 	if !payload.HasPermission(PermissionConnect) {
-		return nil, ErrJwtNoConnectPerm
+		return nil, errors.New("not authorized to connect to this socket")
 	}
 
 	return &payload, nil
 }
 
-// GetHandler returns a new websocket handler using the context provided.
+// Returns a new websocket handler using the context provided.
-func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request, c *gin.Context) (*Handler, error) {
+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,
 		// and not some other location.
 		CheckOrigin: func(r *http.Request) bool {
-			o := r.Header.Get("Origin")
+			return r.Header.Get("Origin") == config.Get().PanelLocation
-			if o == config.Get().PanelLocation {
-				return true
-			}
-			for _, origin := range config.Get().AllowedOrigins {
-				if origin == "*" || origin == o {
-					return true
-				}
-			}
-			return false
 		},
 	}
 
@@ -103,44 +65,26 @@ func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request, c *gin
 		return nil, err
 	}
 
-	u, err := uuid.NewRandom()
-	if err != nil {
-		return nil, err
-	}
-
 	return &Handler{
 		Connection: conn,
 		jwt:        nil,
 		server:     s,
-		ra:         s.NewRequestActivity("", c.ClientIP()),
-		uuid:       u,
 	}, nil
 }
 
-func (h *Handler) Uuid() uuid.UUID {
+func (h *Handler) SendJson(v *Message) error {
-	return h.uuid
+	// Do not send JSON down the line if the JWT on the connection is not
-}
+	// valid!
-
-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{
-			Event: JwtErrorEvent,
-			Args:  []string{err.Error()},
-		})
 		return nil
 	}
 
-	if j := h.GetJwt(); j != nil {
+	j := h.GetJwt()
+	if 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 {
+			zap.S().Debugf("%+v", v.Args)
 			if !j.HasPermission(PermissionReceiveInstall) {
 				return nil
 			}
@@ -153,32 +97,9 @@ func (h *Handler) SendJson(v Message) error {
 				return nil
 			}
 		}
-
-		// If we are sending transfer output, only send it to the user if they have the required permissions.
-		if v.Event == server.TransferLogsEvent {
-			if !j.HasPermission(PermissionReceiveTransfer) {
-				return nil
-			}
-		}
 	}
 
-	if err := h.unsafeSendJson(v); err != nil {
+	return h.unsafeSendJson(v)
-		// Not entirely sure how this happens (likely just when there is a ton of console spam)
-		// but I don't care to fix it right now, so just mask the error and throw a warning into
-		// the logs for us to look into later.
-		if errors.Is(err, websocket.ErrCloseSent) {
-			if h.server != nil {
-				h.server.Log().WithField("subsystem", "websocket").
-					WithField("event", v.Event).
-					Warn("failed to send event to websocket: close already sent")
-			}
-			return nil
-		}
-
-		return err
-	}
-
-	return nil
 }
 
 // Sends JSON over the websocket connection, ignoring the authentication state of the
@@ -191,63 +112,60 @@ func (h *Handler) unsafeSendJson(v interface{}) error {
 	return h.Connection.WriteJSON(v)
 }
 
-// TokenValid checks if the JWT is still valid.
+// Checks if the JWT is still valid.
 func (h *Handler) TokenValid() error {
 	j := h.GetJwt()
 	if j == nil {
-		return ErrJwtNotPresent
+		return errors.New("no jwt present")
 	}
 
 	if err := jwt.ExpirationTimeValidator(time.Now())(&j.Payload); err != nil {
 		return err
 	}
 
-	if j.Denylisted() {
-		return ErrJwtOnDenylist
-	}
-
 	if !j.HasPermission(PermissionConnect) {
-		return ErrJwtNoConnectPerm
+		return errors.New("jwt does not have connect permission")
 	}
 
-	if h.server.ID() != j.GetServerUuid() {
+	if h.server.Uuid != j.ServerUUID {
-		return ErrJwtUuidMismatch
+		return errors.New("jwt server uuid mismatch")
 	}
 
 	return nil
 }
 
-// SendErrorJson sends an error back to the connected websocket instance by checking the permissions
+// 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 {
+func (h *Handler) SendErrorJson(err error) error {
+	h.Lock()
+	defer h.Unlock()
+
 	j := h.GetJwt()
-	isJWTError := IsJwtError(err)
 
-	wsm := Message{
+	message := "an unexpected error was encountered while handling this request"
-		Event: ErrorEvent,
+	if server.IsSuspendedError(err) || (j != nil && j.HasPermission(PermissionReceiveErrors)) {
-		Args:  []string{"an unexpected error was encountered while handling this request"},
+		message = err.Error()
 	}
 
-	if isJWTError || (j != nil && j.HasPermission(PermissionReceiveErrors)) {
+	m, u := h.GetErrorMessage(message)
-		if isJWTError {
-			wsm.Event = JwtErrorEvent
-		}
-		wsm.Args = []string{err.Error()}
-	}
 
-	m, u := h.GetErrorMessage(wsm.Args[0])
+	wsm := Message{Event: ErrorEvent}
 	wsm.Args = []string{m}
 
-	if !isJWTError && (len(shouldLog) == 0 || (len(shouldLog) == 1 && shouldLog[0] == true)) {
+	if !server.IsSuspendedError(err) {
-		h.server.Log().WithFields(log.Fields{"event": msg.Event, "error_identifier": u.String(), "error": err}).
+		zap.S().Errorw(
-			Errorf("error processing websocket event \"%s\"", msg.Event)
+			"an error was encountered in the websocket process",
+			zap.String("server", h.server.Uuid),
+			zap.String("error_identifier", u.String()),
+			zap.Error(err),
+		)
 	}
 
-	return h.unsafeSendJson(wsm)
+	return h.Connection.WriteJSON(wsm)
 }
 
-// GetErrorMessage converts an error message into a more readable representation and returns a UUID
+// 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())
@@ -257,7 +175,13 @@ func (h *Handler) GetErrorMessage(msg string) (string, uuid.UUID) {
 	return m, u
 }
 
-// GetJwt returns the JWT for the websocket in a race-safe manner.
+// 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()
+}
+
 func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	h.RLock()
 	defer h.RUnlock()
@@ -265,22 +189,17 @@ func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	return h.jwt
 }
 
-// setJwt sets the JWT for the websocket in a race-safe manner.
+// Handle the inbound socket request and route it to the proper server action.
-func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
+func (h *Handler) HandleInbound(m Message) error {
-	h.Lock()
-	h.ra = h.ra.SetUser(token.UserUUID)
-	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 {
+			zap.S().Debugw("jwt token is no longer valid", zap.String("message", err.Error()))
+
 			h.unsafeSendJson(Message{
-				Event: JwtErrorEvent,
+				Event: ErrorEvent,
-				Args:  []string{err.Error()},
+				Args:  []string{"could not authenticate client: " + err.Error()},
 			})
+
 			return nil
 		}
 	}
@@ -290,122 +209,80 @@ func (h *Handler) HandleInbound(ctx context.Context, 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
 			}
 
-			// Check if the user has previously authenticated successfully.
+			if token.HasPermission(PermissionConnect) {
-			newConnection := h.GetJwt() == nil
+				h.setJwt(token)
-
-			// Previously there was a HasPermission(PermissionConnect) check around this,
-			// however NewTokenPayload will return an error if it doesn't have the connect
-			// permission meaning that it was a redundant function call.
-			h.setJwt(token)
-
-			// Tell the client they authenticated successfully.
-			_ = h.unsafeSendJson(Message{Event: AuthenticationSuccessEvent})
-
-			// Check if the client was refreshing their authentication token
-			// instead of authenticating for the first time.
-			if !newConnection {
-				// This prevents duplicate status messages as outlined in
-				// https://github.com/pterodactyl/panel/issues/2077
-				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.server.Events().Publish(server.StatusEvent, h.server.GetState())
-			_ = h.SendJson(Message{
+
-				Event: server.StatusEvent,
+			h.unsafeSendJson(Message{
-				Args:  []string{state},
+				Event: AuthenticationSuccessEvent,
+				Args:  []string{},
 			})
 
-			// Only send the current disk usage if the server is offline, if docker container is running,
-			// Environment#EnableResourcePolling() will send this data to all clients.
-			if state == environment.ProcessOfflineState {
-				if !h.server.IsInstalling() && !h.server.IsTransferring() {
-					_ = h.server.Filesystem().HasSpaceAvailable(false)
-
-					b, _ := json.Marshal(h.server.Proc())
-					_ = h.SendJson(Message{
-						Event: server.StatsEvent,
-						Args:  []string{string(b)},
-					})
-				}
-			}
-
 			return nil
 		}
 	case SetStateEvent:
 		{
-			action := server.PowerAction(strings.Join(m.Args, ""))
+			switch strings.Join(m.Args, "") {
-
+			case "start":
-			actions := make(map[server.PowerAction]string)
+				if h.GetJwt().HasPermission(PermissionSendPowerStart) {
-			actions[server.PowerActionStart] = PermissionSendPowerStart
+					return h.server.Environment.Start()
-			actions[server.PowerActionStop] = PermissionSendPowerStop
-			actions[server.PowerActionRestart] = PermissionSendPowerRestart
-			actions[server.PowerActionTerminate] = PermissionSendPowerStop
-
-			// Check that they have permission to perform this action if it is needed.
-			if permission, exists := actions[action]; exists {
-				if !h.GetJwt().HasPermission(permission) {
-					return nil
 				}
+				break
+			case "stop":
+				if h.GetJwt().HasPermission(PermissionSendPowerStop) {
+					return h.server.Environment.Stop()
+				}
+				break
+			case "restart":
+				if h.GetJwt().HasPermission(PermissionSendPowerRestart) {
+					if err := h.server.Environment.WaitForStop(60, false); err != nil {
+						return err
+					}
+
+					return h.server.Environment.Start()
+				}
+				break
+			case "kill":
+				if h.GetJwt().HasPermission(PermissionSendPowerStop) {
+					return h.server.Environment.Terminate(os.Kill)
+				}
+				break
 			}
 
-			err := h.server.HandlePowerAction(action)
+			return nil
-			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{
-					Event: ErrorEvent,
-					Args:  []string{m},
-				})
-
-				return nil
-			}
-
-			if err == nil {
-				h.server.SaveActivity(h.ra, models.Event(server.ActivityPowerPrefix+action), nil)
-			}
-
-			return err
 		}
 	case SendServerLogsEvent:
 		{
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			if running, _ := h.server.Environment.IsRunning(); !running {
-			defer cancel()
-			if running, _ := h.server.Environment.IsRunning(ctx); !running {
 				return nil
 			}
 
-			logs, err := h.server.Environment.Readlog(config.Get().System.WebsocketLogCount)
+			logs, err := h.server.Environment.Readlog(1024 * 16)
 			if err != nil {
 				return err
 			}
 
 			for _, line := range logs {
-				_ = h.SendJson(Message{
+				h.SendJson(&Message{
 					Event: server.ConsoleOutputEvent,
 					Args:  []string{line},
 				})
 			}
 
-			return nil
-		}
-	case SendStatsEvent:
-		{
-			b, _ := json.Marshal(h.server.Proc())
-			_ = h.SendJson(Message{
-				Event: server.StatsEvent,
-				Args:  []string{string(b)},
-			})
-
 			return nil
 		}
 	case SendCommandEvent:
@@ -414,29 +291,11 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 				return nil
 			}
 
-			if h.server.Environment.State() == environment.ProcessOfflineState {
+			if h.server.GetState() == server.ProcessOfflineState {
 				return nil
 			}
 
-			// TODO(dane): should probably add a new process state that is "booting environment" or something
+			return h.server.Environment.SendCommand(strings.Join(m.Args, ""))
-			//  so that we can better handle this and only set the environment to booted once we're attached.
-			//
-			//  Or maybe just an IsBooted function?
-			if h.server.Environment.State() == environment.ProcessStartingState {
-				if e, ok := h.server.Environment.(*docker.Environment); ok {
-					if !e.IsAttached() {
-						return nil
-					}
-				}
-			}
-
-			if err := h.server.Environment.SendCommand(strings.Join(m.Args, "")); err != nil {
-				return err
-			}
-			h.server.SaveActivity(h.ra, server.ActivityConsoleCommand, models.ActivityMeta{
-				"command": strings.Join(m.Args, ""),
-			})
-			return nil
 		}
 	}
 

rpm/ptero-wings.spec

@@ -1,124 +0,0 @@
-Name:       ptero-wings
-Version:    1.7.0
-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 Sep 14 2022 Chance Callahan <ccallaha@redhat.com> - 1.7.0-1
-- Updating specfile to match stable release.
-
-* 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/activity.go

@@ -1,64 +0,0 @@
-package server
-
-import (
-	"context"
-	"emperror.dev/errors"
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-	"time"
-)
-
-const ActivityPowerPrefix = "server:power."
-
-const (
-	ActivityConsoleCommand      = models.Event("server:console.command")
-	ActivitySftpWrite           = models.Event("server:sftp.write")
-	ActivitySftpCreate          = models.Event("server:sftp.create")
-	ActivitySftpCreateDirectory = models.Event("server:sftp.create-directory")
-	ActivitySftpRename          = models.Event("server:sftp.rename")
-	ActivitySftpDelete          = models.Event("server:sftp.delete")
-	ActivityFileUploaded        = models.Event("server:file.uploaded")
-)
-
-// RequestActivity is a wrapper around a LoggedEvent that is able to track additional request
-// specific metadata including the specific user and IP address associated with all subsequent
-// events. The internal logged event structure can be extracted by calling RequestEvent.Event().
-type RequestActivity struct {
-	server string
-	user   string
-	ip     string
-}
-
-// Event returns the underlying logged event from the RequestEvent instance and sets the
-// specific event and metadata on it.
-func (ra RequestActivity) Event(event models.Event, metadata models.ActivityMeta) *models.Activity {
-	a := models.Activity{Server: ra.server, IP: ra.ip, Event: event, Metadata: metadata}
-
-	return a.SetUser(ra.user)
-}
-
-// SetUser clones the RequestActivity struct and sets a new user value on the copy
-// before returning it.
-func (ra RequestActivity) SetUser(u string) RequestActivity {
-	c := ra
-	c.user = u
-	return c
-}
-
-func (s *Server) NewRequestActivity(user string, ip string) RequestActivity {
-	return RequestActivity{server: s.ID(), user: user, ip: ip}
-}
-
-// SaveActivity saves an activity entry to the database in a background routine. If an error is
-// encountered it is logged but not returned to the caller.
-func (s *Server) SaveActivity(a RequestActivity, event models.Event, metadata models.ActivityMeta) {
-	ctx, cancel := context.WithTimeout(s.Context(), time.Second*3)
-	go func() {
-		defer cancel()
-		if tx := database.Instance().WithContext(ctx).Create(a.Event(event, metadata)); tx.Error != nil {
-			s.Log().WithField("error", errors.WithStack(tx.Error)).
-				WithField("event", event).
-				Error("activity: failed to save event")
-		}
-	}()
-}

server/archiver.go

@@ -0,0 +1,104 @@
+package server
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"github.com/mholt/archiver/v3"
+	"github.com/pterodactyl/wings/config"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+// Archiver represents a Server Archiver.
+type Archiver struct {
+	Server *Server
+}
+
+// ArchivePath returns the path to the server's archive.
+func (a *Archiver) ArchivePath() string {
+	return filepath.Join(config.Get().System.ArchiveDirectory, a.ArchiveName())
+}
+
+// ArchiveName returns the name of the server's archive.
+func (a *Archiver) ArchiveName() string {
+	return a.Server.Uuid + ".tar.gz"
+}
+
+// Exists returns a boolean based off if the archive exists.
+func (a *Archiver) Exists() bool {
+	if _, err := os.Stat(a.ArchivePath()); os.IsNotExist(err) {
+		return false
+	}
+
+	return true
+}
+
+// Stat stats the archive file.
+func (a *Archiver) Stat() (*Stat, error) {
+	return a.Server.Filesystem.unsafeStat(a.ArchivePath())
+}
+
+// Archive creates an archive of the server and deletes the previous one.
+func (a *Archiver) Archive() error {
+	path := a.Server.Filesystem.Path()
+
+	// Get the list of root files and directories to archive.
+	var files []string
+	fileInfo, err := ioutil.ReadDir(path)
+	if err != nil {
+		return err
+	}
+
+	for _, file := range fileInfo {
+		files = append(files, filepath.Join(path, file.Name()))
+	}
+
+	stat, err := a.Stat()
+	if err != nil && !os.IsNotExist(err) {
+		return err
+	}
+
+	// Check if the file exists.
+	if stat != nil {
+		if err := os.Remove(a.ArchivePath()); err != nil {
+			return err
+		}
+	}
+
+	return archiver.NewTarGz().Archive(files, a.ArchivePath())
+}
+
+// DeleteIfExists deletes the archive if it exists.
+func (a *Archiver) DeleteIfExists() error {
+	stat, err := a.Stat()
+	if err != nil && !os.IsNotExist(err) {
+		return err
+	}
+
+	// Check if the file exists.
+	if stat != nil {
+		if err := os.Remove(a.ArchivePath()); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Checksum computes a SHA256 checksum of the server's archive.
+func (a *Archiver) Checksum() (string, error) {
+	file, err := os.Open(a.ArchivePath())
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	hash := sha256.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", err
+	}
+
+	return hex.EncodeToString(hash.Sum(nil)), nil
+}

server/backup.go

@@ -1,167 +1,115 @@
 package server
 
 import (
-	"io"
+	"bufio"
-	"io/fs"
+	"github.com/pkg/errors"
-	"os"
+	"github.com/pterodactyl/wings/api"
-	"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"
+	"go.uber.org/zap"
+	"os"
+	"path"
 )
 
 // Notifies the panel of a backup's state and returns an error if one is encountered
 // while performing this action.
 func (s *Server) notifyPanelOfBackup(uuid string, ad *backup.ArchiveDetails, successful bool) error {
-	if err := s.client.SetBackupStatus(s.Context(), uuid, ad.ToRequest(successful)); err != nil {
+	r := api.NewRequester()
-		if !remote.IsRequestError(err) {
+	rerr, err := r.SendBackupStatus(uuid, ad.ToRequest(successful))
-			s.Log().WithFields(log.Fields{
+	if rerr != nil || err != nil {
-				"backup": uuid,
+		if err != nil {
-				"error":  err,
+			zap.S().Errorw(
-			}).Error("failed to notify panel of backup status due to wings error")
+				"failed to notify panel of backup status due to internal code error",
+				zap.String("backup", s.Uuid),
+				zap.Error(err),
+			)
 
 			return err
 		}
 
-		return errors.New(err.Error())
+		zap.S().Warnw(rerr.String(), zap.String("backup", uuid))
+
+		return errors.New(rerr.String())
 	}
 
 	return nil
 }
 
 // Get all of the ignored files for a server based on its .pteroignore file in the root.
-func (s *Server) getServerwideIgnoredFiles() (string, error) {
+func (s *Server) getServerwideIgnoredFiles() ([]string, error) {
-	f, st, err := s.Filesystem().File(".pteroignore")
+	var ignored []string
+
+	f, err := os.Open(path.Join(s.Filesystem.Path(), ".pteroignore"))
 	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
+		if !os.IsNotExist(err) {
-			return "", nil
+			return nil, err
+		}
+	} else {
+		scanner := bufio.NewScanner(f)
+		for scanner.Scan() {
+			// Only include non-empty lines, for the sake of clarity...
+			if t := scanner.Text(); t != "" {
+				ignored = append(ignored, t)
+			}
+		}
+
+		if err := scanner.Err(); err != nil {
+			return nil, err
 		}
-		return "", err
 	}
-	defer f.Close()
+
-	if st.Mode()&os.ModeSymlink != 0 || st.Size() > 32*1024 {
+	return ignored, nil
-		// Don't read a symlinked ignore file, or a file larger than 32KiB in size.
-		return "", nil
-	}
-	b, err := io.ReadAll(f)
-	if err != nil {
-		return "", err
-	}
-	return string(b), nil
 }
 
-// Backup performs a server backup and then emits the event over the server
+// Get the backup files to include when generating it.
-// websocket. We let the actual backup system handle notifying the panel of the
+func (s *Server) GetIncludedBackupFiles(ignored []string) (*backup.IncludedFiles, error) {
-// status, but that won't emit a websocket event.
+	// If no ignored files are present in the request, check for a .pteroignore file in the root
-func (s *Server) Backup(b backup.BackupInterface) error {
+	// of the server files directory, and use that to generate the backup.
-	ignored := b.Ignored()
+	if len(ignored) == 0 {
-	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")
+			zap.S().Warnw("failed to retrieve server ignored files", zap.String("server", s.Uuid), zap.Error(err))
 		} else {
 			ignored = i
 		}
 	}
 
-	ad, err := b.Generate(s.Context(), s.Filesystem().Path(), ignored)
+	// Get the included files based on the root path and the ignored files provided.
+	return s.Filesystem.GetIncludedFiles(s.Filesystem.Path(), ignored)
+}
+
+// Performs a server backup and then emits the event over the server websocket. We
+// let the actual backup system handle notifying the panel of the status, but that
+// won't emit a websocket event.
+func (s *Server) Backup(b backup.BackupInterface) error {
+	// Get the included files based on the root path and the ignored files provided.
+	inc, err := s.GetIncludedBackupFiles(b.Ignored())
 	if err != nil {
-		if err := s.notifyPanelOfBackup(b.Identifier(), &backup.ArchiveDetails{}, false); err != nil {
+		return errors.WithStack(err)
-			s.Log().WithFields(log.Fields{
+	}
-				"backup": b.Identifier(),
+
-				"error":  err,
+	ad, err := b.Generate(inc, s.Filesystem.Path())
-			}).Warn("failed to notify panel of failed backup state")
+	if err != nil {
-		} else {
+		if notifyError := s.notifyPanelOfBackup(b.Identifier(), &backup.ArchiveDetails{}, false); notifyError != nil {
-			s.Log().WithField("backup", b.Identifier()).Info("notified panel of failed backup state")
+			zap.S().Warnw("failed to notify panel of failed backup state", zap.String("backup", b.Identifier()), zap.Error(err))
 		}
 
-		s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+		return errors.WithStack(err)
-			"uuid":          b.Identifier(),
-			"is_successful": false,
-			"checksum":      "",
-			"checksum_type": "sha1",
-			"file_size":     0,
-		})
-
-		return errors.WrapIf(err, "backup: error while generating server backup")
 	}
 
 	// Try to notify the panel about the status of this backup. If for some reason this request
 	// fails, delete the archive from the daemon and return that error up the chain to the caller.
 	if notifyError := s.notifyPanelOfBackup(b.Identifier(), ad, true); notifyError != nil {
-		_ = b.Remove()
+		b.Remove()
 
-		s.Log().WithField("error", notifyError).Info("failed to notify panel of successful backup state")
+		return notifyError
-		return err
-	} else {
-		s.Log().WithField("backup", b.Identifier()).Info("notified panel of successful backup state")
 	}
 
 	// Emit an event over the socket so we can update the backup in realtime on
 	// the frontend for the server.
-	s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+	s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
-		"uuid":          b.Identifier(),
+		"uuid":        b.Identifier(),
-		"is_successful": true,
+		"sha256_hash": ad.Checksum,
-		"checksum":      ad.Checksum,
+		"file_size":   ad.Size,
-		"checksum_type": "sha1",
-		"file_size":     ad.Size,
 	})
 
 	return nil
 }
-
-// RestoreBackup calls the Restore function on the provided backup. Once this
-// restoration is completed an event is emitted to the websocket to notify the
-// Panel that is has been completed.
-//
-// In addition to the websocket event an API call is triggered to notify the
-// Panel of the new state.
-func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (err error) {
-	s.Config().SetSuspended(true)
-	// Local backups will not pass a reader through to this function, so check first
-	// to make sure it is a valid reader before trying to close it.
-	defer func() {
-		s.Config().SetSuspended(false)
-		if reader != nil {
-			reader.Close()
-		}
-	}()
-	// Send an API call to the Panel as soon as this function is done running so that
-	// the Panel is informed of the restoration status of this backup.
-	defer func() {
-		if rerr := s.client.SendRestorationStatus(s.Context(), b.Identifier(), err == nil); rerr != nil {
-			s.Log().WithField("error", rerr).WithField("backup", b.Identifier()).Error("failed to notify Panel of backup restoration status")
-		}
-	}()
-
-	// Don't try to restore the server until we have completely stopped the running
-	// instance, otherwise you'll likely hit all types of write errors due to the
-	// server being suspended.
-	if s.Environment.State() != environment.ProcessOfflineState {
-		if err = s.Environment.WaitForStop(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")
-			}
-		}
-	}
-
-	// 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(s.Context(), reader, func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error {
-		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
-		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/archiver.go

@@ -0,0 +1,111 @@
+package backup
+
+import (
+	"archive/tar"
+	"context"
+	gzip "github.com/klauspost/pgzip"
+	"github.com/remeh/sizedwaitgroup"
+	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
+	"io"
+	"os"
+	"strings"
+	"sync"
+)
+
+type Archive struct {
+	sync.Mutex
+
+	TrimPrefix string
+	Files      *IncludedFiles
+}
+
+// Creates an archive at dest with all of the files definied in the included files struct.
+func (a *Archive) Create(dest string, ctx context.Context) error {
+	f, err := os.OpenFile(dest, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	gzw := gzip.NewWriter(f)
+	defer gzw.Close()
+
+	tw := tar.NewWriter(gzw)
+	defer tw.Close()
+
+	wg := sizedwaitgroup.New(10)
+	g, ctx := errgroup.WithContext(ctx)
+	// Iterate over all of the files to be included and put them into the archive. This is
+	// done as a concurrent goroutine to speed things along. If an error is encountered at
+	// any step, the entire process is aborted.
+	for p, s := range a.Files.All() {
+		if (*s).IsDir() {
+			continue
+		}
+
+		pa := p
+		st := s
+
+		g.Go(func() error {
+			wg.Add()
+			defer wg.Done()
+
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			default:
+				return a.addToArchive(pa, st, tw)
+			}
+		})
+	}
+
+	// Block until the entire routine is completed.
+	if err := g.Wait(); err != nil {
+		f.Close()
+
+		// Attempt to remove the archive if there is an error, report that error to
+		// the logger if it fails.
+		if rerr := os.Remove(dest); rerr != nil && !os.IsNotExist(rerr) {
+			zap.S().Warnw("failed to delete corrupted backup archive", zap.String("location", dest))
+		}
+
+		return err
+	}
+
+	return nil
+}
+
+// Adds a single file to the existing tar archive writer.
+func (a *Archive) addToArchive(p string, s *os.FileInfo, w *tar.Writer) error {
+	f, err := os.Open(p)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	st := *s
+	header := &tar.Header{
+		// Trim the long server path from the name of the file so that the resulting
+		// archive is exactly how the user would see it in the panel file manager.
+		Name:    strings.TrimPrefix(p, a.TrimPrefix),
+		Size:    st.Size(),
+		Mode:    int64(st.Mode()),
+		ModTime: st.ModTime(),
+	}
+
+	// These actions must occur sequentially, even if this function is called multiple
+	// in parallel. You'll get some nasty panic's otherwise.
+	a.Lock()
+	defer a.Unlock()
+
+	if err = w.WriteHeader(header); err != nil {
+		return err
+	}
+
+	if _, err := io.Copy(w, f); err != nil {
+		return err
+	}
+
+	return nil
+}

server/backup/backup.go

@@ -1,65 +1,35 @@
 package backup
 
 import (
-	"context"
+	"crypto/sha256"
-	"crypto/sha1"
 	"encoding/hex"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
+	"go.uber.org/zap"
 	"io"
-	"io/fs"
 	"os"
 	"path"
-	"time"
+	"sync"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"golang.org/x/sync/errgroup"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/remote"
 )
 
-type AdapterType string
-
 const (
-	LocalBackupAdapter AdapterType = "wings"
+	LocalBackupAdapter = "wings"
-	S3BackupAdapter    AdapterType = "s3"
+	S3BackupAdapter    = "s3"
 )
 
-// RestoreCallback is a generic restoration callback that exists for both local
+type ArchiveDetails struct {
-// and remote backups allowing the files to be restored.
+	Checksum string `json:"checksum"`
-type RestoreCallback func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error
+	Size     int64  `json:"size"`
+}
 
-// noinspection GoNameStartsWithPackageName
+// Returns a request object.
-type BackupInterface interface {
+func (ad *ArchiveDetails) ToRequest(successful bool) api.BackupRequest {
-	// SetClient sets the API request client on the backup interface.
+	return api.BackupRequest{
-	SetClient(remote.Client)
+		Checksum:   ad.Checksum,
-	// Identifier returns the UUID of this backup as tracked by the panel
+		Size:       ad.Size,
-	// instance.
+		Successful: successful,
-	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(context.Context, 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(context.Context, []remote.BackupPart) (*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(context.Context, io.Reader, RestoreCallback) error
 }
 
 type Backup struct {
@@ -69,112 +39,113 @@ type Backup struct {
 
 	// An array of files to ignore when generating this backup. This should be
 	// compatible with a standard .gitignore structure.
-	Ignore string `json:"ignore"`
+	IgnoredFiles []string `json:"ignored_files"`
-
-	client     remote.Client
-	adapter    AdapterType
-	logContext map[string]interface{}
 }
 
-func (b *Backup) SetClient(c remote.Client) {
+// noinspection GoNameStartsWithPackageName
-	b.client = c
+type BackupInterface interface {
+	// Returns the UUID of this backup as tracked by the panel instance.
+	Identifier() string
+
+	// Generates a backup in whatever the configured source for the specific
+	// implementation is.
+	Generate(*IncludedFiles, string) (*ArchiveDetails, error)
+
+	// Returns the ignored files for this backup instance.
+	Ignored() []string
+
+	// Returns a SHA256 checksum for the generated backup.
+	Checksum() ([]byte, error)
+
+	// Returns the size of the generated backup.
+	Size() (int64, error)
+
+	// Returns the path to the backup on the machine. This is not always the final
+	// storage location of the backup, simply the location we're using to store
+	// it until it is moved to the final spot.
+	Path() string
+
+	// Returns details about the archive.
+	Details() *ArchiveDetails
+
+	// Removes a backup file.
+	Remove() error
 }
 
 func (b *Backup) Identifier() string {
 	return b.Uuid
 }
 
-// Path returns the path for this specific backup.
+// Returns the path for this specific backup.
 func (b *Backup) Path() string {
 	return path.Join(config.Get().System.BackupDirectory, b.Identifier()+".tar.gz")
 }
 
-// Size returns the size of the generated backup.
+// Return the size of the generated backup.
 func (b *Backup) Size() (int64, error) {
 	st, err := os.Stat(b.Path())
 	if err != nil {
-		return 0, err
+		return 0, errors.WithStack(err)
 	}
 
 	return st.Size(), nil
 }
 
-// Checksum returns the SHA256 checksum of a backup.
+// Returns the SHA256 checksum of a backup.
 func (b *Backup) Checksum() ([]byte, error) {
-	h := sha1.New()
+	h := sha256.New()
 
 	f, err := os.Open(b.Path())
 	if err != nil {
-		return nil, err
+		return []byte{}, errors.WithStack(err)
 	}
 	defer f.Close()
 
-	buf := make([]byte, 1024*4)
+	if _, err := io.Copy(h, f); err != nil {
-	if _, err := io.CopyBuffer(h, f, buf); err != nil {
+		return []byte{}, errors.WithStack(err)
-		return nil, err
 	}
 
 	return h.Sum(nil), nil
 }
 
-// Details returns both the checksum and size of the archive currently stored on
+// Returns details of the archive by utilizing two go-routines to get the checksum and
-// the disk to the caller.
+// the size of the archive.
-func (b *Backup) Details(ctx context.Context, parts []remote.BackupPart) (*ArchiveDetails, error) {
+func (b *Backup) Details() *ArchiveDetails {
-	ad := ArchiveDetails{ChecksumType: "sha1", Parts: parts}
+	wg := sync.WaitGroup{}
-	g, ctx := errgroup.WithContext(ctx)
+	wg.Add(2)
+
+	var checksum string
+	// Calculate the checksum for the file.
+	go func() {
+		defer wg.Done()
 
-	g.Go(func() error {
 		resp, err := b.Checksum()
 		if err != nil {
-			return err
+			zap.S().Errorw("failed to calculate checksum for backup", zap.String("backup", b.Uuid), zap.Error(err))
 		}
-		ad.Checksum = hex.EncodeToString(resp)
-		return nil
-	})
 
-	g.Go(func() error {
+		checksum = hex.EncodeToString(resp)
-		s, err := b.Size()
+	}()
-		if err != nil {
+
-			return err
+	var sz int64
+	go func() {
+		defer wg.Done()
+
+		if s, err := b.Size(); err != nil {
+			return
+		} else {
+			sz = s
 		}
-		ad.Size = s
+	}()
-		return nil
-	})
 
-	if err := g.Wait(); err != nil {
+	wg.Wait()
-		return nil, errors.WithStackDepth(err, 1)
-	}
-	return &ad, nil
-}
 
-func (b *Backup) Ignored() string {
+	return &ArchiveDetails{
-	return b.Ignore
+		Checksum: checksum,
-}
+		Size:     sz,
-
-// Returns a logger instance for this backup with the additional context fields
-// assigned to the output.
-func (b *Backup) log() *log.Entry {
-	l := log.WithField("backup", b.Identifier()).WithField("adapter", b.adapter)
-	for k, v := range b.logContext {
-		l = l.WithField(k, v)
-	}
-	return l
-}
-
-type ArchiveDetails struct {
-	Checksum     string              `json:"checksum"`
-	ChecksumType string              `json:"checksum_type"`
-	Size         int64               `json:"size"`
-	Parts        []remote.BackupPart `json:"parts"`
-}
-
-// 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,
-		Parts:        ad.Parts,
 	}
 }
+
+func (b *Backup) Ignored() []string {
+	return b.IgnoredFiles
+}

server/backup/backup_local.go

@@ -2,14 +2,8 @@ package backup
 
 import (
 	"context"
-	"io"
+	"github.com/pkg/errors"
 	"os"
-
-	"emperror.dev/errors"
-	"github.com/mholt/archiver/v3"
-
-	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/server/filesystem"
 )
 
 type LocalBackup struct {
@@ -18,77 +12,44 @@ type LocalBackup struct {
 
 var _ BackupInterface = (*LocalBackup)(nil)
 
-func NewLocal(client remote.Client, uuid string, ignore string) *LocalBackup {
+// Locates the backup for a server and returns the local path. This will obviously only
-	return &LocalBackup{
+// work if the backup was created as a local backup.
+func LocateLocal(uuid string) (*LocalBackup, os.FileInfo, error) {
+	b := &LocalBackup{
 		Backup{
-			client:  client,
+			Uuid:         uuid,
-			Uuid:    uuid,
+			IgnoredFiles: nil,
-			Ignore:  ignore,
-			adapter: LocalBackupAdapter,
 		},
 	}
-}
 
-// LocateLocal finds the backup for a server and returns the local path. This
-// will obviously only work if the backup was created as a local backup.
-func LocateLocal(client remote.Client, uuid string) (*LocalBackup, os.FileInfo, error) {
-	b := NewLocal(client, uuid, "")
 	st, err := os.Stat(b.Path())
 	if err != nil {
 		return nil, nil, err
 	}
 
 	if st.IsDir() {
-		return nil, nil, errors.New("invalid archive, is directory")
+		return nil, nil, errors.New("invalid archive found; is directory")
 	}
 
 	return b, st, nil
 }
 
-// Remove removes a backup from the system.
+// Removes a backup from the system.
 func (b *LocalBackup) Remove() error {
 	return os.Remove(b.Path())
 }
 
-// WithLogContext attaches additional context to the log output for this backup.
+// Generates a backup of the selected files and pushes it to the defined location
-func (b *LocalBackup) WithLogContext(c map[string]interface{}) {
+// for this instance.
-	b.logContext = c
+func (b *LocalBackup) Generate(included *IncludedFiles, prefix string) (*ArchiveDetails, error) {
-}
+	a := &Archive{
-
+		TrimPrefix: prefix,
-// Generate generates a backup of the selected files and pushes it to the
+		Files:      included,
-// defined location for this instance.
-func (b *LocalBackup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
-	a := &filesystem.Archive{
-		BasePath: basePath,
-		Ignore:   ignore,
 	}
 
-	b.log().WithField("path", b.Path()).Info("creating backup for server")
+	if err := a.Create(b.Path(), context.Background()); err != nil {
-	if err := a.Create(b.Path()); err != nil {
 		return nil, err
 	}
-	b.log().Info("created backup successfully")
 
-	ad, err := b.Details(ctx, nil)
+	return b.Details(), nil
-	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(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
-			}
-			return callback(filesystem.ExtractNameFromArchive(f), f, f.Mode(), f.ModTime(), f.ModTime())
-		}
-	})
 }

server/backup/backup_request.go

@@ -0,0 +1,46 @@
+package backup
+
+import (
+	"fmt"
+	"github.com/pkg/errors"
+)
+
+type Request struct {
+	Adapter      string   `json:"adapter"`
+	Uuid         string   `json:"uuid"`
+	IgnoredFiles []string `json:"ignored_files"`
+	PresignedUrl string   `json:"presigned_url"`
+}
+
+// Generates a new local backup struct.
+func (r *Request) NewLocalBackup() (*LocalBackup, error) {
+	if r.Adapter != LocalBackupAdapter {
+		return nil, errors.New(fmt.Sprintf("cannot create local backup using [%s] adapter", r.Adapter))
+	}
+
+	return &LocalBackup{
+		Backup{
+			Uuid:         r.Uuid,
+			IgnoredFiles: r.IgnoredFiles,
+		},
+	}, nil
+}
+
+// Generates a new S3 backup struct.
+func (r *Request) NewS3Backup() (*S3Backup, error) {
+	if r.Adapter != S3BackupAdapter {
+		return nil, errors.New(fmt.Sprintf("cannot create s3 backup using [%s] adapter", r.Adapter))
+	}
+
+	if len(r.PresignedUrl) == 0 {
+		return nil, errors.New("a valid presigned S3 upload URL must be provided to use the [s3] adapter")
+	}
+
+	return &S3Backup{
+		Backup: Backup{
+			Uuid:         r.Uuid,
+			IgnoredFiles: r.IgnoredFiles,
+		},
+		PresignedUrl: r.PresignedUrl,
+	}, nil
+}

server/backup/backup_s3.go

@@ -1,270 +1,83 @@
 package backup
 
 import (
-	"archive/tar"
-	"compress/gzip"
 	"context"
 	"fmt"
+	"go.uber.org/zap"
 	"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"
 )
 
 type S3Backup struct {
 	Backup
+
+	// The pre-signed upload endpoint for the generated backup. This must be
+	// provided otherwise this request will fail. This allows us to keep all
+	// of the keys off the daemon instances and the panel can handle generating
+	// the credentials for us.
+	PresignedUrl string
 }
 
 var _ BackupInterface = (*S3Backup)(nil)
 
-func NewS3(client remote.Client, uuid string, ignore string) *S3Backup {
+// Generates a new backup on the disk, moves it into the S3 bucket via the provided
-	return &S3Backup{
+// presigned URL, and then deletes the backup from the disk.
-		Backup{
+func (s *S3Backup) Generate(included *IncludedFiles, prefix string) (*ArchiveDetails, error) {
-			client:  client,
+	defer s.Remove()
-			Uuid:    uuid,
+
-			Ignore:  ignore,
+	a := &Archive{
-			adapter: S3BackupAdapter,
+		TrimPrefix: prefix,
-		},
+		Files:      included,
 	}
+
+	if err := a.Create(s.Path(), context.Background()); err != nil {
+		return nil, err
+	}
+
+	rc, err := os.Open(s.Path())
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+
+	if resp, err := s.generateRemoteRequest(rc); err != nil {
+		return nil, err
+	} else {
+		resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("failed to put S3 object, %d:%s", resp.StatusCode, resp.Status)
+		}
+	}
+
+	return s.Details(), err
 }
 
-// Remove removes a backup from the system.
+// Removes a backup from the system.
 func (s *S3Backup) Remove() error {
 	return os.Remove(s.Path())
 }
 
-// WithLogContext attaches additional context to the log output for this backup.
-func (s *S3Backup) WithLogContext(c map[string]interface{}) {
-	s.logContext = c
-}
-
-// 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(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
-	defer s.Remove()
-
-	a := &filesystem.Archive{
-		BasePath: basePath,
-		Ignore:   ignore,
-	}
-
-	s.log().WithField("path", s.Path()).Info("creating backup for server")
-	if err := a.Create(s.Path()); err != nil {
-		return nil, err
-	}
-	s.log().Info("created backup successfully")
-
-	rc, err := os.Open(s.Path())
-	if err != nil {
-		return nil, errors.Wrap(err, "backup: could not read archive from disk")
-	}
-	defer rc.Close()
-
-	parts, err := s.generateRemoteRequest(ctx, rc)
-	if err != nil {
-		return nil, err
-	}
-	ad, err := s.Details(ctx, parts)
-	if err != nil {
-		return nil, errors.WrapIf(err, "backup: failed to get archive details after upload")
-	}
-	return ad, nil
-}
-
-// Restore will read from the provided reader assuming that it is a gzipped
-// tar reader. When a file is encountered in the archive the callback function
-// will be triggered. If the callback returns an error the entire process is
-// stopped, otherwise this function will run until all files have been written.
-//
-// This restoration uses a workerpool to use up to the number of CPUs available
-// on the machine when writing files to the disk.
-func (s *S3Backup) Restore(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
-			}
-		}
-	}
-	return nil
-}
-
 // Generates the remote S3 request and begins the upload.
-func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser) ([]remote.BackupPart, error) {
+func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) (*http.Response, error) {
-	defer rc.Close()
+	r, err := http.NewRequest(http.MethodPut, s.PresignedUrl, nil)
-
-	s.log().Debug("attempting to get size of backup...")
-	size, err := s.Backup.Size()
 	if err != nil {
 		return nil, err
 	}
-	s.log().WithField("size", size).Debug("got size of backup")
 
-	s.log().Debug("attempting to get S3 upload urls from Panel...")
+	if sz, err := s.Size(); err != nil {
-	urls, err := s.client.GetBackupRemoteUploadURLs(context.Background(), s.Backup.Uuid, size)
-	if err != nil {
 		return nil, err
-	}
+	} else {
-	s.log().Debug("got S3 upload urls from the Panel")
+		r.ContentLength = sz
-	s.log().WithField("parts", len(urls.Parts)).Info("attempting to upload backup to s3 endpoint...")
+		r.Header.Add("Content-Length", strconv.Itoa(int(sz)))
-
+		r.Header.Add("Content-Type", "application/x-gzip")
-	uploader := newS3FileUploader(rc)
-	for i, part := range urls.Parts {
-		// Get the size for the current part.
-		var partSize int64
-		if i+1 < len(urls.Parts) {
-			partSize = urls.PartSize
-		} else {
-			// This is the remaining size for the last part,
-			// there is not a minimum size limit for the last part.
-			partSize = size - (int64(i) * urls.PartSize)
-		}
-
-		// Attempt to upload the part.
-		etag, err := uploader.uploadPart(ctx, part, partSize)
-		if err != nil {
-			s.log().WithField("part_id", i+1).WithError(err).Warn("failed to upload part")
-			return nil, err
-		}
-		uploader.uploadedParts = append(uploader.uploadedParts, remote.BackupPart{
-			ETag:       etag,
-			PartNumber: i + 1,
-		})
-		s.log().WithField("part_id", i+1).Info("successfully uploaded backup part")
-	}
-	s.log().WithField("parts", len(urls.Parts)).Info("backup has been successfully uploaded")
-
-	return uploader.uploadedParts, nil
-}
-
-type s3FileUploader struct {
-	io.ReadCloser
-	client        *http.Client
-	uploadedParts []remote.BackupPart
-}
-
-// 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.
-//
-// 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 "", errors.Wrap(err, "backup: could not create request for S3")
 	}
 
-	r.ContentLength = size
+	r.Body = rc
-	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.
+	zap.S().Debugw("uploading backup to remote S3 endpoint", zap.String("endpoint", s.PresignedUrl), zap.Any("headers", r.Header))
-	r.Body = Reader{Reader: io.LimitReader(fu.ReadCloser, size)}
 
-	var etag string
+	return http.DefaultClient.Do(r)
-	err = backoff.Retry(func() error {
-		res, err := fu.client.Do(r)
-		if err != nil {
-			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
-			}
-			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/backup/included.go

@@ -0,0 +1,31 @@
+package backup
+
+import (
+	"os"
+	"sync"
+)
+
+type IncludedFiles struct {
+	sync.RWMutex
+	files map[string]*os.FileInfo
+}
+
+// Pushes an additional file or folder onto the struct.
+func (i *IncludedFiles) Push(info *os.FileInfo, p string) {
+	i.Lock()
+	defer i.Unlock()
+
+	if i.files == nil {
+		i.files = make(map[string]*os.FileInfo)
+	}
+
+	i.files[p] = info
+}
+
+// Returns all of the files that were marked as being included.
+func (i *IncludedFiles) All() map[string]*os.FileInfo {
+	i.RLock()
+	defer i.RUnlock()
+
+	return i.files
+}

server/collection.go

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

server/config_parser.go

@@ -1,37 +1,34 @@
 package server
 
 import (
-	"runtime"
+	"github.com/pterodactyl/wings/parser"
-
+	"go.uber.org/zap"
-	"github.com/gammazero/workerpool"
+	"sync"
 )
 
-// UpdateConfigurationFiles updates all of the defined configuration files for
+// Parent function that will update all of the defined configuration files for a server
-// a server automatically to ensure that they always use the specified values.
+// automatically to ensure that they always use the specified values.
 func (s *Server) UpdateConfigurationFiles() {
-	pool := workerpool.New(runtime.NumCPU())
+	wg := new(sync.WaitGroup)
 
-	s.Log().Debug("acquiring process configuration files...")
+	for _, v := range s.processConfiguration.ConfigurationFiles {
-	files := s.ProcessConfiguration().ConfigurationFiles
+		wg.Add(1)
-	s.Log().Debug("acquired process configuration files")
-	for _, cf := range files {
-		f := cf
 
-		pool.Submit(func() {
+		go func(f parser.ConfigurationFile, server *Server) {
-			p, err := s.Filesystem().SafePath(f.FileName)
+			defer wg.Done()
+
+			p, err := s.Filesystem.SafePath(f.FileName)
 			if err != nil {
-				s.Log().WithField("error", err).Error("failed to generate safe path for configuration file")
+				zap.S().Errorw("failed to generate safe path for configuration file", zap.String("server", server.Uuid), zap.Error(err))
 
 				return
 			}
 
 			if err := f.Parse(p, false); err != nil {
-				s.Log().WithField("error", err).Error("failed to parse and update server configuration file")
+				zap.S().Errorw("failed to parse and update server configuration file", zap.String("server", server.Uuid), zap.Error(err))
 			}
-
+		}(v, s)
-			s.Log().WithField("path", f.FileName).Debug("finished processing server configuration file")
-		})
 	}
 
-	pool.StopWait()
+	wg.Wait()
 }

server/configuration.go

@@ -1,90 +0,0 @@
-package server
-
-import (
-	"sync"
-
-	"github.com/pterodactyl/wings/environment"
-)
-
-type EggConfiguration struct {
-	// The internal UUID of the Egg on the Panel.
-	ID string `json:"id"`
-
-	// Maintains a list of files that are blacklisted for opening/editing/downloading
-	// or basically any type of access on the server by any user. This is NOT the same
-	// as a per-user denylist, this is defined at the Egg level.
-	FileDenylist []string `json:"file_denylist"`
-}
-
-type ConfigurationMeta struct {
-	Name        string `json:"name"`
-	Description string `json:"description"`
-}
-
-type Configuration struct {
-	mu sync.RWMutex
-
-	// The unique identifier for the server that should be used when referencing
-	// it against the Panel API (and internally). This will be used when naming
-	// docker containers as well as in log output.
-	Uuid string `json:"uuid"`
-
-	Meta ConfigurationMeta `json:"meta"`
-
-	// Whether or not the server is in a suspended state. Suspended servers cannot
-	// be started or modified except in certain scenarios by an admin user.
-	Suspended bool `json:"suspended"`
-
-	// The command that should be used when booting up the server instance.
-	Invocation string `json:"invocation"`
-
-	// 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 `json:"skip_egg_scripts"`
-
-	// An array of environment variables that should be passed along to the running
-	// server process.
-	EnvVars environment.Variables `json:"environment"`
-
-	Allocations           environment.Allocations `json:"allocations"`
-	Build                 environment.Limits      `json:"build"`
-	CrashDetectionEnabled bool                    `json:"crash_detection_enabled"`
-	Mounts                []Mount                 `json:"mounts"`
-	Egg                   EggConfiguration        `json:"egg,omitempty"`
-
-	Container struct {
-		// Defines the Docker image that will be used for this server
-		Image string `json:"image,omitempty"`
-	} `json:"container,omitempty"`
-}
-
-func (s *Server) Config() *Configuration {
-	s.cfg.mu.RLock()
-	defer s.cfg.mu.RUnlock()
-	return &s.cfg
-}
-
-// 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
-}

server/console.go

@@ -2,80 +2,33 @@ package server
 
 import (
 	"fmt"
-	"sync"
-	"time"
-
 	"github.com/mitchellh/colorstring"
-	"github.com/pterodactyl/wings/config"
+	"io"
-	"github.com/pterodactyl/wings/system"
 )
 
-// appName is a local cache variable to avoid having to make expensive copies of
+type Console struct {
-// the configuration every time we need to send output along to the websocket for
+	Server      *Server
-// a server.
+	HandlerFunc *func(string)
-var appName string
+}
-var appNameSync sync.Once
 
-// PublishConsoleOutputFromDaemon sends output to the server console formatted
+var _ io.Writer = Console{}
-// to appear correctly as being sent from Wings.
+
+func (c Console) Write(b []byte) (int, error) {
+	if c.HandlerFunc != nil {
+		l := make([]byte, len(b))
+		copy(l, b)
+
+		(*c.HandlerFunc)(string(l))
+	}
+
+	return len(b), nil
+}
+
+// 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)),
+		colorstring.Color(fmt.Sprintf("[yellow][bold][Pterodactyl Daemon]:[default] %s", data)),
 	)
 }
-
-// Throttler returns the throttler instance for the server or creates a new one.
-func (s *Server) Throttler() *ConsoleThrottle {
-	s.throttleOnce.Do(func() {
-		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
-}
-
-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

@@ -1,62 +0,0 @@
-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/crash.go

@@ -2,54 +2,42 @@ package server
 
 import (
 	"fmt"
-	"strconv"
+	"github.com/pkg/errors"
-	"sync"
-	"time"
-
 	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/environment"
+	"go.uber.org/zap"
+	"time"
 )
 
-type CrashHandler struct {
+type CrashDetection struct {
-	mu sync.RWMutex
+	// If set to false, the system will not listen for crash detection events that
+	// can indicate that the server stopped unexpectedly.
+	Enabled bool `default:"true" json:"enabled" yaml:"enabled"`
 
 	// Tracks the time of the last server crash event.
 	lastCrash time.Time
 }
 
-// Returns the time of the last crash for this server instance.
-func (cd *CrashHandler) LastCrashTime() time.Time {
-	cd.mu.RLock()
-	defer cd.mu.RUnlock()
-
-	return cd.lastCrash
-}
-
-// Sets the last crash time for a server.
-func (cd *CrashHandler) SetLastCrash(t time.Time) {
-	cd.mu.Lock()
-	cd.lastCrash = t
-	cd.mu.Unlock()
-}
-
 // Looks at the environment exit state to determine if the process exited cleanly or
 // if it was the result of an event that we should try to recover from.
 //
 // This function assumes it is called under circumstances where a crash is suspected
-// of occurring. It will not do anything to determine if it was actually a crash, just
+// of occuring. It will not do anything to determine if it was actually a crash, just
 // look at the exit state and check if it meets the criteria of being called a crash
 // by Wings.
 //
 // If the server is determined to have crashed, the process will be restarted and the
 // counter for the server will be incremented.
+//
+// @todo output event to server console
 func (s *Server) handleServerCrash() error {
 	// No point in doing anything here if the server isn't currently offline, there
 	// is no reason to do a crash detection event. If the server crash detection is
 	// disabled we want to skip anything after this as well.
-	if s.Environment.State() != environment.ProcessOfflineState || !s.Config().CrashDetectionEnabled {
+	if s.GetState() != ProcessOfflineState || !s.CrashDetection.Enabled {
-		if !s.Config().CrashDetectionEnabled {
+		if !s.CrashDetection.Enabled {
-			s.Log().Debug("server triggered crash detection but handler is disabled for server process")
+			zap.S().Debugw("server triggered crash detection but handler is disabled for server process", zap.String("server", s.Uuid))
-			s.PublishConsoleOutputFromDaemon("Aborting automatic restart, crash detection is disabled for this instance.")
+
+			s.PublishConsoleOutputFromDaemon("Server detected as crashed; crash detection is disabled for this instance.")
 		}
 
 		return nil
@@ -57,13 +45,14 @@ func (s *Server) handleServerCrash() error {
 
 	exitCode, oomKilled, err := s.Environment.ExitState()
 	if err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	// If the system is not configured to detect a clean exit code as a crash, and the
 	// crash is not the result of the program running out of memory, do nothing.
-	if exitCode == 0 && !oomKilled && !config.Get().System.CrashDetection.DetectCleanExitAsCrash {
+	if exitCode == 0 && !oomKilled && !config.Get().System.DetectCleanExitAsCrash {
-		s.Log().Debug("server exited with successful exit code; system is configured to not detect this as a crash")
+		zap.S().Debugw("server exited with successful code; system configured to not detect as crash", zap.String("server", s.Uuid))
+
 		return nil
 	}
 
@@ -71,19 +60,16 @@ func (s *Server) handleServerCrash() error {
 	s.PublishConsoleOutputFromDaemon(fmt.Sprintf("Exit code: %d", exitCode))
 	s.PublishConsoleOutputFromDaemon(fmt.Sprintf("Out of memory: %t", oomKilled))
 
-	c := s.crasher.LastCrashTime()
+	c := s.CrashDetection.lastCrash
-	timeout := config.Get().System.CrashDetection.Timeout
+	// If the last crash time was within the last 60 seconds we do not want to perform
-
-	// If the last crash time was within the last `timeout` seconds we do not want to perform
 	// an automatic reboot of the process. Return an error that can be handled.
-	//
+	if !c.IsZero() && c.Add(time.Second * 60).After(time.Now()) {
-	// If timeout is set to 0, always reboot the server (this is probably a terrible idea, but some people want it)
+		s.PublishConsoleOutputFromDaemon("Aborting automatic reboot: last crash occurred less than 60 seconds ago.")
-	if timeout != 0 && !c.IsZero() && c.Add(time.Second*time.Duration(config.Get().System.CrashDetection.Timeout)).After(time.Now()) {
+
-		s.PublishConsoleOutputFromDaemon("Aborting automatic restart, last crash occurred less than " + strconv.Itoa(timeout) + " seconds ago.")
 		return &crashTooFrequent{}
 	}
 
-	s.crasher.SetLastCrash(time.Now())
+	s.CrashDetection.lastCrash = time.Now()
 
-	return s.HandlePowerAction(PowerActionStart)
+	return s.Environment.Start()
 }

server/environment.go

@@ -0,0 +1,84 @@
+package server
+
+import (
+	"os"
+)
+
+// Defines the basic interface that all environments need to implement so that
+// a server can be properly controlled.
+type Environment interface {
+	// Returns the name of the environment.
+	Type() string
+
+	// Determines if the environment is currently active and running a server process
+	// for this specific server instance.
+	IsRunning() (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
+	// a no-op.
+	InSituUpdate() error
+
+	// Runs before the environment is started. If an error is returned starting will
+	// not occur, otherwise proceeds as normal.
+	OnBeforeStart() 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
+
+	// Stops a server instance. If the server is already stopped an error should
+	// not be returned.
+	Stop() 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 int, terminate bool) error
+
+	// 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)
+
+	// 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
+
+	// Destroys the environment removing any containers that were created (in Docker
+	// environments at least).
+	Destroy() error
+
+	// Returns the exit state of the process. The first result is the exit code, the second
+	// determines if the process was killed by the system OOM killer.
+	ExitState() (uint32, bool, error)
+
+	// Creates the necessary environment for running the server process. For example,
+	// in the Docker environment create will create a new container instance for the
+	// 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
+	// send data into the environment's stdin.
+	Attach() error
+
+	// Follows the output from the server console and will begin piping the output to
+	// the server's emitter.
+	FollowConsoleOutput() error
+
+	// Sends the provided command to the running server instance.
+	SendCommand(string) error
+
+	// Reads the log file for the process from the end backwards until the provided
+	// number of bytes is met.
+	Readlog(int64) ([]string, error)
+
+	// Polls the given environment for resource usage of the server when the process
+	// is running.
+	EnableResourcePolling() error
+
+	// Disables the polling operation for resource usage and sets the required values
+	// to 0 in the server resource usage struct.
+	DisableResourcePolling() error
+}

server/environment_docker.go

@@ -0,0 +1,862 @@
+package server
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"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/go-connections/nat"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/config"
+	"go.uber.org/zap"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Defines the base environment for Docker instances running through Wings.
+type DockerEnvironment struct {
+	Server *Server
+
+	// The Docker client being used for this instance.
+	Client *client.Client
+
+	// Tracks if we are currently attached to the server container. This allows us to attach
+	// once and then just use that attachment to stream logs out of the server and also stream
+	// commands back into it without constantly attaching and detaching.
+	attached bool
+
+	// Controls the hijacked response stream which exists only when we're attached to
+	// the running container instance.
+	stream types.HijackedResponse
+
+	// Holds the stats stream used by the polling commands so that we can easily close
+	// it out.
+	stats io.ReadCloser
+}
+
+// Creates a new base Docker environment. A server must still be attached to it.
+func NewDockerEnvironment(server *Server) error {
+	cli, err := client.NewClientWithOpts(client.FromEnv)
+	if err != nil {
+		return err
+	}
+
+	server.Environment = &DockerEnvironment{
+		Server: server,
+		Client: cli,
+	}
+
+	return nil
+}
+
+// Ensure that the Docker environment is always implementing all of the methods
+// from the base environment interface.
+var _ Environment = (*DockerEnvironment)(nil)
+
+// Returns the name of the environment.
+func (d *DockerEnvironment) Type() string {
+	return "docker"
+}
+
+// Determines if the container exists in this environment.
+func (d *DockerEnvironment) Exists() (bool, error) {
+	_, err := d.Client.ContainerInspect(context.Background(), d.Server.Uuid)
+
+	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).
+//
+// You can confirm if the instance wasn't found by using client.IsErrNotFound from the Docker
+// API.
+//
+// @see docker/client/errors.go
+func (d *DockerEnvironment) IsRunning() (bool, error) {
+	ctx := context.Background()
+
+	c, err := d.Client.ContainerInspect(ctx, d.Server.Uuid)
+	if err != nil {
+		return false, err
+	}
+
+	return c.State.Running, nil
+}
+
+// Performs an in-place update of the Docker container's resource limits without actually
+// making any changes to the operational state of the container. This allows memory, cpu,
+// and IO limitations to be adjusted on the fly for individual instances.
+func (d *DockerEnvironment) InSituUpdate() error {
+	if _, err := d.Client.ContainerInspect(context.Background(), d.Server.Uuid); 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
+		// to the disk.
+		//
+		// We'll let a boot process make modifications to the container if needed at this point.
+		if client.IsErrNotFound(err) {
+			return nil
+		}
+
+		return errors.WithStack(err)
+	}
+
+	u := container.UpdateConfig{
+		Resources: d.getResourcesForServer(),
+	}
+
+	if _, err := d.Client.ContainerUpdate(context.Background(), d.Server.Uuid, u); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+// 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 unbootable.
+func (d *DockerEnvironment) OnBeforeStart() error {
+	zap.S().Infow("syncing server configuration with Panel", zap.String("server", d.Server.Uuid))
+	if err := d.Server.Sync(); err != nil {
+		return err
+	}
+
+	if !d.Server.Filesystem.HasSpaceAvailable() {
+		return errors.New("cannot start server, not enough disk space available")
+	}
+
+	// Always destroy and re-create the server container to ensure that synced data from
+	// the Panel is used.
+	if err := d.Client.ContainerRemove(context.Background(), d.Server.Uuid, types.ContainerRemoveOptions{RemoveVolumes: true}); err != nil {
+		if !client.IsErrNotFound(err) {
+			return err
+		}
+	}
+
+	// The Create() function will check if the container exists in the first place, and if
+	// so just silently return without an error. Otherwise, it will try to create the necessary
+	// container and data storage directory.
+	//
+	// This won't actually run an installation process however, it is just here to ensure the
+	// environment gets created properly if it is missing and the server is started. We're making
+	// an assumption that all of the files will still exist at this point.
+	if err := d.Create(); err != nil {
+		return err
+	}
+
+	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 (d *DockerEnvironment) Start() error {
+	sawError := false
+	// If sawError is set to true there was an error somewhere in the pipeline that
+	// got passed up, but we also want to ensure we set the server to be offline at
+	// that point.
+	defer func() {
+		if sawError {
+			d.Server.SetState(ProcessOfflineState)
+		}
+	}()
+
+	// If the server is suspended the user shouldn't be able to boot it, in those cases
+	// return a suspension error and let the calling area handle the issue.
+	//
+	// Theoretically you'd have the Panel handle all of this logic, but we cannot do that
+	// because we allow the websocket to control the server power state as well, so we'll
+	// need to handle that action in here.
+	if d.Server.Suspended {
+		return &suspendedError{}
+	}
+
+	if c, err := d.Client.ContainerInspect(context.Background(), d.Server.Uuid); 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 againt
+		// a nil-pointer when checking c.State below.
+		//
+		// @see https://github.com/pterodactyl/panel/issues/2000
+		if !client.IsErrNotFound(err) {
+			return errors.WithStack(err)
+		}
+	} else {
+		// If the server is running update our internal state and continue on with the attach.
+		if c.State.Running {
+			d.Server.SetState(ProcessRunningState)
+
+			return d.Attach()
+		}
+
+		// 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 errors.WithStack(err)
+			}
+		}
+	}
+
+	d.Server.SetState(ProcessStartingState)
+	// Set this to true for now, we will set it to false once we reach the
+	// end of this chain.
+	sawError = true
+
+	// 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 := d.OnBeforeStart(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// 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 completed. 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
+	// server starts in a weird state and the user can manually adjust.
+	d.Server.UpdateConfigurationFiles()
+
+	// Reset the permissions on files for the server before actually trying
+	// to start it.
+	if err := d.Server.Filesystem.Chown("/"); err != nil {
+		return errors.WithStack(err)
+	}
+
+	opts := types.ContainerStartOptions{}
+	if err := d.Client.ContainerStart(context.Background(), d.Server.Uuid, opts); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// No errors, good to continue through.
+	sawError = false
+
+	return d.Attach()
+}
+
+// Stops the container that the server is running in. This will allow up to 10
+// seconds to pass before a failure occurs.
+func (d *DockerEnvironment) Stop() error {
+	stop := d.Server.processConfiguration.Stop
+	if stop.Type == api.ProcessStopSignal {
+		return d.Terminate(os.Kill)
+	}
+
+	d.Server.SetState(ProcessStoppingState)
+	if stop.Type == api.ProcessStopCommand {
+		return d.SendCommand(stop.Value)
+	}
+
+	t := time.Second * 10
+
+	return d.Client.ContainerStop(context.Background(), d.Server.Uuid, &t)
+}
+
+// Attempts to gracefully stop a server using the defined stop command. If the server
+// does not stop after seconds have passed, an error will be returned, or the instance
+// will be terminated forcefully depending on the value of the second argument.
+func (d *DockerEnvironment) WaitForStop(seconds int, terminate bool) error {
+	if d.Server.GetState() == ProcessOfflineState {
+		return nil
+	}
+
+	if err := d.Stop(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(seconds)*time.Second)
+	defer cancel()
+
+	// 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 := d.Client.ContainerWait(ctx, d.Server.Uuid, container.WaitConditionNotRunning)
+	select {
+	case <-ctx.Done():
+		if ctxErr := ctx.Err(); ctxErr != nil {
+			if terminate {
+				return d.Terminate(os.Kill)
+			}
+
+			return errors.WithStack(ctxErr)
+		}
+	case err := <-errChan:
+		if err != nil {
+			return errors.WithStack(err)
+		}
+	case <-ok:
+	}
+
+	return nil
+}
+
+// Forcefully terminates the container using the signal passed through.
+func (d *DockerEnvironment) Terminate(signal os.Signal) error {
+	ctx := context.Background()
+
+	c, err := d.Client.ContainerInspect(ctx, d.Server.Uuid)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	if !c.State.Running {
+		return nil
+	}
+
+	d.Server.SetState(ProcessStoppingState)
+
+	return d.Client.ContainerKill(
+		ctx, d.Server.Uuid, strings.TrimSuffix(strings.TrimPrefix(signal.String(), "signal "), "ed"),
+	)
+}
+
+// Remove the Docker container from the machine. If the container is currently running
+// it will be forcibly stopped by Docker.
+func (d *DockerEnvironment) Destroy() error {
+	ctx := context.Background()
+
+	// Avoid crash detection firing off.
+	d.Server.SetState(ProcessStoppingState)
+
+	err := d.Client.ContainerRemove(ctx, d.Server.Uuid, types.ContainerRemoveOptions{
+		RemoveVolumes: true,
+		RemoveLinks:   false,
+		Force:         true,
+	})
+
+	// Don't trigger a destroy failure if we try to delete a container that does not
+	// exist on the system. We're just a step ahead of ourselves in that case.
+	//
+	// @see https://github.com/pterodactyl/panel/issues/2001
+	if err != nil && client.IsErrNotFound(err) {
+		return nil
+	}
+
+	return err
+}
+
+// Determine the container exit state and return the exit code and wether or not
+// the container was killed by the OOM killer.
+func (d *DockerEnvironment) ExitState() (uint32, bool, error) {
+	c, err := d.Client.ContainerInspect(context.Background(), d.Server.Uuid)
+	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
+		// created a new container for it.
+		//
+		// However, someone reported an error in Discord about this scenario happening,
+		// so I guess this should prevent it? They didn't tell me how they caused it though
+		// so thats a mystery that will have to go unsolved.
+		//
+		// @see https://github.com/pterodactyl/panel/issues/2003
+		if client.IsErrNotFound(err) {
+			return 1, false, nil
+		}
+
+		return 0, false, errors.WithStack(err)
+	}
+
+	return uint32(c.State.ExitCode), c.State.OOMKilled, nil
+}
+
+// Attaches to the docker container itself and ensures that we can pipe data in and out
+// of the process stream. This should not be used for reading console data as you *will*
+// miss important output at the beginning because of the time delay with attaching to the
+// output.
+func (d *DockerEnvironment) Attach() error {
+	if d.attached {
+		return nil
+	}
+
+	if err := d.FollowConsoleOutput(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	ctx := context.Background()
+
+	var err error
+	d.stream, err = d.Client.ContainerAttach(ctx, d.Server.Uuid, types.ContainerAttachOptions{
+		Stdin:  true,
+		Stdout: true,
+		Stderr: true,
+		Stream: true,
+	})
+
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	console := Console{
+		Server: d.Server,
+	}
+
+	d.attached = true
+	go func() {
+		if err := d.EnableResourcePolling(); err != nil {
+			zap.S().Warnw("failed to enabled resource polling on server", zap.String("server", d.Server.Uuid), zap.Error(errors.WithStack(err)))
+		}
+	}()
+
+	go func() {
+		defer d.stream.Close()
+		defer func() {
+			d.Server.SetState(ProcessOfflineState)
+			d.attached = false
+		}()
+
+		io.Copy(console, d.stream.Reader)
+	}()
+
+	return nil
+}
+
+// Attaches to the log for the container. This avoids us missing cruicial output that
+// happens in the split seconds before the code moves from 'Starting' to 'Attaching'
+// on the process.
+func (d *DockerEnvironment) FollowConsoleOutput() error {
+	if exists, err := d.Exists(); !exists {
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		return errors.New(fmt.Sprintf("no such container: %s", d.Server.Uuid))
+	}
+
+	ctx := context.Background()
+	opts := types.ContainerLogsOptions{
+		ShowStderr: true,
+		ShowStdout: true,
+		Follow:     true,
+		Since:      time.Now().Format(time.RFC3339),
+	}
+
+	reader, err := d.Client.ContainerLogs(ctx, d.Server.Uuid, opts)
+
+	go func(r io.ReadCloser) {
+		defer r.Close()
+
+		s := bufio.NewScanner(r)
+		for s.Scan() {
+			d.Server.Events().Publish(ConsoleOutputEvent, s.Text())
+		}
+
+		if err := s.Err(); err != nil {
+			zap.S().Warnw("error processing scanner line in console output", zap.String("server", d.Server.Uuid), zap.Error(err))
+		}
+	}(reader)
+
+	return errors.WithStack(err)
+}
+
+// Enables resource polling on the docker instance. Except we aren't actually polling Docker for this
+// information, instead just sit there with an async process that lets Docker stream all of this data
+// to us automatically.
+func (d *DockerEnvironment) EnableResourcePolling() error {
+	if d.Server.GetState() == ProcessOfflineState {
+		return errors.New("cannot enable resource polling on a server that is not running")
+	}
+
+	ctx := context.Background()
+
+	stats, err := d.Client.ContainerStats(ctx, d.Server.Uuid, true)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	d.stats = stats.Body
+
+	dec := json.NewDecoder(d.stats)
+	go func(s *Server) {
+		for {
+			var v *types.StatsJSON
+
+			if err := dec.Decode(&v); err != nil {
+				if err != io.EOF {
+					zap.S().Warnw("encountered error processing server stats; stopping collection", zap.Error(err))
+				}
+
+				d.DisableResourcePolling()
+				return
+			}
+
+			// Disable collection if the server is in an offline state and this process is
+			// still running.
+			if s.GetState() == ProcessOfflineState {
+				d.DisableResourcePolling()
+				return
+			}
+
+			s.Resources.CpuAbsolute = s.Resources.CalculateAbsoluteCpu(&v.PreCPUStats, &v.CPUStats)
+			s.Resources.Memory = s.Resources.CalculateDockerMemory(v.MemoryStats)
+			s.Resources.MemoryLimit = v.MemoryStats.Limit
+
+			// Why you ask? This already has the logic for caching disk space in use and then
+			// also handles pushing that value to the resources object automatically.
+			s.Filesystem.HasSpaceAvailable()
+
+			for _, nw := range v.Networks {
+				s.Resources.Network.RxBytes += nw.RxBytes
+				s.Resources.Network.TxBytes += nw.TxBytes
+			}
+
+			b, _ := json.Marshal(s.Resources)
+			s.Events().Publish(StatsEvent, string(b))
+		}
+	}(d.Server)
+
+	return nil
+}
+
+// Closes the stats stream for a server process.
+func (d *DockerEnvironment) DisableResourcePolling() error {
+	if d.stats == nil {
+		return nil
+	}
+
+	err := d.stats.Close()
+
+	d.Server.Resources.CpuAbsolute = 0
+	d.Server.Resources.Memory = 0
+	d.Server.Resources.Network.TxBytes = 0
+	d.Server.Resources.Network.RxBytes = 0
+
+	return errors.WithStack(err)
+}
+
+// Pulls the image from Docker.
+//
+// @todo handle authorization & local images
+func (d *DockerEnvironment) ensureImageExists(c *client.Client) error {
+	out, err := c.ImagePull(context.Background(), d.Server.Container.Image, types.ImagePullOptions{All: false})
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	zap.S().Debugw("pulling docker image... this could take a bit of time", zap.String("image", d.Server.Container.Image))
+
+	// I'm not sure what the best approach here is, but this will block execution until the image
+	// is done being pulled, which is what we need.
+	scanner := bufio.NewScanner(out)
+	for scanner.Scan() {
+		continue
+	}
+
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Creates a new container for the server using all of the data that is currently
+// available for it. If the container already exists it will be returned.
+func (d *DockerEnvironment) Create() error {
+	ctx := context.Background()
+	cli, err := client.NewClientWithOpts(client.FromEnv)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Ensure the data directory exists before getting too far through this process.
+	if err := d.Server.Filesystem.EnsureDataDirectory(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// 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 := cli.ContainerInspect(ctx, d.Server.Uuid); err == nil {
+		return nil
+	} else if !client.IsErrNotFound(err) {
+		return errors.WithStack(err)
+	}
+
+	// Try to pull the requested image before creating the container.
+	if err := d.ensureImageExists(cli); err != nil {
+		return errors.WithStack(err)
+	}
+
+	conf := &container.Config{
+		Hostname:     "container",
+		User:         strconv.Itoa(config.Get().System.User.Uid),
+		AttachStdin:  true,
+		AttachStdout: true,
+		AttachStderr: true,
+		OpenStdin:    true,
+		Tty:          true,
+
+		ExposedPorts: d.exposedPorts(),
+
+		Image: d.Server.Container.Image,
+		Env:   d.environmentVariables(),
+
+		Labels: map[string]string{
+			"Service":       "Pterodactyl",
+			"ContainerType": "server_process",
+		},
+	}
+
+	hostConf := &container.HostConfig{
+		PortBindings: d.portBindings(),
+
+		// Configure the mounts for this container. First mount the server data directory
+		// into the container as a r/w bind.
+		Mounts: []mount.Mount{
+			{
+				Target:   "/home/container",
+				Source:   d.Server.Filesystem.Path(),
+				Type:     mount.TypeBind,
+				ReadOnly: false,
+			},
+		},
+
+		// Configure the /tmp folder mapping in containers. This is necessary for some
+		// games that need to make use of it for downloads and other installation processes.
+		Tmpfs: map[string]string{
+			"/tmp": "rw,exec,nosuid,size=50M",
+		},
+
+		// Define resource limits for the container based on the data passed through
+		// from the Panel.
+		Resources: d.getResourcesForServer(),
+
+		DNS: config.Get().Docker.Network.Dns,
+
+		// Configure logging for the container to make it easier on the Daemon to grab
+		// the server output. Ensure that we don't use too much space on the host machine
+		// 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,
+			Config: map[string]string{
+				"max-size": "5m",
+				"max-file": "1",
+			},
+		},
+
+		SecurityOpt:    []string{"no-new-privileges"},
+		ReadonlyRootfs: true,
+		CapDrop: []string{
+			"setpcap", "mknod", "audit_write", "net_raw", "dac_override",
+			"fowner", "fsetid", "net_bind_service", "sys_chroot", "setfcap",
+		},
+		NetworkMode: container.NetworkMode(config.Get().Docker.Network.Mode),
+	}
+
+	if _, err := cli.ContainerCreate(ctx, conf, hostConf, nil, d.Server.Uuid); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+// Sends the specified command to the stdin of the running container instance. There is no
+// confirmation that this data is sent successfully, only that it gets pushed into the stdin.
+func (d *DockerEnvironment) SendCommand(c string) error {
+	if !d.attached {
+		return errors.New("attempting to send command to non-attached instance")
+	}
+
+	_, err := d.stream.Conn.Write([]byte(c + "\n"))
+
+	return errors.WithStack(err)
+}
+
+// Reads the log file for the server. This does not care if the server is running or not, it will
+// simply try to read the last X bytes of the file and return them.
+func (d *DockerEnvironment) Readlog(len int64) ([]string, error) {
+	ctx := context.Background()
+
+	j, err := d.Client.ContainerInspect(ctx, d.Server.Uuid)
+	if err != nil {
+		return nil, err
+	}
+
+	if j.LogPath == "" {
+		return nil, errors.New("empty log path defined for server")
+	}
+
+	f, err := os.Open(j.LogPath)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	// Check if the length of the file is smaller than the amount of data that was requested
+	// for reading. If so, adjust the length to be the total length of the file. If this is not
+	// done an error is thrown since we're reading backwards, and not forwards.
+	if stat, err := os.Stat(j.LogPath); err != nil {
+		return nil, err
+	} else if stat.Size() < len {
+		len = stat.Size()
+	}
+
+	// Seed to the end of the file and then move backwards until the length is met to avoid
+	// reading the entirety of the file into memory.
+	if _, err := f.Seek(-len, io.SeekEnd); err != nil {
+		return nil, err
+	}
+
+	b := make([]byte, len)
+
+	if _, err := f.Read(b); err != nil && err != io.EOF {
+		return nil, err
+	}
+
+	return d.parseLogToStrings(b)
+}
+
+type dockerLogLine struct {
+	Log string `json:"log"`
+}
+
+// Docker stores the logs for server output in a JSON format. This function will iterate over the JSON
+// that was read from the log file and parse it into a more human readable format.
+func (d *DockerEnvironment) parseLogToStrings(b []byte) ([]string, error) {
+	var hasError = false
+	var out []string
+
+	scanner := bufio.NewScanner(bytes.NewReader(b))
+	for scanner.Scan() {
+		var l dockerLogLine
+		// Unmarshal the contents and allow up to a single error before bailing out of the process. We
+		// do this because if you're arbitrarily reading a length of the file you'll likely end up
+		// with the first line in the output being improperly formatted JSON. In those cases we want to
+		// just skip over it. However if we see another error we're going to bail out because that is an
+		// abnormal situation.
+		if err := json.Unmarshal([]byte(scanner.Text()), &l); err != nil {
+			if hasError {
+				return nil, err
+			}
+
+			hasError = true
+			continue
+		}
+
+		out = append(out, l.Log)
+	}
+
+	return out, nil
+}
+
+// Returns the environment variables for a server in KEY="VALUE" form.
+func (d *DockerEnvironment) environmentVariables() []string {
+	zone, _ := time.Now().In(time.Local).Zone()
+
+	var out = []string{
+		fmt.Sprintf("TZ=%s", zone),
+		fmt.Sprintf("STARTUP=%s", d.Server.Invocation),
+		fmt.Sprintf("SERVER_MEMORY=%d", d.Server.Build.MemoryLimit),
+		fmt.Sprintf("SERVER_IP=%s", d.Server.Allocations.DefaultMapping.Ip),
+		fmt.Sprintf("SERVER_PORT=%d", d.Server.Allocations.DefaultMapping.Port),
+	}
+
+eloop:
+	for k, v := range d.Server.EnvVars {
+		for _, e := range out {
+			if strings.HasPrefix(e, strings.ToUpper(k)) {
+				continue eloop
+			}
+		}
+
+		out = append(out, fmt.Sprintf("%s=%s", strings.ToUpper(k), v))
+	}
+
+	return out
+}
+
+func (d *DockerEnvironment) volumes() map[string]struct{} {
+	return nil
+}
+
+// Converts the server allocation mappings into a format that can be understood
+// by Docker.
+func (d *DockerEnvironment) portBindings() nat.PortMap {
+	var out = nat.PortMap{}
+
+	for ip, ports := range d.Server.Allocations.Mappings {
+		for _, port := range ports {
+			// Skip over invalid ports.
+			if port < 0 || port > 65535 {
+				continue
+			}
+
+			binding := []nat.PortBinding{
+				{
+					HostIP:   ip,
+					HostPort: strconv.Itoa(port),
+				},
+			}
+
+			out[nat.Port(fmt.Sprintf("%d/tcp", port))] = binding
+			out[nat.Port(fmt.Sprintf("%d/udp", port))] = binding
+		}
+	}
+
+	return out
+}
+
+// Converts the server allocation mappings into a PortSet that can be understood
+// by Docker. This formatting is slightly different than portBindings as it should
+// return an empty struct rather than a binding.
+//
+// To accomplish this, we'll just get the values from portBindings and then set them
+// to empty structs. Because why not.
+func (d *DockerEnvironment) exposedPorts() nat.PortSet {
+	var out = nat.PortSet{}
+
+	for port := range d.portBindings() {
+		out[port] = struct{}{}
+	}
+
+	return out
+}
+
+// Formats the resources available to a server instance in such as way that Docker will
+// generate a matching environment in the container.
+//
+// This will set the actual memory limit on the container using the multiplier which is the
+// hard limit for the container (after which will result in a crash). We then set the
+// reservation to be the expected memory limit based on simply multiplication.
+//
+// The swap value is either -1 to disable it, or set to the value of the hard memory limit
+// plus the additional swap assigned to the server since Docker expects this value to be
+// the same or higher than the memory limit.
+func (d *DockerEnvironment) getResourcesForServer() container.Resources {
+	return container.Resources{
+		Memory:            d.Server.Build.BoundedMemoryLimit(),
+		MemoryReservation: d.Server.Build.MemoryLimit * 1_000_000,
+		MemorySwap:        d.Server.Build.ConvertedSwap(),
+		CPUQuota:          d.Server.Build.ConvertedCpuLimit(),
+		CPUPeriod:         100_000,
+		CPUShares:         1024,
+		BlkioWeight:       d.Server.Build.IoWeight,
+		OomKillDisable:    &d.Server.Container.OomDisabled,
+		CpusetCpus:        d.Server.Build.Threads,
+	}
+}

server/errors.go

@@ -1,18 +1,20 @@
 package server
 
-import (
+type suspendedError struct {
-	"emperror.dev/errors"
+}
-)
 
-var (
+func (e *suspendedError) Error() string {
-	ErrIsRunning            = errors.New("server is running")
+	return "server is currently in a suspended state"
-	ErrSuspended            = errors.New("server is currently in a suspended state")
+}
-	ErrServerIsInstalling   = errors.New("server is currently installing")
-	ErrServerIsTransferring = errors.New("server is currently being transferred")
-	ErrServerIsRestoring    = errors.New("server is currently being restored")
-)
 
-type crashTooFrequent struct{}
+func IsSuspendedError(err error) bool {
+	_, ok := err.(*suspendedError)
+
+	return ok
+}
+
+type crashTooFrequent struct {
+}
 
 func (e *crashTooFrequent) Error() string {
 	return "server has crashed too soon after the last detected crash"
@@ -24,7 +26,8 @@ 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

@@ -1,55 +1,120 @@
 package server
 
 import (
-	"github.com/pterodactyl/wings/events"
+	"encoding/json"
-	"github.com/pterodactyl/wings/system"
+	"strings"
+	"sync"
 )
 
 // Defines all of the possible output events for a server.
 // noinspection GoNameStartsWithPackageName
 const (
-	DaemonMessageEvent          = "daemon message"
+	DaemonMessageEvent   = "daemon message"
-	InstallOutputEvent          = "install output"
+	InstallOutputEvent   = "install output"
-	InstallStartedEvent         = "install started"
+	ConsoleOutputEvent   = "console output"
-	InstallCompletedEvent       = "install completed"
+	StatusEvent          = "status"
-	ConsoleOutputEvent          = "console output"
+	StatsEvent           = "stats"
-	StatusEvent                 = "status"
+	BackupCompletedEvent = "backup completed"
-	StatsEvent                  = "stats"
-	BackupRestoreCompletedEvent = "backup restore completed"
-	BackupCompletedEvent        = "backup completed"
-	TransferLogsEvent           = "transfer logs"
-	TransferStatusEvent         = "transfer status"
 )
 
-// Events returns the server's emitter instance.
+type Event struct {
-func (s *Server) Events() *events.Bus {
+	Data  string
-	s.emitterLock.Lock()
+	Topic string
-	defer s.emitterLock.Unlock()
+}
 
+type EventBus struct {
+	sync.RWMutex
+
+	subscribers map[string][]chan Event
+}
+
+// Returns the server's emitter instance.
+func (s *Server) Events() *EventBus {
 	if s.emitter == nil {
-		s.emitter = events.NewBus()
+		s.emitter = &EventBus{
+			subscribers: map[string][]chan Event{},
+		}
 	}
 
 	return s.emitter
 }
 
-// Sink returns the instantiated and named sink for a server. If the sink has
+// Publish data to a given topic.
-// not been configured yet this function will cause a panic condition.
+func (e *EventBus) Publish(topic string, data string) {
-func (s *Server) Sink(name system.SinkName) *system.SinkPool {
+	e.RLock()
-	sink, ok := s.sinks[name]
+	defer e.RUnlock()
-	if !ok {
+
-		s.Log().Fatalf("attempt to access nil sink: %s", name)
+	t := topic
+	// Some of our topics 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
+	// name of "backup completed".
+	if strings.Contains(topic, ":") {
+		parts := strings.SplitN(topic, ":", 2)
+
+		if len(parts) == 2 {
+			t = parts[0]
+		}
+	}
+
+	if ch, ok := e.subscribers[t]; ok {
+		go func(data Event, cs []chan Event) {
+			for _, channel := range cs {
+				channel <- data
+			}
+		}(Event{Data: data, Topic: topic}, ch)
 	}
-	return sink
 }
 
-// DestroyAllSinks iterates over all of the sinks configured for the server and
+func (e *EventBus) PublishJson(topic string, data interface{}) error {
-// destroys their instances. Note that this will cause a panic if you attempt
+	b, err := json.Marshal(data)
-// to call Server.Sink() again after. This function is only used when a server
+	if err != nil {
-// is being deleted from the system.
+		return err
-func (s *Server) DestroyAllSinks() {
+	}
-	s.Log().Info("destroying all registered sinks for server instance")
+
-	for _, sink := range s.sinks {
+	e.Publish(topic, string(b))
-		sink.Destroy()
+
+	return nil
+}
+
+// Subscribe to an emitter topic using a channel.
+func (e *EventBus) Subscribe(topic string, ch chan Event) {
+	e.Lock()
+	defer e.Unlock()
+
+	if p, ok := e.subscribers[topic]; ok {
+		e.subscribers[topic] = append(p, ch)
+	} else {
+		e.subscribers[topic] = append([]chan Event{}, ch)
+	}
+}
+
+// Unsubscribe a channel from a topic.
+func (e *EventBus) Unsubscribe(topic string, ch chan Event) {
+	e.Lock()
+	defer e.Unlock()
+
+	if _, ok := e.subscribers[topic]; ok {
+		for i := range e.subscribers[topic] {
+			if ch == e.subscribers[topic][i] {
+				e.subscribers[topic] = append(e.subscribers[topic][:i], e.subscribers[topic][i+1:]...)
+			}
+		}
+	}
+}
+
+// Removes all of the event listeners for the server. This is used when a server
+// is being deleted to avoid a bunch of de-reference errors cropping up. Obviously
+// should also check elsewhere and handle a server reference going nil, but this
+// won't hurt.
+func (e *EventBus) UnsubscribeAll() {
+	e.Lock()
+	defer e.Unlock()
+
+	// Loop over all of the subscribers and just remove all of the events
+	// for them.
+	for t := range e.subscribers {
+		e.subscribers[t] = make([]chan Event, 0)
 	}
 }

server/filesystem.go

@@ -0,0 +1,604 @@
+package server
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/gabriel-vasile/mimetype"
+	"github.com/pkg/errors"
+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/server/backup"
+	ignore "github.com/sabhiram/go-gitignore"
+	"go.uber.org/zap"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Error returned when there is a bad path provided to one of the FS calls.
+var InvalidPathResolution = errors.New("invalid path resolution")
+
+type Filesystem struct {
+	// The server object associated with this Filesystem.
+	Server *Server
+
+	Configuration *config.SystemConfiguration
+}
+
+// Returns the root path that contains all of a server's data.
+func (fs *Filesystem) Path() string {
+	return filepath.Join(fs.Configuration.Data, fs.Server.Uuid)
+}
+
+// Normalizes a directory being passed in to ensure the user is not able to escape
+// from their data directory. After normalization if the directory is still within their home
+// path it is returned. If they managed to "escape" an error will be returned.
+//
+// This logic is actually copied over from the SFTP server code. Ideally that eventually
+// either gets ported into this application, or is able to make use of this package.
+func (fs *Filesystem) SafePath(p string) (string, error) {
+	var nonExistentPathResolution string
+
+	// Calling filpath.Clean on the joined directory will resolve it to the absolute path,
+	// removing any ../ type of resolution arguments, and leaving us with a direct path link.
+	//
+	// This will also trim the existing root path off the beginning of the path passed to
+	// the function since that can get a bit messy.
+	r := filepath.Clean(filepath.Join(fs.Path(), strings.TrimPrefix(p, fs.Path())))
+
+	// At the same time, evaluate the symlink status and determine where this file or folder
+	// is truly pointing to.
+	p, err := filepath.EvalSymlinks(r)
+	if err != nil && !os.IsNotExist(err) {
+		return "", err
+	} else if os.IsNotExist(err) {
+		// The requested directory doesn't exist, so at this point we need to iterate up the
+		// path chain until we hit a directory that _does_ exist and can be validated.
+		parts := strings.Split(filepath.Dir(r), "/")
+
+		var try string
+		// Range over all of the path parts and form directory pathings from the end
+		// moving up until we have a valid resolution or we run out of paths to try.
+		for k := range parts {
+			try = strings.Join(parts[:(len(parts)-k)], "/")
+
+			if !strings.HasPrefix(try, fs.Path()) {
+				break
+			}
+
+			t, err := filepath.EvalSymlinks(try)
+			if err == nil {
+				nonExistentPathResolution = t
+				break
+			}
+		}
+	}
+
+	// If the new path doesn't start with their root directory there is clearly an escape
+	// attempt going on, and we should NOT resolve this path for them.
+	if nonExistentPathResolution != "" {
+		if !strings.HasPrefix(nonExistentPathResolution, fs.Path()) {
+			return "", InvalidPathResolution
+		}
+
+		// If the nonExistentPathResolution variable is not empty then the initial path requested
+		// did not exist and we looped through the pathway until we found a match. At this point
+		// we've confirmed the first matched pathway exists in the root server directory, so we
+		// can go ahead and just return the path that was requested initially.
+		return r, nil
+	}
+
+	// If the requested directory from EvalSymlinks begins with the server root directory go
+	// ahead and return it. If not we'll return an error which will block any further action
+	// on the file.
+	if strings.HasPrefix(p, fs.Path()) {
+		return p, nil
+	}
+
+	return "", InvalidPathResolution
+}
+
+// Determines if the directory a file is trying to be added to has enough space available
+// for the file to be written to.
+//
+// Because determining the amount of space being used by a server is a taxing operation we
+// will load it all up into a cache and pull from that as long as the key is not expired.
+func (fs *Filesystem) HasSpaceAvailable() bool {
+	var space = fs.Server.Build.DiskSpace
+
+	// If space is -1 or 0 just return true, means they're allowed unlimited.
+	if space <= 0 {
+		return true
+	}
+
+	// If we have a match in the cache, use that value in the return. No need to perform an expensive
+	// disk operation, even if this is an empty value.
+	if x, exists := fs.Server.Cache.Get("disk_used"); exists {
+		fs.Server.Resources.Disk = x.(int64)
+		return (x.(int64) / 1000.0 / 1000.0) <= space
+	}
+
+	// If there is no size its either because there is no data (in which case running this function
+	// will have effectively no impact), or there is nothing in the cache, in which case we need to
+	// grab the size of their data directory. This is a taxing operation, so we want to store it in
+	// the cache once we've gotten it.
+	size, err := fs.DirectorySize("/")
+	if err != nil {
+		zap.S().Warnw("failed to determine directory size", zap.String("server", fs.Server.Uuid), zap.Error(err))
+	}
+
+	// Always cache the size, even if there is an error. We want to always return that value
+	// so that we don't cause an endless loop of determining the disk size if there is a temporary
+	// error encountered.
+	fs.Server.Cache.Set("disk_used", size, time.Second*60)
+
+	// Determine if their folder size, in bytes, is smaller than the amount of space they've
+	// been allocated.
+	fs.Server.Resources.Disk = size
+
+	return (size / 1000.0 / 1000.0) <= space
+}
+
+// Determines the directory size of a given location by running parallel tasks to iterate
+// through all of the folders. Returns the size in bytes. This can be a fairly taxing operation
+// on locations with tons of files, so it is recommended that you cache the output.
+func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
+	w := fs.NewWalker()
+	ctx := context.Background()
+
+	var size int64
+	err := w.Walk(dir, ctx, func(f os.FileInfo, _ string) bool {
+		// Only increment the size when we're dealing with a file specifically, otherwise
+		// just continue digging deeper until there are no more directories to iterate over.
+		if !f.IsDir() {
+			atomic.AddInt64(&size, f.Size())
+		}
+		return true
+	})
+
+	return size, err
+}
+
+// Reads a file on the system and returns it as a byte representation in a file
+// reader. This is not the most memory efficient usage since it will be reading the
+// entirety of the file into memory.
+func (fs *Filesystem) Readfile(p string) (io.Reader, error) {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err := ioutil.ReadFile(cleaned)
+	if err != nil {
+		return nil, err
+	}
+
+	return bytes.NewReader(b), nil
+}
+
+// Writes a file to the system. If the file does not already exist one will be created.
+//
+// @todo should probably have a write lock here so we don't write twice at once.
+func (fs *Filesystem) Writefile(p string, r io.Reader) error {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	// If the file does not exist on the system already go ahead and create the pathway
+	// to it and an empty file. We'll then write to it later on after this completes.
+	if stat, err := os.Stat(cleaned); err != nil && os.IsNotExist(err) {
+		if err := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
+			return errors.WithStack(err)
+		}
+
+		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
+			return errors.WithStack(err)
+		}
+	} else if err != nil {
+		return errors.WithStack(err)
+	} else if stat.IsDir() {
+		return errors.New("cannot use a directory as a file for writing")
+	}
+
+	// This will either create the file if it does not already exist, or open and
+	// truncate the existing file.
+	file, err := os.OpenFile(cleaned, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	defer file.Close()
+
+	// Create a new buffered writer that will write to the file we just opened
+	// and stream in the contents from the reader.
+	w := bufio.NewWriter(file)
+
+	buf := make([]byte, 1024)
+	for {
+		n, err := r.Read(buf)
+		if err != nil && err != io.EOF {
+			return errors.WithStack(err)
+		}
+
+		if n == 0 {
+			break
+		}
+
+		if _, err := w.Write(buf[:n]); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+
+	if err := w.Flush(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Finally, chown the file to ensure the permissions don't end up out-of-whack
+	// if we had just created it.
+	return fs.Chown(p)
+}
+
+// Defines the stat struct object.
+type Stat struct {
+	Info     os.FileInfo
+	Mimetype string
+}
+
+func (s *Stat) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Name      string `json:"name"`
+		Created   string `json:"created"`
+		Modified  string `json:"modified"`
+		Mode      string `json:"mode"`
+		Size      int64  `json:"size"`
+		Directory bool   `json:"directory"`
+		File      bool   `json:"file"`
+		Symlink   bool   `json:"symlink"`
+		Mime      string `json:"mime"`
+	}{
+		Name:      s.Info.Name(),
+		Created:   s.CTime().Format(time.RFC3339),
+		Modified:  s.Info.ModTime().Format(time.RFC3339),
+		Mode:      s.Info.Mode().String(),
+		Size:      s.Info.Size(),
+		Directory: s.Info.IsDir(),
+		File:      !s.Info.IsDir(),
+		Symlink:   s.Info.Mode().Perm()&os.ModeSymlink != 0,
+		Mime:      s.Mimetype,
+	})
+}
+
+// Stats a file or folder and returns the base stat object from go along with the
+// MIME data that can be used for editing files.
+func (fs *Filesystem) Stat(p string) (*Stat, error) {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return nil, err
+	}
+
+	return fs.unsafeStat(cleaned)
+}
+
+func (fs *Filesystem) unsafeStat(p string) (*Stat, error) {
+	s, err := os.Stat(p)
+	if err != nil {
+		return nil, err
+	}
+
+	var m = "inode/directory"
+	if !s.IsDir() {
+		m, _, err = mimetype.DetectFile(p)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	st := &Stat{
+		Info:     s,
+		Mimetype: m,
+	}
+
+	return st, nil
+}
+
+// Creates a new directory (name) at a specificied path (p) for the server.
+func (fs *Filesystem) CreateDirectory(name string, p string) error {
+	cleaned, err := fs.SafePath(path.Join(p, name))
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	return os.MkdirAll(cleaned, 0755)
+}
+
+// Moves (or renames) a file or directory.
+func (fs *Filesystem) Rename(from string, to string) error {
+	cleanedFrom, err := fs.SafePath(from)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	cleanedTo, err := fs.SafePath(to)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	return os.Rename(cleanedFrom, cleanedTo)
+}
+
+// Recursively iterates over a directory and sets the permissions on all of the
+// underlying files.
+func (fs *Filesystem) Chown(path string) error {
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	if s, err := os.Stat(cleaned); err != nil {
+		return errors.WithStack(err)
+	} else if !s.IsDir() {
+		return os.Chown(cleaned, fs.Configuration.User.Uid, fs.Configuration.User.Gid)
+	}
+
+	return fs.chownDirectory(cleaned)
+}
+
+// Iterate over all of the files and directories. If it is a file just go ahead and perform
+// the chown operation. Otherwise dig deeper into the directory until we've run out of
+// directories to dig into.
+func (fs *Filesystem) chownDirectory(path string) error {
+	var wg sync.WaitGroup
+
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Chown the directory itself.
+	os.Chown(cleaned, config.Get().System.User.Uid, config.Get().System.User.Gid)
+
+	files, err := ioutil.ReadDir(cleaned)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	for _, f := range files {
+		if f.IsDir() {
+			wg.Add(1)
+
+			go func(p string) {
+				defer wg.Done()
+				fs.chownDirectory(p)
+			}(filepath.Join(cleaned, f.Name()))
+		} else {
+			// Chown the file.
+			os.Chown(filepath.Join(cleaned, f.Name()), fs.Configuration.User.Uid, fs.Configuration.User.Gid)
+		}
+	}
+
+	wg.Wait()
+
+	return nil
+}
+
+// Copies a given file to the same location and appends a suffix to the file to indicate that
+// it has been copied.
+//
+// @todo need to get an exclusive lock on the file.
+func (fs *Filesystem) Copy(p string) error {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	if s, err := os.Stat(cleaned); err != nil {
+		return err
+	} else if s.IsDir() || !s.Mode().IsRegular() {
+		// If this is a directory or not a regular file, just throw a not-exist error
+		// since anything calling this function should understand what that means.
+		return os.ErrNotExist
+	}
+
+	base := filepath.Base(cleaned)
+	relative := strings.TrimSuffix(strings.TrimPrefix(cleaned, fs.Path()), base)
+	extension := filepath.Ext(base)
+	name := strings.TrimSuffix(base, filepath.Ext(base))
+
+	// Begin looping up to 50 times to try and create a unique copy file name. This will take
+	// an input of "file.txt" and generate "file copy.txt". If that name is already taken, it will
+	// then try to write "file copy 2.txt" and so on, until reaching 50 loops. At that point we
+	// won't waste anymore time, just use the current timestamp and make that copy.
+	//
+	// Could probably make this more efficient by checking if there are any files matching the copy
+	// pattern, and trying to find the highest number and then incrementing it by one rather than
+	// looping endlessly.
+	var i int
+	copySuffix := " copy"
+	for i = 0; i < 51; i++ {
+		if i > 0 {
+			copySuffix = " copy " + strconv.Itoa(i)
+		}
+
+		tryName := fmt.Sprintf("%s%s%s", name, copySuffix, extension)
+		tryLocation, err := fs.SafePath(path.Join(relative, tryName))
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		// If the file exists, continue to the next loop, otherwise we're good to start a copy.
+		if _, err := os.Stat(tryLocation); err != nil && !os.IsNotExist(err) {
+			return errors.WithStack(err)
+		} else if os.IsNotExist(err) {
+			break
+		}
+
+		if i == 50 {
+			copySuffix = "." + time.Now().Format(time.RFC3339)
+		}
+	}
+
+	finalPath, err := fs.SafePath(path.Join(relative, fmt.Sprintf("%s%s%s", name, copySuffix, extension)))
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	source, err := os.Open(cleaned)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	defer source.Close()
+
+	dest, err := os.Create(finalPath)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	defer dest.Close()
+
+	if _, err := io.Copy(dest, source); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+// Deletes a file or folder from the system. Prevents the user from accidentally
+// (or maliciously) removing their root server data directory.
+func (fs *Filesystem) Delete(p string) error {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Block any whoopsies.
+	if cleaned == fs.Path() {
+		return errors.New("cannot delete root server directory")
+	}
+
+	return os.RemoveAll(cleaned)
+}
+
+// Lists the contents of a given directory and returns stat information about each
+// file and folder within it.
+func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return nil, err
+	}
+
+	files, err := ioutil.ReadDir(cleaned)
+	if err != nil {
+		return nil, err
+	}
+
+	var wg sync.WaitGroup
+
+	// You must initialize the output of this directory as a non-nil value otherwise
+	// when it is marshaled into a JSON object you'll just get 'null' back, which will
+	// break the panel badly.
+	out := make([]*Stat, len(files))
+
+	// Iterate over all of the files and directories returned and perform an async process
+	// to get the mime-type for them all.
+	for i, file := range files {
+		wg.Add(1)
+
+		go func(idx int, f os.FileInfo) {
+			defer wg.Done()
+
+			var m = "inode/directory"
+			if !f.IsDir() {
+				m, _, _ = mimetype.DetectFile(filepath.Join(cleaned, f.Name()))
+			}
+
+			out[idx] = &Stat{
+				Info:     f,
+				Mimetype: m,
+			}
+		}(i, file)
+	}
+
+	wg.Wait()
+
+	// Sort the output alphabetically to begin with since we've run the output
+	// through an asynchronous process and the order is gonna be very random.
+	sort.SliceStable(out, func(i, j int) bool {
+		if out[i].Info.Name() == out[j].Info.Name() || out[i].Info.Name() > out[j].Info.Name() {
+			return true
+		}
+
+		return false
+	})
+
+	// Then, sort it so that directories are listed first in the output. Everything
+	// will continue to be alphabetized at this point.
+	sort.SliceStable(out, func(i, j int) bool {
+		return out[i].Info.IsDir()
+	})
+
+	return out, nil
+}
+
+// Ensures that the data directory for the server instance exists.
+func (fs *Filesystem) EnsureDataDirectory() error {
+	if _, err := os.Stat(fs.Path()); err != nil && !os.IsNotExist(err) {
+		return errors.WithStack(err)
+	} else if err != nil {
+		// Create the server data directory because it does not currently exist
+		// on the system.
+		if err := os.MkdirAll(fs.Path(), 0700); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+
+	return nil
+}
+
+// Given a directory, iterate through all of the files and folders within it and determine
+// if they should be included in the output based on an array of ignored matches. This uses
+// standard .gitignore formatting to make that determination.
+//
+// If no ignored files are passed through you'll get the entire directory listing.
+func (fs *Filesystem) GetIncludedFiles(dir string, ignored []string) (*backup.IncludedFiles, error) {
+	cleaned, err := fs.SafePath(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	w := fs.NewWalker()
+	ctx := context.Background()
+
+	i, err := ignore.CompileIgnoreLines(ignored...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Walk through all of the files and directories on a server. This callback only returns
+	// files found, and will keep walking deeper and deeper into directories.
+	inc := new(backup.IncludedFiles)
+	if err := w.Walk(cleaned, ctx, func(f os.FileInfo, p string) bool {
+		// Avoid unnecessary parsing if there are no ignored files, nothing will match anyways
+		// so no reason to call the function.
+		if len(ignored) == 0 || !i.MatchesPath(strings.TrimPrefix(p, fs.Path() + "/")) {
+			inc.Push(&f, p)
+		}
+
+		// We can't just abort if the path is technically ignored. It is possible there is a nested
+		// file or folder that should not be excluded, so in this case we need to just keep going
+		// until we get to a final state.
+		return true
+	}); err != nil {
+		return nil, err
+	}
+
+	return inc, nil
+}

server/filesystem/archive.go

@@ -1,316 +0,0 @@
-package filesystem
-
-import (
-	"archive/tar"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"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/pterodactyl/wings/system"
-)
-
-const memory = 4 * 1024
-
-var pool = sync.Pool{
-	New: func() interface{} {
-		b := make([]byte, memory)
-		return b
-	},
-}
-
-// Progress is used to track the progress of any I/O operation that are being
-// performed.
-type Progress struct {
-	// written is the total size of the files that have been written to the writer.
-	written int64
-	// Total is the total size of the archive in bytes.
-	total int64
-	// w .
-	w io.Writer
-}
-
-// NewProgress .
-func NewProgress(total int64) *Progress {
-	return &Progress{total: total}
-}
-
-// Written returns the total number of bytes written.
-// This function should be used when the progress is tracking data being written.
-func (p *Progress) Written() int64 {
-	return atomic.LoadInt64(&p.written)
-}
-
-// Total returns the total size in bytes.
-func (p *Progress) Total() int64 {
-	return atomic.LoadInt64(&p.total)
-}
-
-// Write totals the number of bytes that have been written to the writer.
-func (p *Progress) Write(v []byte) (int, error) {
-	n := len(v)
-	atomic.AddInt64(&p.written, int64(n))
-	if p.w != nil {
-		return p.w.Write(v)
-	}
-	return n, nil
-}
-
-// Progress returns a formatted progress string for the current progress.
-func (p *Progress) Progress(width int) string {
-	current := p.Written()
-	total := p.Total()
-
-	// v = 100 (Progress)
-	// size = 1000 (Content-Length)
-	// p / size = 0.1
-	// * 100 = 10% (Multiply by 100 to get a percentage of the download)
-	// 10% / tickPercentage = (10% / (100 / 25)) (Divide by tick percentage to get the number of ticks)
-	// 2.5 (Number of ticks as a float64)
-	// 2 (convert to an integer)
-
-	// We have to cast these numbers to float in order to get a float result from the division.
-	ticks := ((float64(current) / float64(total)) * 100) / (float64(100) / float64(width))
-	bar := strings.Repeat("=", int(ticks)) + strings.Repeat(" ", width-int(ticks))
-	return "[" + bar + "] " + system.FormatBytes(current) + " / " + system.FormatBytes(total)
-}
-
-type Archive struct {
-	// BasePath is the absolute path to create the archive from where Files and Ignore are
-	// relative to.
-	BasePath string
-
-	// Ignore is a gitignore string (most likely read from a file) of files to ignore
-	// from the archive.
-	Ignore string
-
-	// Files specifies the files to archive, this takes priority over the Ignore option, if
-	// unspecified, all files in the BasePath will be archived unless Ignore is set.
-	Files []string
-
-	// Progress wraps the writer of the archive to pass through the progress tracker.
-	Progress *Progress
-}
-
-// Create creates an archive at dst with all the files defined in the
-// included Files array.
-func (a *Archive) Create(dst string) error {
-	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	// Select a writer based off of the WriteLimit configuration option. If there is no
-	// write limit, use the file as the writer.
-	var writer io.Writer
-	if writeLimit := int64(config.Get().System.Backups.WriteLimit * 1024 * 1024); writeLimit > 0 {
-		// Token bucket with a capacity of "writeLimit" MiB, adding "writeLimit" MiB/s
-		// and then wrap the file writer with the token bucket limiter.
-		writer = ratelimit.Writer(f, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
-	} else {
-		writer = f
-	}
-
-	// Choose which compression level to use based on the compression_level configuration option
-	var compressionLevel int
-	switch config.Get().System.Backups.CompressionLevel {
-	case "none":
-		compressionLevel = pgzip.NoCompression
-	case "best_compression":
-		compressionLevel = pgzip.BestCompression
-	case "best_speed":
-		fallthrough
-	default:
-		compressionLevel = pgzip.BestSpeed
-	}
-
-	// Create a new gzip writer around the file.
-	gw, _ := pgzip.NewWriterLevel(writer, compressionLevel)
-	_ = gw.SetConcurrency(1<<20, 1)
-	defer gw.Close()
-
-	var pw io.Writer
-	if a.Progress != nil {
-		a.Progress.w = gw
-		pw = a.Progress
-	} else {
-		pw = gw
-	}
-
-	// Create a new tar writer around the gzip writer.
-	tw := tar.NewWriter(pw)
-	defer tw.Close()
-
-	// Configure godirwalk.
-	options := &godirwalk.Options{
-		FollowSymbolicLinks: false,
-		Unsorted:            true,
-		Callback:            a.callback(tw),
-	}
-
-	// If we're specifically looking for only certain files, or have requested
-	// that certain files be ignored we'll update the callback function to reflect
-	// that request.
-	if len(a.Files) == 0 && len(a.Ignore) > 0 {
-		i := ignore.CompileIgnoreLines(strings.Split(a.Ignore, "\n")...)
-
-		options.Callback = a.callback(tw, func(_ string, rp string) error {
-			if i.MatchesPath(rp) {
-				return godirwalk.SkipThis
-			}
-
-			return nil
-		})
-	} else if len(a.Files) > 0 {
-		options.Callback = a.withFilesCallback(tw)
-	}
-
-	// Recursively walk the path we are archiving.
-	return godirwalk.Walk(a.BasePath, options)
-}
-
-// Callback function used to determine if a given file should be included in the archive
-// being generated.
-func (a *Archive) callback(tw *tar.Writer, opts ...func(path string, relative string) error) func(path string, de *godirwalk.Dirent) error {
-	return func(path string, de *godirwalk.Dirent) error {
-		// Skip directories because we are walking them recursively.
-		if de.IsDir() {
-			return nil
-		}
-
-		relative := filepath.ToSlash(strings.TrimPrefix(path, a.BasePath+string(filepath.Separator)))
-
-		// Call the additional options passed to this callback function. If any of them return
-		// a non-nil error we will exit immediately.
-		for _, opt := range opts {
-			if err := opt(path, relative); err != nil {
-				return err
-			}
-		}
-
-		// Add the file to the archive, if it is nested in a directory,
-		// the directory will be automatically "created" in the archive.
-		return a.addToArchive(path, relative, tw)
-	}
-}
-
-// Pushes only files defined in the Files key to the final archive.
-func (a *Archive) withFilesCallback(tw *tar.Writer) func(path string, de *godirwalk.Dirent) error {
-	return a.callback(tw, func(p string, rp string) error {
-		for _, f := range a.Files {
-			// If the given doesn't match, or doesn't have the same prefix continue
-			// to the next item in the loop.
-			if p != f && !strings.HasPrefix(strings.TrimSuffix(p, "/")+"/", f) {
-				continue
-			}
-
-			// Once we have a match return a nil value here so that the loop stops and the
-			// call to this function will correctly include the file in the archive. If there
-			// are no matches we'll never make it to this line, and the final error returned
-			// will be the godirwalk.SkipThis error.
-			return nil
-		}
-
-		return godirwalk.SkipThis
-	})
-}
-
-// Adds a given file path to the final archive being created.
-func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
-	// Lstat the file, this will give us the same information as Stat except that it will not
-	// follow a symlink to its target automatically. This is important to avoid including
-	// files that exist outside the server root unintentionally in the backup.
-	s, err := os.Lstat(p)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		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()&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
-		// it doesn't work.
-		target, err = os.Readlink(s.Name())
-		if err != nil {
-			// Ignore the not exist errors specifically, since theres nothing important about that.
-			if !os.IsNotExist(err) {
-				log.WithField("path", rp).WithField("readlink_err", err.Error()).Warn("failed reading symlink for target path; skipping...")
-			}
-			return nil
-		}
-	}
-
-	// Get the tar FileInfoHeader in order to add the file to the archive.
-	header, err := tar.FileInfoHeader(s, filepath.ToSlash(target))
-	if err != nil {
-		return errors.WrapIff(err, "failed to get tar#FileInfoHeader for '%s'", rp)
-	}
-
-	// Fix the header name if the file is not a symlink.
-	if s.Mode()&fs.ModeSymlink == 0 {
-		header.Name = rp
-	}
-
-	// Write the tar FileInfoHeader to the archive.
-	if err := w.WriteHeader(header); err != nil {
-		return errors.WrapIff(err, "failed to write tar#FileInfoHeader for '%s'", rp)
-	}
-
-	// If the size of the file is less than 1 (most likely for symlinks), skip writing the file.
-	if header.Size < 1 {
-		return nil
-	}
-
-	// If the buffer size is larger than the file size, create a smaller buffer to hold the file.
-	var buf []byte
-	if header.Size < memory {
-		buf = make([]byte, header.Size)
-	} else {
-		// Get a fixed-size buffer from the pool to save on allocations.
-		buf = pool.Get().([]byte)
-		defer func() {
-			buf = make([]byte, memory)
-			pool.Put(buf)
-		}()
-	}
-
-	// Open the file.
-	f, err := os.Open(p)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return errors.WrapIff(err, "failed to open '%s' for copying", header.Name)
-	}
-	defer f.Close()
-
-	// Copy the file's contents to the archive using our buffer.
-	if _, err := io.CopyBuffer(w, io.LimitReader(f, header.Size), buf); err != nil {
-		return errors.WrapIff(err, "failed to copy '%s' to archive", header.Name)
-	}
-
-	return nil
-}

server/filesystem/compress.go

@@ -1,200 +0,0 @@
-package filesystem
-
-import (
-	"archive/tar"
-	"archive/zip"
-	"compress/gzip"
-	"fmt"
-	gzip2 "github.com/klauspost/compress/gzip"
-	zip2 "github.com/klauspost/compress/zip"
-	"os"
-	"path"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/mholt/archiver/v3"
-)
-
-// CompressFiles compresses all of the files matching the given paths in the
-// specified directory. This function also supports passing nested paths to only
-// compress certain files and folders when working in a larger directory. This
-// effectively creates a local backup, but rather than ignoring specific files
-// and folders, it takes an allow-list of files and folders.
-//
-// All paths are relative to the dir that is passed in as the first argument,
-// and the compressed file will be placed at that location named
-// `archive-{date}.tar.gz`.
-func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, error) {
-	cleanedRootDir, err := fs.SafePath(dir)
-	if err != nil {
-		return nil, err
-	}
-
-	// Take all of the paths passed in and merge them together with the root directory we've gotten.
-	for i, p := range paths {
-		paths[i] = filepath.Join(cleanedRootDir, p)
-	}
-
-	cleaned, err := fs.ParallelSafePath(paths)
-	if err != nil {
-		return nil, err
-	}
-
-	a := &Archive{BasePath: cleanedRootDir, Files: cleaned}
-	d := path.Join(
-		cleanedRootDir,
-		fmt.Sprintf("archive-%s.tar.gz", strings.ReplaceAll(time.Now().Format(time.RFC3339), ":", "")),
-	)
-
-	if err := a.Create(d); err != nil {
-		return nil, err
-	}
-
-	f, err := os.Stat(d)
-	if err != nil {
-		_ = os.Remove(d)
-		return nil, err
-	}
-
-	if err := fs.HasSpaceFor(f.Size()); err != nil {
-		_ = os.Remove(d)
-		return nil, err
-	}
-
-	fs.addDisk(f.Size())
-
-	return f, nil
-}
-
-// SpaceAvailableForDecompression looks through a given archive and determines
-// if decompressing it would put the server over its allocated disk space limit.
-func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) error {
-	// Don't waste time trying to determine this if we know the server will have the space for
-	// it since there is no limit.
-	if fs.MaxDisk() <= 0 {
-		return nil
-	}
-
-	source, err := fs.SafePath(filepath.Join(dir, file))
-	if err != nil {
-		return err
-	}
-
-	// Get the cached size in a parallel process so that if it is not cached we are not
-	// waiting an unnecessary amount of time on this call.
-	dirSize, err := fs.DiskUsage(false)
-
-	var size int64
-	// Walk over the archive and figure out just how large the final output would be from unarchiving it.
-	err = archiver.Walk(source, func(f archiver.File) error {
-		if atomic.AddInt64(&size, f.Size())+dirSize > fs.MaxDisk() {
-			return newFilesystemError(ErrCodeDiskSpace, nil)
-		}
-		return nil
-	})
-	if err != nil {
-		if IsUnknownArchiveFormatError(err) {
-			return newFilesystemError(ErrCodeUnknownArchive, err)
-		}
-		return err
-	}
-	return err
-}
-
-// DecompressFile will decompress a file in a given directory by using the
-// archiver tool to infer the file type and go from there. This will walk over
-// all of the files within the given archive and ensure that there is not a
-// zip-slip attack being attempted by validating that the final path is within
-// the server data directory.
-func (fs *Filesystem) DecompressFile(dir string, file string) error {
-	source, err := fs.SafePath(filepath.Join(dir, file))
-	if err != nil {
-		return err
-	}
-	// Ensure that the source archive actually exists on the system.
-	if _, err := os.Stat(source); err != nil {
-		return errors.WithStack(err)
-	}
-
-	// Walk all of the files in the archiver file and write them to the disk. If any
-	// directory is encountered it will be skipped since we handle creating any missing
-	// directories automatically when writing files.
-	err = archiver.Walk(source, func(f archiver.File) error {
-		if f.IsDir() {
-			return nil
-		}
-		p := filepath.Join(dir, ExtractNameFromArchive(f))
-		// If it is ignored, just don't do anything with the file and skip over it.
-		if err := fs.IsIgnored(p); err != nil {
-			return nil
-		}
-		if err := fs.Writefile(p, f); err != nil {
-			return wrapError(err, source)
-		}
-		// 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 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 *zip.FileHeader:
-		return s.Name
-	case *zip2.FileHeader:
-		return s.Name
-	case *tar.Header:
-		return s.Name
-	case *gzip.Header:
-		return s.Name
-	case *gzip2.Header:
-		return s.Name
-	default:
-		// At this point we cannot figure out what type of archive this might be so
-		// just try to find the name field in the struct. If it is found return it.
-		field := reflect.Indirect(reflect.ValueOf(sys)).FieldByName("Name")
-		if field.IsValid() {
-			return field.String()
-		}
-		// Fallback to the basename of the file at this point. There is nothing we can really
-		// do to try and figure out what the underlying directory of the file is supposed to
-		// be since it didn't implement a name field.
-		return f.Name()
-	}
-}