metrics: initial commit

.github/FUNDING.yml

@@ -1,2 +1,2 @@
-github: [ DaneEveritt ]
+github: [DaneEveritt]
-custom: [ "https://paypal.me/PterodactylSoftware" ]
+custom: ["https://paypal.me/PterodactylSoftware"]

.github/workflows/build-test.yml

@@ -2,17 +2,17 @@ name: Run Tests
 on:
   push:
     branches:
-      - develop
+      - 'develop'
   pull_request:
     branches:
-      - develop
+      - 'develop'
 jobs:
   build:
     strategy:
       fail-fast: false
       matrix:
         os: [ ubuntu-20.04 ]
-        go: [ '^1.17' ]
+        go: [ '^1.15', '^1.16' ]
         goos: [ linux ]
         goarch: [ amd64, arm64 ]
     runs-on: ${{ matrix.os }}
@@ -60,7 +60,7 @@ jobs:
         run: go test ./...
       - name: Upload Artifact
         uses: actions/upload-artifact@v2
-        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
+        if: ${{ matrix.go == '^1.15' && (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
         with:
           name: wings_${{ matrix.goos }}_${{ matrix.goarch }}
           path: build/wings_${{ matrix.goos }}_${{ matrix.goarch }}

.github/workflows/codeql-analysis.yml

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

.github/workflows/docker.yml

@@ -2,7 +2,8 @@ name: Publish Docker Image
 on:
   push:
     branches:
-      - develop
+      - 'develop'
+
     tags:
       - 'v*'
 jobs:
@@ -43,7 +44,6 @@ jobs:
           build-args: |
             VERSION=${{ steps.build_info.outputs.version_tag }}
           labels: ${{ steps.docker_meta.outputs.labels }}
-          platforms: linux/amd64,linux/arm64
           push: true
           tags: ${{ steps.docker_meta.outputs.tags }}
       - name: Release Development Build
@@ -53,6 +53,5 @@ jobs:
           build-args: |
             VERSION=dev-${{ steps.build_info.outputs.short_sha }}
           labels: ${{ steps.docker_meta.outputs.labels }}
-          platforms: linux/amd64,linux/arm64
           push: ${{ github.event_name != 'pull_request' }}
           tags: ${{ steps.docker_meta.outputs.tags }}

.github/workflows/release.yml

@@ -11,7 +11,7 @@ jobs:
         uses: actions/checkout@v2
       - uses: actions/setup-go@v2
         with:
-          go-version: '^1.17'
+          go-version: '^1.15'
       - name: Build
         env:
           REF: ${{ github.ref }}

CHANGELOG.md

@@ -1,75 +1,5 @@
 # Changelog
 
-## 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.

Dockerfile

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

README.md

@@ -30,11 +30,8 @@ I would like to extend my sincere thanks to the following sponsors for helping f
 | [**Spill Hosting**](https://spillhosting.no/) | Spill Hosting is a Norwegian hosting service, which aims for inexpensive services on quality servers. Premium i9-9900K processors will run your game like a dream. |
 | [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
 | [**HostBend**](https://hostbend.com/) | HostBend offers a variety of solutions for developers, students, and others who have a tight budget but don't want to compromise quality and support. |
-| [**Capitol Hosting Solutions**](https://chs.gg/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
+| [**Capitol Hosting Solutions**](https://capitolsolutions.cloud/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
 | [**ByteAnia**](https://byteania.com/?utm_source=pterodactyl) | ByteAnia offers the best performing and most affordable **Ryzen 5000 Series hosting** on the market for *unbeatable prices*! |
-| [**Aussie Server Hosts**](https://aussieserverhosts.com/) | No frills Australian Owned and operated High Performance Server hosting for some of the most demanding games serving Australia and New Zealand. |
-| [**VibeGAMES**](https://vibegames.net/) | VibeGAMES is a game server provider that specializes in DDOS protection for the games we offer. We have multiple locations in the US, Brazil, France, Germany, Singapore, Australia and South Africa.|
-| [**RocketNode**](https://rocketnode.net) | RocketNode is a VPS and Game Server provider that offers the best performing VPS and Game hosting Solutions at affordable prices! |
 
 ## Documentation
 * [Panel Documentation](https://pterodactyl.io/panel/1.0/getting_started.html)

cmd/configure.go

@@ -14,9 +14,8 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
-	"github.com/spf13/cobra"
-
 	"github.com/pterodactyl/wings/config"
+	"github.com/spf13/cobra"
 )
 
 var (

cmd/diagnostics.go

@@ -21,12 +21,11 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/parsers/kernel"
 	"github.com/docker/docker/pkg/parsers/operatingsystem"
-	"github.com/spf13/cobra"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/loggers/cli"
 	"github.com/pterodactyl/wings/system"
+	"github.com/spf13/cobra"
 )
 
 const DefaultHastebinUrl = "https://ptero.co"

cmd/root.go

@@ -1,10 +1,10 @@
 package cmd
 
 import (
-	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
+	"github.com/pterodactyl/wings/metrics"
 	log2 "log"
 	"net/http"
 	"os"
@@ -21,10 +21,6 @@ import (
 	"github.com/gammazero/workerpool"
 	"github.com/mitchellh/colorstring"
 	"github.com/pkg/profile"
-	"github.com/spf13/cobra"
-	"golang.org/x/crypto/acme"
-	"golang.org/x/crypto/acme/autocert"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/loggers/cli"
@@ -33,6 +29,9 @@ import (
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/sftp"
 	"github.com/pterodactyl/wings/system"
+	"github.com/spf13/cobra"
+	"golang.org/x/crypto/acme"
+	"golang.org/x/crypto/acme/autocert"
 )
 
 var (
@@ -42,7 +41,7 @@ var (
 
 var rootCommand = &cobra.Command{
 	Use:   "wings",
-	Short: "Runs the API server allowing programmatic control of game servers for Pterodactyl Panel.",
+	Short: "Runs the API server allowing programatic control of game servers for Pterodactyl Panel.",
 	PreRun: func(cmd *cobra.Command, args []string) {
 		initConfig()
 		initLogging()
@@ -92,9 +91,9 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 	case "mem":
 		defer profile.Start(profile.MemProfile).Stop()
 	case "alloc":
-		defer profile.Start(profile.MemProfile, profile.MemProfileAllocs).Stop()
+		defer profile.Start(profile.MemProfile, profile.MemProfileAllocs()).Stop()
 	case "heap":
-		defer profile.Start(profile.MemProfile, profile.MemProfileHeap).Stop()
+		defer profile.Start(profile.MemProfile, profile.MemProfileHeap()).Stop()
 	case "routines":
 		defer profile.Start(profile.GoroutineProfile).Stop()
 	case "mutex":
@@ -124,6 +123,11 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
 		return
 	}
+	if err := config.EnableLogRotation(); err != nil {
+		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
+		return
+	}
+
 	log.WithField("username", config.Get().System.User).Info("checking for pterodactyl system user")
 	if err := config.EnsurePterodactylUser(); err != nil {
 		log.WithField("error", err).Fatal("failed to create pterodactyl system user")
@@ -133,10 +137,9 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		"uid":      config.Get().System.User.Uid,
 		"gid":      config.Get().System.User.Gid,
 	}).Info("configured system user successfully")
-	if err := config.EnableLogRotation(); err != nil {
+
-		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
+	done := make(chan bool)
-		return
+	go metrics.Initialize(done)
-	}
 
 	pclient := remote.New(
 		config.Get().PanelLocation,
@@ -161,7 +164,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	// Just for some nice log output.
 	for _, s := range manager.All() {
-		log.WithField("server", s.ID()).Info("finished loading configuration for server")
+		log.WithField("server", s.Id()).Info("finished loading configuration for server")
 	}
 
 	states, err := manager.ReadStates()
@@ -200,27 +203,23 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 			continue
 		}
 
+		if states[s.Id()] == environment.ProcessRunningState {
+			metrics.ServerStatus.WithLabelValues(s.Id()).Set(1)
+		} else {
+			metrics.ServerStatus.WithLabelValues(s.Id()).Set(0)
+		}
+
 		pool.Submit(func() {
 			s.Log().Info("configuring server environment and restoring to previous state")
 			var st string
-			if state, exists := states[s.ID()]; exists {
+			if state, exists := states[s.Id()]; exists {
 				st = state
 			}
 
-			// 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
-			// machine is rebooted. It is much better for us to just have a single failed
-			// server instance than an entire offline node.
-			//
-			// @see https://github.com/pterodactyl/panel/issues/2475
-			// @see https://github.com/pterodactyl/panel/issues/3358
-			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*30)
-			defer cancel()
-
-			r, err := s.Environment.IsRunning(ctx)
 			// We ignore missing containers because we don't want to actually block booting of wings at this
-			// point. If we didn't do this, and you pruned all the images and then started wings you could
+			// point. If we didn't do this and you pruned all of the images and then started wings you could
-			// end up waiting a long period of time for all the images to be re-pulled on Wings boot rather
+			// end up waiting a long period of time for all of 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")
@@ -246,7 +245,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				s.Log().Info("detected server is running, re-attaching to process...")
 
 				s.Environment.SetState(environment.ProcessRunningState)
-				if err := s.Environment.Attach(ctx); err != nil {
+				if err := s.Environment.Attach(); err != nil {
 					s.Log().WithField("error", err).Warn("failed to attach to running server environment")
 				}
 			} else {
@@ -255,20 +254,13 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				// state being tracked.
 				s.Environment.SetState(environment.ProcessOfflineState)
 			}
-
-			if state := s.Environment.State(); state == environment.ProcessStartingState || state == environment.ProcessRunningState {
-				s.Log().Debug("re-syncing server configuration for already running server")
-				if err := s.Sync(); err != nil {
-					s.Log().WithError(err).Error("failed to re-sync server configuration")
-				}
-			}
 		})
 	}
 
-	// Wait until all 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 SFTP and HTTP servers.
 	pool.StopWait()
 	defer func() {
-		// Cancel the context on all the running servers at this point, even though the
+		// Cancel the context on all of the running servers at this point, even though the
 		// program is just shutting down.
 		for _, s := range manager.All() {
 			s.CtxCancel()
@@ -285,7 +277,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	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
+		// Update all of the servers on the Panel to be in a valid state if they're
 		// currently marked as installing/restoring now that Wings is restarted.
 		if err := pclient.ResetServersState(cmd.Context()); err != nil {
 			log.WithField("error", err).Error("failed to reset server states on Panel: some instances may be stuck in an installing/restoring state unexpectedly")
@@ -294,12 +286,12 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(sys.ArchiveDirectory, 0o755); err != nil {
+	if err := os.MkdirAll(sys.ArchiveDirectory, 0755); err != nil {
 		log.WithField("error", err).Error("failed to create archive directory")
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(sys.BackupDirectory, 0o755); err != nil {
+	if err := os.MkdirAll(sys.BackupDirectory, 0755); err != nil {
 		log.WithField("error", err).Error("failed to create backup directory")
 	}
 
@@ -364,10 +356,11 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 	if err := s.ListenAndServe(); err != nil {
 		log.WithField("error", err).Fatal("failed to configure HTTP server")
 	}
+	<-done
 }
 
 // Reads the configuration from the disk and then sets up the global singleton
-// with all the configuration values.
+// with all of the configuration values.
 func initConfig() {
 	if !strings.HasPrefix(configPath, "/") {
 		d, err := os.Getwd()
@@ -392,7 +385,7 @@ func initConfig() {
 // in the code without having to pass around a logger instance.
 func initLogging() {
 	dir := config.Get().System.LogDirectory
-	if err := os.MkdirAll(path.Join(dir, "/install"), 0o700); err != nil {
+	if err := os.MkdirAll(path.Join(dir, "/install"), 0700); err != nil {
 		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
 	}
 	p := filepath.Join(dir, "/wings.log")

config/config.go

@@ -21,9 +21,8 @@ import (
 	"github.com/cobaugh/osrelease"
 	"github.com/creasty/defaults"
 	"github.com/gbrlsnchs/jwt/v3"
-	"gopkg.in/yaml.v2"
-
 	"github.com/pterodactyl/wings/system"
+	"gopkg.in/yaml.v2"
 )
 
 const DefaultLocation = "/etc/pterodactyl/config.yml"
@@ -48,15 +47,13 @@ var DefaultTLSConfig = &tls.Config{
 	CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
 }
 
-var (
+var mu sync.RWMutex
-	mu            sync.RWMutex
+var _config *Configuration
-	_config       *Configuration
+var _jwtAlgo *jwt.HMACSHA
-	_jwtAlgo      *jwt.HMACSHA
+var _debugViaFlag bool
-	_debugViaFlag bool
-)
 
 // Locker specific to writing the configuration to the disk, this happens
-// in areas that might already be locked, so we don't want to crash the process.
+// in areas that might already be locked so we don't want to crash the process.
 var _writeLock sync.Mutex
 
 // SftpConfiguration defines the configuration of the internal SFTP server.
@@ -94,6 +91,12 @@ type ApiConfiguration struct {
 	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
 }
 
+// MetricsConfiguration .
+type MetricsConfiguration struct {
+	// Bind .
+	Bind string `default:":9000" yaml:"bind"`
+}
+
 // RemoteQueryConfiguration defines the configuration settings for remote requests
 // from Wings to the Panel.
 type RemoteQueryConfiguration struct {
@@ -183,9 +186,6 @@ type SystemConfiguration struct {
 }
 
 type CrashDetection struct {
-	// CrashDetectionEnabled sets if crash detection is enabled globally for all servers on this node.
-	CrashDetectionEnabled bool `default:"true" yaml:"enabled"`
-
 	// Determines if Wings should detect a server that stops with a normal exit code of
 	// "0" as being crashed if the process stopped without any Wings interaction. E.g.
 	// the user did not press the stop button, but the process stopped cleanly.
@@ -266,9 +266,10 @@ type Configuration struct {
 	// validate against it.
 	AuthenticationToken string `json:"token" yaml:"token"`
 
-	Api    ApiConfiguration    `json:"api" yaml:"api"`
+	Api     ApiConfiguration     `json:"api" yaml:"api"`
-	System SystemConfiguration `json:"system" yaml:"system"`
+	System  SystemConfiguration  `json:"system" yaml:"system"`
-	Docker DockerConfiguration `json:"docker" yaml:"docker"`
+	Docker  DockerConfiguration  `json:"docker" yaml:"docker"`
+	Metrics MetricsConfiguration `json:"metrics" yaml:"metrics"`
 
 	// Defines internal throttling configurations for server processes to prevent
 	// someone from running an endless loop that spams data to logs.
@@ -380,7 +381,7 @@ func WriteToDisk(c *Configuration) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(c.path, b, 0o600); err != nil {
+	if err := ioutil.WriteFile(c.path, b, 0600); err != nil {
 		return err
 	}
 	return nil
@@ -400,7 +401,7 @@ func EnsurePterodactylUser() error {
 	}
 
 	// Our way of detecting if wings is running inside of Docker.
-	if sysName == "distroless" {
+	if sysName == "busybox" {
 		_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"))
@@ -457,22 +458,9 @@ func FromFile(path string) error {
 		return err
 	}
 	// Replace environment variables within the configuration file with their
-	// values from the host system. This function works almost identically to
+	// values from the host system.
-	// the default os.ExpandEnv function, except it supports escaping dollar
+	b = []byte(os.ExpandEnv(string(b)))
-	// signs in the text if you pass "$$" through.
+	if err := yaml.Unmarshal(b, c); err != nil {
-	//
-	// "some$$foo" -> "some$foo"
-	// "some$foo" -> "some" (or "someVALUE_OF_FOO" if FOO is defined in env)
-	//
-	// @see https://github.com/pterodactyl/panel/issues/3692
-	exp := os.Expand(string(b), func(s string) string {
-		if s == "$" {
-			return s
-		}
-		return os.Getenv(s)
-	})
-
-	if err := yaml.Unmarshal([]byte(exp), c); err != nil {
 		return err
 	}
 	// Store this configuration in the global state.
@@ -488,7 +476,7 @@ func FromFile(path string) error {
 func ConfigureDirectories() error {
 	root := _config.System.RootDirectory
 	log.WithField("path", root).Debug("ensuring root data directory exists")
-	if err := os.MkdirAll(root, 0o700); err != nil {
+	if err := os.MkdirAll(root, 0700); err != nil {
 		return err
 	}
 
@@ -509,17 +497,17 @@ func ConfigureDirectories() error {
 	}
 
 	log.WithField("path", _config.System.Data).Debug("ensuring server data directory exists")
-	if err := os.MkdirAll(_config.System.Data, 0o700); err != nil {
+	if err := os.MkdirAll(_config.System.Data, 0700); err != nil {
 		return err
 	}
 
 	log.WithField("path", _config.System.ArchiveDirectory).Debug("ensuring archive data directory exists")
-	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0o700); err != nil {
+	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0700); err != nil {
 		return err
 	}
 
 	log.WithField("path", _config.System.BackupDirectory).Debug("ensuring backup data directory exists")
-	if err := os.MkdirAll(_config.System.BackupDirectory, 0o700); err != nil {
+	if err := os.MkdirAll(_config.System.BackupDirectory, 0700); err != nil {
 		return err
 	}
 
@@ -557,7 +545,8 @@ func EnableLogRotation() error {
 	}
 	defer f.Close()
 
-	t, err := template.New("logrotate").Parse(`{{.LogDirectory}}/wings.log {
+	t, err := template.New("logrotate").Parse(`
+{{.LogDirectory}}/wings.log {
     size 10M
     compress
     delaycompress
@@ -565,8 +554,9 @@ func EnableLogRotation() error {
     maxage 7
     missingok
     notifempty
+    create 0640 {{.User.Uid}} {{.User.Gid}}
     postrotate
-        /usr/bin/systemctl kill -s HUP wings.service >/dev/null 2>&1 || true
+        killall -SIGHUP wings
     endscript
 }`)
 	if err != nil {

config/config_docker.go

@@ -60,7 +60,7 @@ type DockerConfiguration struct {
 	// 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"`
+	ContainerPidLimit int64 `default:"256" json:"container_pid_limit" yaml:"container_pid_limit"`
 
 	// InstallLimits defines the limits on the installer containers that prevents a server's
 	// installation process from unintentionally consuming more resources than expected. This

environment/allocations.go

@@ -5,7 +5,6 @@ import (
 	"strconv"
 
 	"github.com/docker/go-connections/nat"
-
 	"github.com/pterodactyl/wings/config"
 )
 
@@ -20,7 +19,7 @@ type Allocations struct {
 		Port int    `json:"port"`
 	} `json:"default"`
 
-	// Mappings contains all the ports that should be assigned to a given server
+	// Mappings contains all of the ports that should be assigned to a given server
 	// attached to the IP they correspond to.
 	Mappings map[string][]int `json:"mappings"`
 }
@@ -63,7 +62,7 @@ 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
+	// Loop over all of 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 {

environment/docker.go

@@ -10,7 +10,6 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/config"
 )
 

environment/docker/container.go

@@ -17,7 +17,6 @@ import (
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/daemon/logger/jsonfilelog"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/system"
@@ -45,7 +44,7 @@ func (nw noopWriter) Write(b []byte) (int, error) {
 // Calling this function will poll resources for the container in the background
 // until the provided context is canceled by the caller. Failure to cancel said
 // context will cause background memory leaks as the goroutine will not exit.
-func (e *Environment) Attach(ctx context.Context) error {
+func (e *Environment) Attach() error {
 	if e.IsAttached() {
 		return nil
 	}
@@ -62,17 +61,14 @@ func (e *Environment) Attach(ctx context.Context) error {
 	}
 
 	// Set the stream again with the container.
-	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
+	if st, err := e.client.ContainerAttach(context.Background(), 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
+		ctx, cancel := context.WithCancel(context.Background())
-		// 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() {
@@ -81,7 +77,7 @@ func (e *Environment) Attach(ctx context.Context) error {
 		}()
 
 		go func() {
-			if err := e.pollResources(pollCtx); err != nil {
+			if err := e.pollResources(ctx); err != nil {
 				if !errors.Is(err, context.Canceled) {
 					e.log().WithField("error", err).Error("error during environment resource polling")
 				} else {
@@ -143,7 +139,7 @@ func (e *Environment) InSituUpdate() error {
 	return nil
 }
 
-// Create creates a new container for the server using all the data that is
+// Create creates a new container for the server using all of the data that is
 // currently available for it. If the container already exists it will be
 // returned.
 func (e *Environment) Create() error {
@@ -196,7 +192,7 @@ func (e *Environment) Create() error {
 		PortBindings: a.DockerBindings(),
 
 		// Configure the mounts for this container. First mount the server data directory
-		// into the container as an r/w bind.
+		// into the container as a r/w bind.
 		Mounts: e.convertMounts(),
 
 		// Configure the /tmp folder mapping in containers. This is necessary for some
@@ -344,9 +340,11 @@ func (e *Environment) scanOutput(reader io.ReadCloser) {
 
 	events := e.Events()
 
-	if err := system.ScanReader(reader, func(line string) {
+	err := system.ScanReader(reader, func(line string) {
 		events.Publish(environment.ConsoleOutputEvent, line)
-	}); err != nil && err != io.EOF {
+	})
+
+	if err != nil && err != io.EOF {
 		log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
 		return
 	}
@@ -356,7 +354,7 @@ func (e *Environment) scanOutput(reader io.ReadCloser) {
 		return
 	}
 
-	// Close the current reader before starting a new one, the defer will still run,
+	// Close the current reader before starting a new one, the defer will still run
 	// but it will do nothing if we already closed the stream.
 	_ = reader.Close()
 
@@ -374,7 +372,7 @@ type imagePullStatus struct {
 // 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
+// late, and we don't need to block all of the servers from booting just because
 // of that. I'd imagine in a lot of cases an outage shouldn't affect users too
 // badly. It'll at least keep existing servers working correctly if anything.
 func (e *Environment) ensureImageExists(image string) error {

environment/docker/environment.go

@@ -3,6 +3,7 @@ package docker
 import (
 	"context"
 	"fmt"
+	"github.com/pterodactyl/wings/metrics"
 	"io"
 	"sync"
 
@@ -10,7 +11,6 @@ import (
 	"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"
@@ -22,7 +22,7 @@ type Metadata struct {
 	Stop  remote.ProcessStopConfiguration
 }
 
-// Ensure that the Docker environment is always implementing all the methods
+// Ensure that the Docker environment is always implementing all of the methods
 // from the base environment interface.
 var _ environment.ProcessEnvironment = (*Environment)(nil)
 
@@ -128,20 +128,20 @@ func (e *Environment) Exists() (bool, error) {
 	return true, nil
 }
 
-// IsRunning determines if the server's docker container is currently running.
+// Determines if the server's docker container is currently running. If there is no container
-// If there is no container present, an error will be raised (since this
+// present, an error will be raised (since this shouldn't be a case that ever happens under
-// shouldn't be a case that ever happens under correctly developed
+// correctly developed circumstances).
-// circumstances).
 //
-// You can confirm if the instance wasn't found by using client.IsErrNotFound
+// You can confirm if the instance wasn't found by using client.IsErrNotFound from the Docker
-// from the Docker API.
+// API.
 //
 // @see docker/client/errors.go
-func (e *Environment) IsRunning(ctx context.Context) (bool, error) {
+func (e *Environment) IsRunning() (bool, error) {
-	c, err := e.client.ContainerInspect(ctx, e.Id)
+	c, err := e.client.ContainerInspect(context.Background(), e.Id)
 	if err != nil {
 		return false, err
 	}
+
 	return c.State.Running, nil
 }
 
@@ -213,5 +213,15 @@ func (e *Environment) SetState(state string) {
 		// If the state changed make sure we update the internal tracking to note that.
 		e.st.Store(state)
 		e.Events().Publish(environment.StateChangeEvent, state)
+
+		if state == environment.ProcessRunningState || state == environment.ProcessOfflineState {
+			val := 0
+			if state == environment.ProcessRunningState {
+				val = 1
+			} else {
+				metrics.ResetServer(e.Id)
+			}
+			metrics.ServerStatus.WithLabelValues(e.Id).Set(float64(val))
+		}
 	}
 }

environment/docker/power.go

@@ -12,22 +12,20 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 )
 
-// OnBeforeStart run before the container starts and get the process
+// Run before the container starts and get the process configuration from the Panel.
-// configuration from the Panel. This is important since we use this to check
+// This is important since we use this to check configuration files as well as ensure
-// configuration files as well as ensure we always have the latest version of
+// we always have the latest version of an egg available for server processes.
-// an egg available for server processes.
 //
-// This process will also confirm that the server environment exists and is in
+// This process will also confirm that the server environment exists and is in a bootable
-// a bootable state. This ensures that unexpected container deletion while Wings
+// state. This ensures that unexpected container deletion while Wings is running does
-// is running does not result in the server becoming un-bootable.
+// not result in the server becoming un-bootable.
-func (e *Environment) OnBeforeStart(ctx context.Context) error {
+func (e *Environment) OnBeforeStart() error {
 	// Always destroy and re-create the server container to ensure that synced data from the Panel is used.
-	if err := e.client.ContainerRemove(ctx, e.Id, types.ContainerRemoveOptions{RemoveVolumes: true}); err != nil {
+	if err := e.client.ContainerRemove(context.Background(), 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")
 		}
@@ -47,10 +45,10 @@ func (e *Environment) OnBeforeStart(ctx context.Context) error {
 	return nil
 }
 
-// Start will start the server environment and begins piping output to the event
+// Starts the server environment and begins piping output to the event listeners for the
-// listeners for the console. If a container does not exist, or needs to be
+// console. If a container does not exist, or needs to be rebuilt that will happen in the
-// rebuilt that will happen in the call to OnBeforeStart().
+// call to OnBeforeStart().
-func (e *Environment) Start(ctx context.Context) error {
+func (e *Environment) Start() error {
 	sawError := false
 
 	// If sawError is set to true there was an error somewhere in the pipeline that
@@ -66,7 +64,7 @@ func (e *Environment) Start(ctx context.Context) error {
 		}
 	}()
 
-	if c, err := e.client.ContainerInspect(ctx, e.Id); err != nil {
+	if c, err := e.client.ContainerInspect(context.Background(), e.Id); 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.
@@ -80,10 +78,10 @@ func (e *Environment) Start(ctx context.Context) error {
 		if c.State.Running {
 			e.SetState(environment.ProcessRunningState)
 
-			return e.Attach(ctx)
+			return e.Attach()
 		}
 
-		// Truncate the log file, so we don't end up outputting a bunch of useless log information
+		// Truncate the log file so we don't end up outputting a bunch of useless log information
 		// to the websocket and whatnot. Check first that the path and file exist before trying
 		// to truncate them.
 		if _, err := os.Stat(c.LogPath); err == nil {
@@ -102,23 +100,21 @@ func (e *Environment) Start(ctx context.Context) error {
 	// Run the before start function and wait for it to finish. This will validate that the container
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
-	if err := e.OnBeforeStart(ctx); err != nil {
+	if err := e.OnBeforeStart(); err != nil {
 		return errors.WithStackIf(err)
 	}
 
-	// If we cannot start & attach to the container in 30 seconds something has gone
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
-	// quite sideways and we should stop trying to avoid a hanging situation.
-	actx, cancel := context.WithTimeout(ctx, time.Second*30)
 	defer cancel()
 
-	if err := e.client.ContainerStart(actx, e.Id, types.ContainerStartOptions{}); err != nil {
+	if err := e.client.ContainerStart(ctx, e.Id, types.ContainerStartOptions{}); err != nil {
 		return errors.WrapIf(err, "environment/docker: failed to start container")
 	}
 
 	// No errors, good to continue through.
 	sawError = false
 
-	return e.Attach(actx)
+	return e.Attach()
 }
 
 // Stop stops the container that the server is running in. This will allow up to
@@ -246,7 +242,7 @@ func (e *Environment) Terminate(signal os.Signal) error {
 	}
 
 	if !c.State.Running {
-		// If the container is not running, but we're not already in a stopped state go ahead
+		// If the container is not running but we're not already in a stopped state go ahead
 		// and update things to indicate we should be completely stopped now. Set to stopping
 		// first so crash detection is not triggered.
 		if e.st.Load() != environment.ProcessOfflineState {

environment/docker/stats.go

@@ -2,34 +2,15 @@ package docker
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"encoding/json"
+	"github.com/docker/docker/api/types"
+	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/metrics"
 	"io"
 	"math"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/docker/docker/api/types"
-
-	"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.client.ContainerInspect(ctx, e.Id)
-	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 {
@@ -46,11 +27,6 @@ func (e *Environment) pollResources(ctx context.Context) error {
 	}
 	defer stats.Body.Close()
 
-	uptime, err := e.Uptime(ctx)
-	if err != nil {
-		e.log().WithField("error", err).Warn("failed to calculate container uptime")
-	}
-
 	dec := json.NewDecoder(stats.Body)
 	for {
 		select {
@@ -73,12 +49,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				return nil
 			}
 
-			if !v.PreRead.IsZero() {
-				uptime = uptime + v.Read.Sub(v.PreRead).Milliseconds()
-			}
-
 			st := environment.Stats{
-				Uptime:      uptime,
 				Memory:      calculateDockerMemory(v.MemoryStats),
 				MemoryLimit: v.MemoryStats.Limit,
 				CpuAbsolute: calculateDockerAbsoluteCpu(v.PreCPUStats, v.CPUStats),
@@ -90,6 +61,11 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				st.Network.TxBytes += nw.TxBytes
 			}
 
+			metrics.ServerCPU.WithLabelValues(e.Id).Set(st.CpuAbsolute)
+			metrics.ServerMemory.WithLabelValues(e.Id).Set(float64(st.Memory))
+			metrics.ServerNetworkRx.WithLabelValues(e.Id).Set(float64(st.Network.RxBytes))
+			metrics.ServerNetworkTx.WithLabelValues(e.Id).Set(float64(st.Network.TxBytes))
+
 			if b, err := json.Marshal(st); err != nil {
 				e.log().WithField("error", err).Warn("error while marshaling stats object for environment")
 			} else {
@@ -103,8 +79,9 @@ func (e *Environment) pollResources(ctx context.Context) error {
 // value which can be rather confusing to people trying to compare panel usage to
 // their stats output.
 //
-// This math is from their CLI repository in order to show the same values to avoid people
+// This math is straight up lifted from their CLI repository in order to show the same
-// bothering me about it. It should also reflect a slightly more correct memory value anyways.
+// values to avoid people bothering me about it. It should also reflect a slightly more
+// correct memory value anyways.
 //
 // @see https://github.com/docker/cli/blob/96e1d1d6/cli/command/container/stats_helpers.go#L227-L249
 func calculateDockerMemory(stats types.MemoryStats) uint64 {

environment/environment.go

@@ -1,7 +1,6 @@
 package environment
 
 import (
-	"context"
 	"os"
 
 	"github.com/pterodactyl/wings/events"
@@ -42,9 +41,9 @@ type ProcessEnvironment interface {
 	// 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
+	// Determines if the environment is currently active and running a server process
-	// a server process for this specific server instance.
+	// for this specific server instance.
-	IsRunning(ctx context.Context) (bool, error)
+	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
@@ -53,11 +52,11 @@ type ProcessEnvironment interface {
 
 	// Runs before the environment is started. If an error is returned starting will
 	// not occur, otherwise proceeds as normal.
-	OnBeforeStart(ctx context.Context) error
+	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(ctx context.Context) error
+	Start() error
 
 	// Stops a server instance. If the server is already stopped an error should
 	// not be returned.
@@ -85,10 +84,10 @@ type ProcessEnvironment interface {
 	// server.
 	Create() error
 
-	// Attach attaches to the server console environment and allows piping the output
+	// Attaches to the server console environment and allows piping the output to a
-	// to a websocket or other internal tool to monitor output. Also allows you to later
+	// 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
+	Attach() error
 
 	// Sends the provided command to the running server instance.
 	SendCommand(string) error
@@ -104,8 +103,4 @@ type ProcessEnvironment interface {
 	// handle this itself, but there are some scenarios where it is helpful for the server
 	// to update the state externally (e.g. starting -> started).
 	SetState(string)
-
-	// Uptime returns the current environment uptime in milliseconds. This is
-	// the time that has passed since it was last started.
-	Uptime(ctx context.Context) (int64, error)
 }

environment/settings.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types/container"
-
 	"github.com/pterodactyl/wings/config"
 )
 
@@ -26,7 +25,7 @@ type Mount struct {
 	// 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
+	// Whether or not 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"`
 }

environment/stats.go

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

events/events.go

@@ -30,7 +30,7 @@ func (e *EventBus) Publish(topic string, data string) {
 	// 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 send the event using the standard listener
+	// 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)
@@ -43,7 +43,7 @@ func (e *EventBus) Publish(topic string, data string) {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
 
-	// Acquire a read lock and loop over all the channels registered for the topic. This
+	// Acquire a read lock and loop over all of the channels registered for the topic. This
 	// avoids a panic crash if the process tries to unregister the channel while this routine
 	// is running.
 	if cp, ok := e.pools[t]; ok {
@@ -65,7 +65,7 @@ func (e *EventBus) Publish(topic string, data string) {
 	}
 }
 
-// PublishJson publishes a JSON message to a given topic.
+// Publishes a JSON message to a given topic.
 func (e *EventBus) PublishJson(topic string, data interface{}) error {
 	b, err := json.Marshal(data)
 	if err != nil {
@@ -77,7 +77,7 @@ func (e *EventBus) PublishJson(topic string, data interface{}) error {
 	return nil
 }
 
-// On adds a callback function that will be executed each time one of the events using the topic
+// Register a callback function that will be executed each time one of the events using the topic
 // name is called.
 func (e *EventBus) On(topic string, callback *func(Event)) {
 	e.mu.Lock()
@@ -97,7 +97,7 @@ func (e *EventBus) On(topic string, callback *func(Event)) {
 	e.pools[topic].Add(callback)
 }
 
-// Off removes an event listener from the bus.
+// Removes an event listener from the bus.
 func (e *EventBus) Off(topic string, callback *func(Event)) {
 	e.mu.Lock()
 	defer e.mu.Unlock()
@@ -107,7 +107,7 @@ func (e *EventBus) Off(topic string, callback *func(Event)) {
 	}
 }
 
-// Destroy removes all the event listeners that have been registered for any topic. Also stops the worker
+// Removes all of the event listeners that have been registered for any topic. Also stops the worker
 // pool to close that routine.
 func (e *EventBus) Destroy() {
 	e.mu.Lock()

go.mod

@@ -1,71 +1,82 @@
 module github.com/pterodactyl/wings
 
-go 1.16
+go 1.14
 
 require (
 	emperror.dev/errors v0.8.0
-	github.com/AlecAivazis/survey/v2 v2.2.15
+	github.com/AlecAivazis/survey/v2 v2.2.7
-	github.com/Jeffail/gabs/v2 v2.6.1
+	github.com/Jeffail/gabs/v2 v2.6.0
-	github.com/Microsoft/go-winio v0.5.0 // indirect
+	github.com/Microsoft/go-winio v0.4.16 // indirect
-	github.com/Microsoft/hcsshim v0.8.20 // indirect
+	github.com/Microsoft/hcsshim v0.8.14 // indirect
 	github.com/NYTimes/logrotate v1.0.0
-	github.com/andybalholm/brotli v1.0.3 // indirect
+	github.com/andybalholm/brotli v1.0.1 // indirect
 	github.com/apex/log v1.9.0
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
+	github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef
 	github.com/beevik/etree v1.1.0
-	github.com/buger/jsonparser v1.1.1
+	github.com/buger/jsonparser v1.1.0
-	github.com/cenkalti/backoff/v4 v4.1.1
+	github.com/cenkalti/backoff/v4 v4.1.0
 	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
-	github.com/containerd/containerd v1.5.5 // indirect
+	github.com/containerd/containerd v1.4.3 // indirect
+	github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c // indirect
 	github.com/creasty/defaults v1.5.1
-	github.com/docker/docker v20.10.7+incompatible
+	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/docker v20.10.1+incompatible
 	github.com/docker/go-connections v0.4.0
-	github.com/fatih/color v1.12.0
+	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/fatih/color v1.10.0
 	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
-	github.com/gabriel-vasile/mimetype v1.3.1
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
-	github.com/gammazero/workerpool v1.1.2
+	github.com/gabriel-vasile/mimetype v1.1.2
-	github.com/gbrlsnchs/jwt/v3 v3.0.1
+	github.com/gammazero/deque v0.0.0-20201010052221-3932da5530cc // indirect
-	github.com/gin-gonic/gin v1.7.2
+	github.com/gammazero/workerpool v1.1.1
-	github.com/go-playground/validator/v10 v10.8.0 // indirect
+	github.com/gbrlsnchs/jwt/v3 v3.0.0
-	github.com/golang/snappy v0.0.4 // indirect
+	github.com/gin-gonic/gin v1.6.3
-	github.com/google/uuid v1.3.0
+	github.com/go-playground/validator/v10 v10.4.1 // indirect
+	github.com/golang/snappy v0.0.2 // indirect
+	github.com/google/go-cmp v0.5.2 // indirect
+	github.com/google/uuid v1.1.2
 	github.com/gorilla/mux v1.7.4 // indirect
 	github.com/gorilla/websocket v1.4.2
-	github.com/iancoleman/strcase v0.2.0
+	github.com/iancoleman/strcase v0.1.2
-	github.com/icza/dyno v0.0.0-20210726202311-f1bafe5d9996
+	github.com/icza/dyno v0.0.0-20200205103839-49cb13720835
+	github.com/imdario/mergo v0.3.9
 	github.com/juju/ratelimit v1.0.1
 	github.com/karrick/godirwalk v1.16.1
-	github.com/klauspost/compress v1.13.2 // indirect
+	github.com/klauspost/compress v1.11.4 // indirect
 	github.com/klauspost/pgzip v1.2.5
-	github.com/magefile/mage v1.11.0 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/magiconair/properties v1.8.5
+	github.com/magefile/mage v1.10.0 // indirect
+	github.com/magiconair/properties v1.8.4
 	github.com/mattn/go-colorable v0.1.8
-	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/mholt/archiver/v3 v3.5.0
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
-	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
+	github.com/moby/term v0.0.0-20201216013528-df9cb8a40635 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/nwaples/rardecode v1.1.1 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.0.1 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pierrec/lz4/v4 v4.1.8 // indirect
+	github.com/pierrec/lz4/v4 v4.1.2 // indirect
-	github.com/pkg/profile v1.6.0
+	github.com/pkg/profile v1.5.0
-	github.com/pkg/sftp v1.13.2
+	github.com/pkg/sftp v1.12.0
-	github.com/prometheus/common v0.30.0 // indirect
+	github.com/prometheus/client_golang v1.9.0 // indirect
-	github.com/prometheus/procfs v0.7.1 // indirect
 	github.com/sabhiram/go-gitignore v0.0.0-20201211210132-54b8a0bf510f
-	github.com/spf13/cobra v1.2.1
+	github.com/sirupsen/logrus v1.7.0 // indirect
-	github.com/stretchr/testify v1.7.0
+	github.com/spf13/cobra v1.1.1
-	github.com/ulikunitz/xz v0.5.10 // indirect
+	github.com/stretchr/testify v1.6.1
-	go.uber.org/atomic v1.9.0 // indirect
+	github.com/ugorji/go v1.2.2 // indirect
-	go.uber.org/multierr v1.7.0 // indirect
+	github.com/ulikunitz/xz v0.5.9 // indirect
-	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97
+	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad
-	golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985 // indirect
+	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
+	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
+	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
-	google.golang.org/genproto v0.0.0-20210729151513-df9385d47c1b // indirect
+	golang.org/x/text v0.3.4 // indirect
+	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d // indirect
+	google.golang.org/grpc v1.34.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
 	gopkg.in/ini.v1 v1.62.0
 	gopkg.in/yaml.v2 v2.4.0

installer/installer.go

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

loggers/cli/cli.go

@@ -1,18 +1,17 @@
 package cli
 
 import (
+	"emperror.dev/errors"
 	"fmt"
+	"github.com/apex/log"
+	"github.com/apex/log/handlers/cli"
+	color2 "github.com/fatih/color"
+	"github.com/mattn/go-colorable"
 	"io"
 	"os"
 	"strings"
 	"sync"
 	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/apex/log/handlers/cli"
-	color2 "github.com/fatih/color"
-	"github.com/mattn/go-colorable"
 )
 
 var Default = New(os.Stderr, true)

metrics/metrics.go

@@ -0,0 +1,107 @@
+package metrics
+
+import (
+	"github.com/apex/log"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/pterodactyl/wings/config"
+	"net/http"
+	"time"
+)
+
+type Metrics struct {
+	handler http.Handler
+}
+
+const (
+	namespace = "pterodactyl"
+	subsystem = "wings"
+)
+
+var (
+	bootTimeSeconds = promauto.NewGauge(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "boot_time_seconds",
+		Help:      "Boot time of this instance since epoch (1970)",
+	})
+	timeSeconds = promauto.NewGauge(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "time_seconds",
+		Help:      "System time in seconds since epoch (1970)",
+	})
+
+	ServerStatus = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "server_status",
+	}, []string{"server_id"})
+	ServerCPU = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "server_cpu",
+	}, []string{"server_id"})
+	ServerMemory = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "server_memory",
+	}, []string{"server_id"})
+	ServerNetworkRx = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "server_network_rx",
+	}, []string{"server_id"})
+	ServerNetworkTx = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "server_network_tx",
+	}, []string{"server_id"})
+
+	HTTPRequestsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      "http_requests_total",
+	}, []string{"method", "route_path", "raw_path", "raw_query", "code"})
+)
+
+func Initialize(done chan bool) {
+	bootTimeSeconds.Set(float64(time.Now().UnixNano()) / 1e9)
+	ticker := time.NewTicker(time.Second)
+	go func() {
+		defer ticker.Stop()
+		for {
+			select {
+			case <-done:
+				// Received a "signal" on the done channel.
+				log.Debug("metrics: done")
+				return
+			case t := <-ticker.C:
+				// Update the current time.
+				timeSeconds.Set(float64(t.UnixNano()) / 1e9)
+			}
+		}
+	}()
+	if err := http.ListenAndServe(config.Get().Metrics.Bind, promhttp.Handler()); err != nil && err != http.ErrServerClosed {
+		log.WithField("error", err).Error("failed to start metrics server")
+	}
+}
+
+// DeleteServer will remove any existing labels from being scraped by Prometheus.
+// Any previously scraped data will still be persisted by Prometheus.
+func DeleteServer(sID string) {
+	ServerStatus.DeleteLabelValues(sID)
+	ServerCPU.DeleteLabelValues(sID)
+	ServerMemory.DeleteLabelValues(sID)
+	ServerNetworkRx.DeleteLabelValues(sID)
+	ServerNetworkTx.DeleteLabelValues(sID)
+}
+
+// ResetServer will reset a server's metrics to their default values except the status.
+func ResetServer(sID string) {
+	ServerCPU.WithLabelValues(sID).Set(0)
+	ServerMemory.WithLabelValues(sID).Set(0)
+	ServerNetworkRx.WithLabelValues(sID).Set(0)
+	ServerNetworkTx.WithLabelValues(sID).Set(0)
+}

parser/helpers.go

@@ -48,19 +48,19 @@ func readFileBytes(path string) ([]byte, error) {
 }
 
 // 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
@@ -97,21 +97,22 @@ func (f *ConfigurationFile) IterateOverJson(data []byte) (*gabs.Container, error
 			// If the child is a null value, nothing will happen. Seems reasonable as of the
 			// time this code is being written.
 			for _, child := range parsed.Path(strings.Trim(parts[0], ".")).Children() {
-				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), value); err != nil {
+				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), []byte(value)); err != nil {
 					if errors.Is(err, gabs.ErrNotFound) {
 						continue
 					}
+
 					return nil, errors.WithMessage(err, "failed to set config value of array child")
 				}
 			}
-			continue
+		} else {
-		}
+			if err = v.SetAtPathway(parsed, v.Match, []byte(value)); err != nil {
+				if errors.Is(err, gabs.ErrNotFound) {
+					continue
+				}
 
-		if err := v.SetAtPathway(parsed, v.Match, value); err != nil {
+				return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
-			if errors.Is(err, gabs.ErrNotFound) {
-				continue
 			}
-			return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
 		}
 	}
 
@@ -131,10 +132,13 @@ 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)
+		// Only update the value if the pathway actually exists in the configuration, otherwise
+		// do nothing.
+		if c.ExistsP(path) {
+			_, err = c.SetP(value, path)
+		}
+
 		return err
 	}
 
@@ -192,34 +196,32 @@ func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
 
 // Sets the value at a specific pathway, but checks if we were looking for a specific
 // value or not before doing it.
-func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value string) error {
+func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value []byte) error {
 	if cfr.IfValue == "" {
 		return setValueAtPath(c, path, cfr.getKeyValue(value))
 	}
 
-	// Check if we are replacing instead of overwriting.
+	// If this is a regex based matching, we need to get a little more creative since
-	if strings.HasPrefix(cfr.IfValue, "regex:") {
+	// we're only going to replacing part of the string, and not the whole thing.
-		// Doing a regex replacement requires an existing value.
+	if c.ExistsP(path) && strings.HasPrefix(cfr.IfValue, "regex:") {
-		// TODO: Do we try passing an empty string to the regex?
+		// We're doing some regex here.
-		if c.ExistsP(path) {
-			return gabs.ErrNotFound
-		}
-
 		r, err := regexp.Compile(strings.TrimPrefix(cfr.IfValue, "regex:"))
 		if err != nil {
 			log.WithFields(log.Fields{"if_value": strings.TrimPrefix(cfr.IfValue, "regex:"), "error": err}).
 				Warn("configuration if_value using invalid regexp, cannot perform replacement")
+
 			return nil
 		}
 
-		v := strings.Trim(c.Path(path).String(), "\"")
+		// If the path exists and there is a regex match, go ahead and attempt the replacement
+		// using the value we got from the key. This will only replace the one match.
+		v := strings.Trim(string(c.Path(path).Bytes()), "\"")
 		if r.Match([]byte(v)) {
-			return setValueAtPath(c, path, r.ReplaceAllString(v, value))
+			return setValueAtPath(c, path, r.ReplaceAllString(v, string(value)))
 		}
-		return nil
-	}
 
-	if c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue)) {
+		return nil
+	} else if !c.ExistsP(path) || (c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue))) {
 		return nil
 	}
 

parser/parser.go

@@ -15,10 +15,9 @@ import (
 	"github.com/buger/jsonparser"
 	"github.com/icza/dyno"
 	"github.com/magiconair/properties"
+	"github.com/pterodactyl/wings/config"
 	"gopkg.in/ini.v1"
 	"gopkg.in/yaml.v2"
-
-	"github.com/pterodactyl/wings/config"
 )
 
 // The file parsing options that are available for a server configuration file.
@@ -57,22 +56,17 @@ func (cv *ReplaceValue) Type() jsonparser.ValueType {
 // handle casting the UTF-8 sequence into the expected value, switching something
 // like "\u00a7Foo" into "§Foo".
 func (cv *ReplaceValue) String() string {
-	switch cv.Type() {
+	if cv.Type() != jsonparser.String {
-	case jsonparser.String:
+		if cv.Type() == jsonparser.Null {
-		str, err := jsonparser.ParseString(cv.value)
+			return "<nil>"
-		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>"
 	}
+	str, err := jsonparser.ParseString(cv.value)
+	if err != nil {
+		panic(errors.Wrap(err, "parser: could not parse value"))
+	}
+	return str
 }
 
 type ConfigurationParser string

remote/http.go

@@ -15,7 +15,6 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/cenkalti/backoff/v4"
-
 	"github.com/pterodactyl/wings/system"
 )
 
@@ -119,7 +118,7 @@ func (c *client) requestOnce(ctx context.Context, method, path string, body io.R
 	return &Response{res}, err
 }
 
-// request executes an HTTP request against the Panel API. If there is an error
+// request executes a 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
@@ -171,7 +170,7 @@ func (c *client) request(ctx context.Context, method, path string, body io.Reade
 // 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
+// time that has ellapsed 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

remote/http_test.go

@@ -12,11 +12,11 @@ import (
 func createTestClient(h http.HandlerFunc) (*client, *httptest.Server) {
 	s := httptest.NewServer(h)
 	c := &client{
-		httpClient:  s.Client(),
+		httpClient: s.Client(),
-		baseUrl:     s.URL,
+		baseUrl:    s.URL,
 		maxAttempts: 1,
-		tokenId:     "testid",
+		tokenId:  "testid",
-		token:       "testtoken",
+		token:    "testtoken",
 	}
 	return c, s
 }

remote/types.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	"github.com/apex/log"
-
 	"github.com/pterodactyl/wings/parser"
 )
 
@@ -33,7 +32,7 @@ type Pagination struct {
 
 // ServerConfigurationResponse holds the server configuration data returned from
 // the Panel. When a server process is started, Wings communicates with the
-// Panel to fetch the latest build information as well as get all the details
+// 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

router/downloader/downloader.go

@@ -2,26 +2,26 @@ package downloader
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"encoding/json"
 	"fmt"
+	"github.com/google/uuid"
+	"github.com/pterodactyl/wings/server"
 	"io"
 	"net"
 	"net/http"
 	"net/url"
 	"path/filepath"
+	"regexp"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
-
-	"emperror.dev/errors"
-	"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
+	// Disallow any redirect on a HTTP call. This is a security requirement: do not modify
 	// this logic without first ensuring that the new target location IS NOT within the current
 	// instance's local network.
 	//
@@ -36,14 +36,18 @@ var client = &http.Client{
 }
 
 var instance = &Downloader{
-	// Tracks all the active downloads.
+	// Tracks all of the active downloads.
 	downloadCache: make(map[string]*Download),
-	// Tracks all the downloads active for a given server instance. This is
+	// Tracks all of the downloads active for a given server instance. This is
 	// primarily used to make things quicker and keep the code a little more
 	// legible throughout here.
 	serverCache: make(map[string][]string),
 }
 
+// Regex to match the end of an IPv4/IPv6 address. This allows the port to be removed
+// so that we are just working with the raw IP address in question.
+var ipMatchRegex = regexp.MustCompile(`(:\d+)$`)
+
 // Internal IP ranges that should be blocked if the resource requested resolves within.
 var internalRanges = []*net.IPNet{
 	mustParseCIDR("127.0.0.1/8"),
@@ -56,11 +60,9 @@ var internalRanges = []*net.IPNet{
 	mustParseCIDR("fc00::/7"),
 }
 
-const (
+const ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
-	ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
+const ErrInvalidIPAddress = errors.Sentinel("downloader: invalid IP address")
-	ErrInvalidIPAddress   = errors.Sentinel("downloader: invalid IP address")
+const ErrDownloadFailed = errors.Sentinel("downloader: download request failed")
-	ErrDownloadFailed     = errors.Sentinel("downloader: download request failed")
-)
 
 type Counter struct {
 	total   int
@@ -75,8 +77,8 @@ func (c *Counter) Write(p []byte) (int, error) {
 }
 
 type DownloadRequest struct {
-	Directory string
 	URL       *url.URL
+	Directory string
 }
 
 type Download struct {
@@ -88,7 +90,7 @@ type Download struct {
 	cancelFunc *context.CancelFunc
 }
 
-// New starts a new tracked download which allows for cancellation later on by calling
+// Starts a new tracked download which allows for cancellation later on by calling
 // the Downloader.Cancel function.
 func New(s *server.Server, r DownloadRequest) *Download {
 	dl := Download{
@@ -100,14 +102,14 @@ func New(s *server.Server, r DownloadRequest) *Download {
 	return &dl
 }
 
-// ByServer returns all the tracked downloads for a given server instance.
+// Returns all of 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 {
+			if dl, dlok := instance.downloadCache[id]; dlok {
 				downloads = append(downloads, dl)
 			}
 		}
@@ -115,7 +117,7 @@ func ByServer(sid string) []*Download {
 	return downloads
 }
 
-// ByID returns a single Download matching a given identifier. If no download is found
+// 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)
@@ -132,7 +134,7 @@ func (dl Download) MarshalJSON() ([]byte, error) {
 	})
 }
 
-// Execute executes a given download for the server and begins writing the file to the disk. Once
+// 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)
@@ -183,7 +185,7 @@ func (dl *Download) Execute() error {
 	return nil
 }
 
-// Cancel cancels a running download and frees up the associated resources. If a file is being
+// 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 {
@@ -192,12 +194,12 @@ func (dl *Download) Cancel() {
 	instance.remove(dl.Identifier)
 }
 
-// BelongsTo checks if the given download belongs to the provided server.
+// Checks if the given download belongs to the provided server.
 func (dl *Download) BelongsTo(s *server.Server) bool {
-	return dl.server.ID() == s.ID()
+	return dl.server.Id() == s.Id()
 }
 
-// Progress returns the current progress of the download as a float value between 0 and 1 where
+// 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()
@@ -230,19 +232,15 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 
 	// This cluster-fuck of math and integer shit converts an integer IP into a proper IPv4.
 	// For example: 16843009 would become 1.1.1.1
-	//if i, err := strconv.ParseInt(host, 10, 64); err == nil {
+	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)
+		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 !ipMatchRegex.MatchString(host) {
-		if !strings.Contains(err.Error(), "missing port in address") {
+		if dl.req.URL.Scheme == "https" {
-			return errors.WithStack(err)
+			host = host + ":443"
-		}
+		} else {
-		switch dl.req.URL.Scheme {
+			host = host + ":80"
-		case "http":
-			host += ":80"
-		case "https":
-			host += ":443"
 		}
 	}
 
@@ -252,11 +250,7 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	}
 	_ = c.Close()
 
-	ipStr, _, err := net.SplitHostPort(c.RemoteAddr().String())
+	ip := net.ParseIP(ipMatchRegex.ReplaceAllString(c.RemoteAddr().String(), ""))
-	if err != nil {
-		return errors.WithStack(err)
-	}
-	ip := net.ParseIP(ipStr)
 	if ip == nil {
 		return errors.WithStack(ErrInvalidIPAddress)
 	}
@@ -271,7 +265,7 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	return nil
 }
 
-// Downloader represents a global downloader that keeps track of all currently processing downloads
+// Defines a global downloader struct that keeps track of all currently processing downloads
 // for the machine.
 type Downloader struct {
 	mu            sync.RWMutex
@@ -279,11 +273,11 @@ type Downloader struct {
 	serverCache   map[string][]string
 }
 
-// track tracks a download in the internal cache for this instance.
+// Tracks a download in the internal cache for this instance.
 func (d *Downloader) track(dl *Download) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	sid := dl.server.ID()
+	sid := dl.server.Id()
 	if _, ok := d.downloadCache[dl.Identifier]; !ok {
 		d.downloadCache[dl.Identifier] = dl
 		if _, ok := d.serverCache[sid]; !ok {
@@ -293,7 +287,7 @@ func (d *Downloader) track(dl *Download) {
 	}
 }
 
-// find finds a given download entry using the provided ID and returns it.
+// 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()
@@ -303,24 +297,24 @@ func (d *Downloader) find(dlid string) *Download {
 	return nil
 }
 
-// remove removes the given download reference from the cache storing them. This also updates
+// Remove the given download reference from the cache storing them. This also updates
 // the slice of active downloads for a given server to not include this download.
-func (d *Downloader) remove(dlID string) {
+func (d *Downloader) remove(dlid string) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	if _, ok := d.downloadCache[dlID]; !ok {
+	if _, ok := d.downloadCache[dlid]; !ok {
 		return
 	}
-	sID := d.downloadCache[dlID].server.ID()
+	sid := d.downloadCache[dlid].server.Id()
-	delete(d.downloadCache, dlID)
+	delete(d.downloadCache, dlid)
-	if tracked, ok := d.serverCache[sID]; ok {
+	if tracked, ok := d.serverCache[sid]; ok {
 		var out []string
 		for _, k := range tracked {
-			if k != dlID {
+			if k != dlid {
 				out = append(out, k)
 			}
 		}
-		d.serverCache[sID] = out
+		d.serverCache[sid] = out
 	}
 }
 

router/error.go

@@ -10,7 +10,6 @@ import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
-
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
 )

router/middleware.go

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

router/middleware/middleware.go

@@ -3,16 +3,17 @@ package middleware
 import (
 	"context"
 	"crypto/subtle"
+	"github.com/pterodactyl/wings/metrics"
 	"io"
 	"net/http"
 	"os"
+	"strconv"
 	"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"
@@ -63,7 +64,7 @@ func (re *RequestError) Abort(c *gin.Context, status int) {
 	// server triggered this error.
 	if s, ok := c.Get("server"); ok {
 		if s, ok := s.(*server.Server); ok {
-			event = event.WithField("server_id", s.ID())
+			event = event.WithField("server_id", s.Id())
 		}
 	}
 
@@ -263,14 +264,14 @@ func ServerExists() gin.HandlerFunc {
 		if c.Param("server") != "" {
 			manager := ExtractManager(c)
 			s = manager.Find(func(s *server.Server) bool {
-				return c.Param("server") == s.ID()
+				return c.Param("server") == s.Id()
 			})
 		}
 		if s == nil {
 			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"error": "The requested resource does not exist on this instance."})
 			return
 		}
-		c.Set("logger", ExtractLogger(c).WithField("server_id", s.ID()))
+		c.Set("logger", ExtractLogger(c).WithField("server_id", s.Id()))
 		c.Set("server", s)
 		c.Next()
 	}
@@ -353,3 +354,19 @@ func ExtractManager(c *gin.Context) *server.Manager {
 	}
 	panic("middleware/middleware: cannot extract server manager: not present in context")
 }
+
+func Metrics() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		path := c.Request.URL.Path
+		rawQuery := c.Request.URL.RawQuery
+
+		c.Next()
+
+		// Skip over the server websocket endpoint.
+		if strings.HasSuffix(c.FullPath(), "/ws") {
+			return
+		}
+
+		metrics.HTTPRequestsTotal.WithLabelValues(c.Request.Method, c.FullPath(), path, rawQuery, strconv.Itoa(c.Writer.Status())).Inc()
+	}
+}

router/router.go

@@ -3,18 +3,18 @@ package router
 import (
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router/middleware"
-	wserver "github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server"
 )
 
 // Configure configures the routing infrastructure for this daemon instance.
-func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
+func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 	gin.SetMode("release")
 
 	router := gin.New()
 	router.Use(gin.Recovery())
+	router.Use(middleware.Metrics())
 	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.
@@ -63,6 +63,7 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	server.Use(middleware.RequireAuthorization(), middleware.ServerExists())
 	{
 		server.GET("", getServer)
+		server.PATCH("", patchServer)
 		server.DELETE("", deleteServer)
 
 		server.GET("/logs", getServerLogs)
@@ -70,7 +71,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

router/router_download.go

@@ -8,7 +8,6 @@ import (
 	"strconv"
 
 	"github.com/gin-gonic/gin"
-
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server/backup"

router/router_server.go

@@ -1,6 +1,7 @@
 package router
 
 import (
+	"bytes"
 	"context"
 	"net/http"
 	"os"
@@ -101,7 +102,7 @@ func postServerPower(c *gin.Context) {
 func postServerCommands(c *gin.Context) {
 	s := ExtractServer(c)
 
-	if running, err := s.Environment.IsRunning(c.Request.Context()); err != nil {
+	if running, err := s.Environment.IsRunning(); err != nil {
 		NewServerError(err, s).Abort(c)
 		return
 	} else if !running {
@@ -128,18 +129,21 @@ func postServerCommands(c *gin.Context) {
 	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
-// 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()); err != nil {
+		NewServerError(err, s).Abort(c)
+		return
 	}
+
+	s.SyncWithEnvironment()
+
+	c.Status(http.StatusNoContent)
 }
 
 // Performs a server installation in a background thread.
@@ -191,7 +195,7 @@ func deleteServer(c *gin.Context) {
 	s.Websockets().CancelAll()
 
 	// Remove any pending remote file downloads for the server.
-	for _, dl := range downloader.ByServer(s.ID()) {
+	for _, dl := range downloader.ByServer(s.Id()) {
 		dl.Cancel()
 	}
 
@@ -216,7 +220,7 @@ func deleteServer(c *gin.Context) {
 	}(s.Filesystem().Path())
 
 	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
-		return server.ID() == s.ID()
+		return server.Id() == s.Id()
 	})
 
 	// Deallocate the reference to this server.

router/router_server_backup.go

@@ -8,7 +8,6 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/backup"
@@ -43,7 +42,7 @@ func postServerBackup(c *gin.Context) {
 	// Attach the server ID and the request ID to the adapter log context for easier
 	// parsing in the logs.
 	adapter.WithLogContext(map[string]interface{}{
-		"server":     s.ID(),
+		"server":     s.Id(),
 		"request_id": c.GetString("request_id"),
 	})
 

router/router_server_files.go

@@ -16,13 +16,12 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-	"golang.org/x/sync/errgroup"
-
 	"github.com/pterodactyl/wings/router/downloader"
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
+	"golang.org/x/sync/errgroup"
 )
 
 // getServerFileContents returns the contents of a file on the server.
@@ -246,7 +245,7 @@ func postServerWriteFile(c *gin.Context) {
 func getServerPullingFiles(c *gin.Context) {
 	s := ExtractServer(c)
 	c.JSON(http.StatusOK, gin.H{
-		"downloads": downloader.ByServer(s.ID()),
+		"downloads": downloader.ByServer(s.Id()),
 	})
 }
 
@@ -254,20 +253,13 @@ func getServerPullingFiles(c *gin.Context) {
 func postServerPullRemoteFile(c *gin.Context) {
 	s := ExtractServer(c)
 	var data struct {
-		// Deprecated
-		Directory string `binding:"required_without=RootPath,omitempty" json:"directory"`
-		RootPath  string `binding:"required_without=Directory,omitempty" json:"root"`
 		URL       string `binding:"required" json:"url"`
+		Directory string `binding:"required,omitempty" json:"directory"`
 	}
 	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 {
@@ -285,7 +277,7 @@ func postServerPullRemoteFile(c *gin.Context) {
 		return
 	}
 	// Do not allow more than three simultaneous remote file downloads at one time.
-	if len(downloader.ByServer(s.ID())) >= 3 {
+	if len(downloader.ByServer(s.Id())) >= 3 {
 		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 			"error": "This server has reached its limit of 3 simultaneous remote file downloads at once. Please wait for one to complete before trying again.",
 		})
@@ -293,11 +285,11 @@ func postServerPullRemoteFile(c *gin.Context) {
 	}
 
 	dl := downloader.New(s, downloader.DownloadRequest{
-		Directory: data.RootPath,
 		URL:       u,
+		Directory: data.Directory,
 	})
 
-	// Execute this pull in a separate thread since it may take a long time to complete.
+	// Execute this pull in a seperate thread since it may take a long time to complete.
 	go func() {
 		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 {

router/router_server_ws.go

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

router/router_system.go

@@ -1,14 +1,12 @@
 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"
@@ -43,13 +41,10 @@ func getAllServers(c *gin.Context) {
 // 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(c.Request.Context(), manager, 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{
@@ -70,27 +65,14 @@ func postCreateServer(c *gin.Context) {
 	// cycle. If there are any errors they will be logged and communicated back
 	// to the Panel where a reinstall may take place.
 	go func(i *installer.Installer) {
-		if err := i.Server().CreateEnvironment(); err != nil {
+		err := i.Server().CreateEnvironment()
+		if err != nil {
 			i.Server().Log().WithField("error", err).Error("failed to create server environment during install process")
 			return
 		}
 
 		if err := i.Server().Install(false); err != nil {
-			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
+			log.WithFields(log.Fields{"server": i.Uuid(), "error": err}).Error("failed to run install process for server")
-			return
-		}
-
-		if i.StartOnCompletion {
-			log.WithField("server_id", i.Server().ID()).Debug("starting server after successful installation")
-			if err := i.Server().HandlePowerAction(server.PowerActionStart, 30); err != nil {
-				if errors.Is(err, context.DeadlineExceeded) {
-					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start"}).Warn("could not acquire a lock while attempting to perform a power action")
-				} else {
-					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start", "error": err}).Error("encountered error processing a server power action in the background")
-				}
-			}
-		} else {
-			log.WithField("server_id", i.Server().ID()).Debug("skipping automatic start after successful server installation")
 		}
 	}(install)
 

router/router_transfer.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -22,7 +23,6 @@ import (
 	"github.com/juju/ratelimit"
 	"github.com/mholt/archiver/v3"
 	"github.com/mitchellh/colorstring"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/installer"
 	"github.com/pterodactyl/wings/remote"
@@ -46,10 +46,10 @@ type downloadProgress struct {
 
 // Data passed over to initiate a server transfer.
 type serverTransferRequest struct {
-	ServerID string                  `binding:"required" json:"server_id"`
+	ServerID string          `binding:"required" json:"server_id"`
-	URL      string                  `binding:"required" json:"url"`
+	URL      string          `binding:"required" json:"url"`
-	Token    string                  `binding:"required" json:"token"`
+	Token    string          `binding:"required" json:"token"`
-	Server   installer.ServerDetails `json:"server"`
+	Server   json.RawMessage `json:"server"`
 }
 
 func getArchivePath(sID string) string {
@@ -75,14 +75,14 @@ func getServerArchive(c *gin.Context) {
 	}
 
 	s := ExtractServer(c)
-	if token.Subject != s.ID() {
+	if token.Subject != s.Id() {
 		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
 			"error": "Missing required token subject, or subject is not valid for the requested server.",
 		})
 		return
 	}
 
-	archivePath := getArchivePath(s.ID())
+	archivePath := getArchivePath(s.Id())
 
 	// Stat the archive file.
 	st, err := os.Lstat(archivePath)
@@ -123,7 +123,7 @@ func getServerArchive(c *gin.Context) {
 	c.Header("X-Checksum", checksum)
 	c.Header("X-Mime-Type", "application/tar+gzip")
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(s.ID()+".tar.gz"))
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(s.Id()+".tar.gz"))
 	c.Header("Content-Type", "application/octet-stream")
 
 	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
@@ -134,7 +134,7 @@ func postServerArchive(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 
 	go func(s *server.Server) {
-		l := log.WithField("server", s.ID())
+		l := log.WithField("server", s.Id())
 
 		// This function automatically adds the Source Node prefix and Timestamp to the log
 		// output before sending it over the websocket.
@@ -157,7 +157,7 @@ func postServerArchive(c *gin.Context) {
 			s.Events().Publish(server.TransferStatusEvent, "failure")
 
 			sendTransferLog("Attempting to notify panel of archive failure..")
-			if err := manager.Client().SetArchiveStatus(s.Context(), s.ID(), false); err != nil {
+			if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), false); err != nil {
 				if !remote.IsRequestError(err) {
 					sendTransferLog("Failed to notify panel of archive failure: " + err.Error())
 					l.WithField("error", err).Error("failed to notify panel of failed archive status")
@@ -190,7 +190,7 @@ func postServerArchive(c *gin.Context) {
 		}
 
 		// Attempt to get an archive of the server.
-		if err := a.Create(getArchivePath(s.ID())); err != nil {
+		if err := a.Create(getArchivePath(s.Id())); err != nil {
 			sendTransferLog("An error occurred while archiving the server: " + err.Error())
 			l.WithField("error", err).Error("failed to get transfer archive for server")
 			return
@@ -199,7 +199,7 @@ func postServerArchive(c *gin.Context) {
 		sendTransferLog("Successfully created archive, attempting to notify panel..")
 		l.Info("successfully created server transfer archive, notifying panel..")
 
-		if err := manager.Client().SetArchiveStatus(s.Context(), s.ID(), true); err != nil {
+		if err := manager.Client().SetArchiveStatus(s.Context(), s.Id(), true); err != nil {
 			if !remote.IsRequestError(err) {
 				sendTransferLog("Failed to notify panel of archive success: " + err.Error())
 				l.WithField("error", err).Error("failed to notify panel of successful archive status")
@@ -360,7 +360,7 @@ func postTransfer(c *gin.Context) {
 				sendTransferLog("Server transfer failed, check Wings logs for additional information.")
 				s.Events().Publish(server.TransferStatusEvent, "failure")
 				manager.Remove(func(match *server.Server) bool {
-					return match.ID() == s.ID()
+					return match.Id() == s.Id()
 				})
 
 				// If the transfer status was successful but the request failed, act like the transfer failed.

router/tokens/parser.go

@@ -1,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/websocket.go

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

router/websocket/listeners.go

@@ -2,48 +2,21 @@ package websocket
 
 import (
 	"context"
-	"sync"
-	"time"
-
-	"emperror.dev/errors"
 	"github.com/pterodactyl/wings/events"
 	"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 {
@@ -77,47 +50,29 @@ var e = []string{
 	server.TransferStatusEvent,
 }
 
-// ListenForServerEvents will listen for different events happening on a server
+// Listens for different events happening on a server and sends them along
-// and send them along to the connected websocket client. This function will
+// to the connected websocket.
-// block until the context provided to it is canceled.
+func (h *Handler) ListenForServerEvents(ctx context.Context) {
-func (h *Handler) listenForServerEvents(pctx context.Context) error {
+	h.server.Log().Debug("listening for server events over websocket")
-	var o sync.Once
-	var err error
-	ctx, cancel := context.WithCancel(pctx)
-
 	callback := func(e events.Event) {
-		if sendErr := h.SendJson(&Message{Event: e.Topic, Args: []string{e.Data}}); sendErr != nil {
+		if err := h.SendJson(&Message{Event: e.Topic, Args: []string{e.Data}}); err != nil {
-			h.Logger().WithField("event", e.Topic).WithField("error", sendErr).Error("failed to send event over server websocket")
+			h.server.Log().WithField("error", err).Warn("error while sending server data over 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 = sendErr
-				cancel()
-			})
 		}
 	}
 
-	// Subscribe to all of the events with the same callback that will push the
+	// Subscribe to all of the events with the same callback that will push the data out over the
-	// data out over the websocket for the server.
+	// websocket for the server.
 	for _, evt := range e {
 		h.server.Events().On(evt, &callback)
 	}
 
-	// When this function returns de-register all of the event listeners.
+	go func(ctx context.Context) {
-	defer func() {
+		select {
-		for _, evt := range e {
+		case <-ctx.Done():
-			h.server.Events().Off(evt, &callback)
+			// Once this context is stopped, de-register all of the listeners that have been registered.
+			for _, evt := range e {
+				h.server.Events().Off(evt, &callback)
+			}
 		}
-	}()
+	}(ctx)
-
-	<-ctx.Done()
-	// If the internal context is stopped it is either because the parent context
-	// got canceled or because we ran into an error. If the "err" variable is nil
-	// we can assume the parent was canceled and need not perform any actions.
-	if err != nil {
-		return errors.WithStack(err)
-	}
-
-	return nil
 }

router/websocket/websocket.go

@@ -2,24 +2,22 @@ package websocket
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"encoding/json"
 	"fmt"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
 	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
 )
 
 const (
@@ -57,10 +55,11 @@ func IsJwtError(err error) bool {
 		errors.Is(err, jwt.ErrExpValidation)
 }
 
-// NewTokenPayload parses a JWT into a websocket token payload.
+// 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
 	}
 
@@ -75,7 +74,7 @@ func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
 	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) (*Handler, error) {
 	upgrader := websocket.Upgrader{
 		// Ensure that the websocket request is originating from the Panel itself,
@@ -116,12 +115,6 @@ func (h *Handler) Uuid() uuid.UUID {
 	return h.uuid
 }
 
-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 {
@@ -187,7 +180,7 @@ 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 {
@@ -206,14 +199,14 @@ func (h *Handler) TokenValid() error {
 		return ErrJwtNoConnectPerm
 	}
 
-	if h.server.ID() != j.GetServerUuid() {
+	if h.server.Id() != j.GetServerUuid() {
 		return ErrJwtUuidMismatch
 	}
 
 	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 {
@@ -243,7 +236,7 @@ func (h *Handler) SendErrorJson(msg Message, err error, shouldLog ...bool) error
 	return h.unsafeSendJson(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())
@@ -253,7 +246,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()
@@ -261,15 +260,8 @@ 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.jwt = token
-	h.Unlock()
-}
-
-// HandleInbound handles an inbound socket request and route it to the proper action.
-func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 	if m.Event != AuthenticationEvent {
 		if err := h.TokenValid(); err != nil {
 			h.unsafeSendJson(Message{
@@ -285,6 +277,13 @@ 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
 			}
 
@@ -297,7 +296,10 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 			h.setJwt(token)
 
 			// Tell the client they authenticated successfully.
-			h.unsafeSendJson(Message{Event: AuthenticationSuccessEvent})
+			h.unsafeSendJson(Message{
+				Event: AuthenticationSuccessEvent,
+				Args:  []string{},
+			})
 
 			// Check if the client was refreshing their authentication token
 			// instead of authenticating for the first time.
@@ -307,11 +309,6 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 				return nil
 			}
 
-			// Now that we've authenticated with the token and confirmed that we're not
-			// reconnecting to the socket, register the event listeners for the server and
-			// the token expiration.
-			h.registerListenerEvents(ctx)
-
 			// On every authentication event, send the current server status back
 			// to the client. :)
 			state := h.server.Environment.State()
@@ -369,9 +366,7 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 		}
 	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
 			}
 

rpm/ptero-wings.spec

@@ -1,114 +0,0 @@
-Name:       ptero-wings
-Version:    1.5.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
-* Sun Sep 12 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.0-1
-- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
-- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.0
-- Fixes a race condition when setting the application name in the console output for a server.
-- Fixes a server being reinstalled causing the file_denylist parameter for an Egg to be ignored until Wings is restarted.
-- Fixes YAML file parser not correctly setting boolean values.
-- Fixes potential issue where the underlying websocket connection is closed but the parent request context is not yet canceled causing a write over a closed connection.
-- Fixes race condition when closing all active websocket connections when a server is deleted.
-- Fixes logic to determine if a server's context is closed out and send a websocket close message to connected clients. Previously this fired off whenever the request itself was closed, and not when the server context was closed.
-- Exposes 8080 in the wings Dockerfile to better support reverse proxy tools.
-- Releases are now built using Go 1.17 — the minimum version required to build Wings remains Go 1.16.
-- Simplifed the logic powering server updates to only pull information from the Panel rather than trying to accept updated values. All parts of Wings needing the most up-to-date server details should call Server#Sync() to fetch the latest stored build information.
-- Installer#New() no longer requires passing all of the server data as a byte slice, rather a new Installer#ServerDetails struct is exposed which can be passed and accepts a UUID and if the server should be started after the installer finishes.
-- Removes complicated (and unused) logic during the server installation process that was a hold-over from legacy Wings architectures.
-- Removes the PATCH /api/servers/:server endpoint — if you were previously using this API call it should be replaced with POST /api/servers/:server/sync.
-
-* Wed Aug 25 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.4.7-1
-- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
-- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.4.7
-- SFTP access is now properly denied if a server is suspended.
-- Correctly uses start_on_completion and crash_detection_enabled for servers.

server/backup.go

@@ -2,15 +2,12 @@ package server
 
 import (
 	"io"
-	"io/fs"
 	"io/ioutil"
 	"os"
-	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/backup"
@@ -63,7 +60,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 	ignored := b.Ignored()
 	if b.Ignored() == "" {
 		if i, err := s.getServerwideIgnoredFiles(); err != nil {
-			log.WithField("server", s.ID()).WithField("error", err).Warn("failed to get server-wide ignored files")
+			log.WithField("server", s.Id()).WithField("error", err).Warn("failed to get server-wide ignored files")
 		} else {
 			ignored = i
 		}
@@ -153,15 +150,9 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	// Attempt to restore the backup to the server by running through each entry
 	// in the file one at a time and writing them to the disk.
 	s.Log().Debug("starting file writing process for backup restoration")
-	err = b.Restore(s.Context(), reader, func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error {
+	err = b.Restore(s.Context(), reader, func(file string, r io.Reader) error {
 		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
-		if err := s.Filesystem().Writefile(file, r); err != nil {
+		return s.Filesystem().Writefile(file, r)
-			return err
-		}
-		if err := s.Filesystem().Chmod(file, mode); err != nil {
-			return err
-		}
-		return s.Filesystem().Chtimes(file, atime, mtime)
 	})
 
 	return errors.WithStackIf(err)

server/backup/backup.go

@@ -5,17 +5,14 @@ import (
 	"crypto/sha1"
 	"encoding/hex"
 	"io"
-	"io/fs"
 	"os"
 	"path"
-	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
-	"golang.org/x/sync/errgroup"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
+	"golang.org/x/sync/errgroup"
 )
 
 type AdapterType string
@@ -27,7 +24,7 @@ const (
 
 // RestoreCallback is a generic restoration callback that exists for both local
 // and remote backups allowing the files to be restored.
-type RestoreCallback func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error
+type RestoreCallback func(file string, r io.Reader) error
 
 // noinspection GoNameStartsWithPackageName
 type BackupInterface interface {

server/backup/backup_local.go

@@ -6,10 +6,10 @@ import (
 	"os"
 
 	"emperror.dev/errors"
-	"github.com/mholt/archiver/v3"
-
-	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/filesystem"
+
+	"github.com/mholt/archiver/v3"
+	"github.com/pterodactyl/wings/remote"
 )
 
 type LocalBackup struct {
@@ -85,10 +85,12 @@ func (b *LocalBackup) Restore(ctx context.Context, _ io.Reader, callback Restore
 			// Stop walking if the context is canceled.
 			return archiver.ErrStopWalk
 		default:
-			if f.IsDir() {
+			{
-				return nil
+				if f.IsDir() {
+					return nil
+				}
+				return callback(filesystem.ExtractNameFromArchive(f), f)
 			}
-			return callback(filesystem.ExtractNameFromArchive(f), f, f.Mode(), f.ModTime(), f.ModTime())
 		}
 	})
 }

server/backup/backup_s3.go

@@ -13,11 +13,9 @@ import (
 
 	"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"
 )
@@ -116,7 +114,7 @@ func (s *S3Backup) Restore(ctx context.Context, r io.Reader, callback RestoreCal
 			return err
 		}
 		if header.Typeflag == tar.TypeReg {
-			if err := callback(header.Name, tr, header.FileInfo().Mode(), header.AccessTime, header.ModTime); err != nil {
+			if err := callback(header.Name, tr); err != nil {
 				return err
 			}
 		}

server/configuration.go

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

server/console.go

@@ -9,7 +9,6 @@ import (
 
 	"emperror.dev/errors"
 	"github.com/mitchellh/colorstring"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
 )
@@ -19,8 +18,6 @@ import (
 // a server.
 var appName string
 
-var appNameSync sync.Once
-
 var ErrTooMuchConsoleData = errors.New("console is outputting too much data")
 
 type ConsoleThrottler struct {
@@ -133,9 +130,9 @@ func (s *Server) Throttler() *ConsoleThrottler {
 // PublishConsoleOutputFromDaemon sends output to the server console formatted
 // to appear correctly as being sent from Wings.
 func (s *Server) PublishConsoleOutputFromDaemon(data string) {
-	appNameSync.Do(func() {
+	if appName == "" {
 		appName = config.Get().AppName
-	})
+	}
 	s.Events().Publish(
 		ConsoleOutputEvent,
 		colorstring.Color(fmt.Sprintf("[yellow][bold][%s Daemon]:[default] %s", appName, data)),

server/filesystem/archive.go

@@ -3,7 +3,6 @@ package filesystem
 import (
 	"archive/tar"
 	"io"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -14,9 +13,8 @@ import (
 	"github.com/juju/ratelimit"
 	"github.com/karrick/godirwalk"
 	"github.com/klauspost/pgzip"
-	ignore "github.com/sabhiram/go-gitignore"
-
 	"github.com/pterodactyl/wings/config"
+	"github.com/sabhiram/go-gitignore"
 )
 
 const memory = 4 * 1024
@@ -158,15 +156,9 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 		return errors.WrapIff(err, "failed executing os.Lstat on '%s'", rp)
 	}
 
-	// Skip socket files as they are unsupported by archive/tar.
-	// Error will come from tar#FileInfoHeader: "archive/tar: sockets not supported"
-	if s.Mode()&fs.ModeSocket != 0 {
-		return nil
-	}
-
 	// Resolve the symlink target if the file is a symlink.
 	var target string
-	if s.Mode()&fs.ModeSymlink != 0 {
+	if s.Mode()&os.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
@@ -188,7 +180,7 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 	}
 
 	// Fix the header name if the file is not a symlink.
-	if s.Mode()&fs.ModeSymlink == 0 {
+	if s.Mode()&os.ModeSymlink == 0 {
 		header.Name = rp
 	}
 

server/filesystem/compress.go

@@ -132,14 +132,6 @@ func (fs *Filesystem) DecompressFile(dir string, file string) error {
 		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 {

server/filesystem/filesystem.go

@@ -17,10 +17,9 @@ import (
 	"emperror.dev/errors"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/karrick/godirwalk"
-	ignore "github.com/sabhiram/go-gitignore"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
+	ignore "github.com/sabhiram/go-gitignore"
 )
 
 type Filesystem struct {
@@ -528,20 +527,3 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 
 	return out, nil
 }
-
-func (fs *Filesystem) Chtimes(path string, atime, mtime time.Time) error {
-	cleaned, err := fs.SafePath(path)
-	if err != nil {
-		return err
-	}
-
-	if fs.isTest {
-		return nil
-	}
-
-	if err := os.Chtimes(cleaned, atime, mtime); err != nil {
-		return err
-	}
-
-	return nil
-}

server/filesystem/filesystem_test.go

@@ -12,7 +12,6 @@ import (
 	"unicode/utf8"
 
 	. "github.com/franela/goblin"
-
 	"github.com/pterodactyl/wings/config"
 )
 

server/install.go

@@ -17,7 +17,6 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
@@ -89,7 +88,7 @@ func (s *Server) Reinstall() error {
 
 // Internal installation function used to simplify reporting back to the Panel.
 func (s *Server) internalInstall() error {
-	script, err := s.client.GetInstallationScript(s.Context(), s.ID())
+	script, err := s.client.GetInstallationScript(s.Context(), s.Id())
 	if err != nil {
 		return err
 	}
@@ -157,7 +156,7 @@ func (s *Server) SetRestoring(state bool) {
 
 // Removes the installer container for the server.
 func (ip *InstallationProcess) RemoveContainer() error {
-	err := ip.client.ContainerRemove(ip.context, ip.Server.ID()+"_installer", types.ContainerRemoveOptions{
+	err := ip.client.ContainerRemove(ip.context, ip.Server.Id()+"_installer", types.ContainerRemoveOptions{
 		RemoveVolumes: true,
 		Force:         true,
 	})
@@ -207,7 +206,7 @@ func (ip *InstallationProcess) Run() error {
 
 // Returns the location of the temporary data for the installation process.
 func (ip *InstallationProcess) tempDir() string {
-	return filepath.Join(os.TempDir(), "pterodactyl/", ip.Server.ID())
+	return filepath.Join(os.TempDir(), "pterodactyl/", ip.Server.Id())
 }
 
 // Writes the installation script to a temporary file on the host machine so that it
@@ -330,7 +329,7 @@ func (ip *InstallationProcess) BeforeExecute() error {
 
 // Returns the log path for the installation process.
 func (ip *InstallationProcess) GetLogPath() string {
-	return filepath.Join(config.Get().System.LogDirectory, "/install", ip.Server.ID()+".log")
+	return filepath.Join(config.Get().System.LogDirectory, "/install", ip.Server.Id()+".log")
 }
 
 // Cleans up after the execution of the installation process. This grabs the logs from the
@@ -366,7 +365,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 |
 | Details
 | ------------------------------
-  Server UUID:          {{.Server.ID}}
+  Server UUID:          {{.Server.Id}}
   Container Image:      {{.Script.ContainerImage}}
   Container Entrypoint: {{.Script.Entrypoint}}
 
@@ -470,7 +469,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		}
 	}()
 
-	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.ID()+"_installer")
+	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.Id()+"_installer")
 	if err != nil {
 		return "", err
 	}
@@ -574,5 +573,5 @@ func (ip *InstallationProcess) resourceLimits() container.Resources {
 // server is. A boolean value of "true" means everything was successful, "false"
 // means something went wrong and the server must be deleted and re-created.
 func (s *Server) SyncInstallState(successful bool) error {
-	return s.client.SetInstallationStatus(s.Context(), s.ID(), successful)
+	return s.client.SetInstallationStatus(s.Context(), s.Id(), successful)
 }

server/listeners.go

@@ -7,7 +7,6 @@ import (
 	"sync"
 
 	"github.com/apex/log"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/events"
@@ -41,7 +40,7 @@ func (dsl *diskSpaceLimiter) Reset() {
 // 15 seconds, and terminate it forcefully if it does not stop.
 //
 // This function is only executed one time, so whenever a server is marked as booting the limiter
-// should be reset, so it can properly be triggered as needed.
+// should be reset so it can properly be triggered as needed.
 func (dsl *diskSpaceLimiter) Trigger() {
 	dsl.o.Do(func() {
 		dsl.server.PublishConsoleOutputFromDaemon("Server is exceeding the assigned disk space limit, stopping process now.")
@@ -51,7 +50,7 @@ func (dsl *diskSpaceLimiter) Trigger() {
 	})
 }
 
-// StartEventListeners adds all the internal event listeners we want to use for a server. These listeners can only be
+// Adds all of the internal event listeners we want to use for a server. These listeners can only be
 // removed by deleting the server as they should last for the duration of the process' lifetime.
 func (s *Server) StartEventListeners() {
 	console := func(e events.Event) {
@@ -107,15 +106,15 @@ func (s *Server) StartEventListeners() {
 	}
 
 	stats := func(e events.Event) {
-		var st environment.Stats
+		st := new(environment.Stats)
-		if err := json.Unmarshal([]byte(e.Data), &st); err != nil {
+		if err := json.Unmarshal([]byte(e.Data), st); err != nil {
 			s.Log().WithField("error", err).Warn("failed to unmarshal server environment stats")
 			return
 		}
 
 		// Update the server resource tracking object with the resources we got here.
 		s.resources.mu.Lock()
-		s.resources.Stats = st
+		s.resources.Stats = *st
 		s.resources.mu.Unlock()
 
 		// If there is no disk space available at this point, trigger the server disk limiter logic

server/manager.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/pterodactyl/wings/metrics"
 	"io"
 	"io/ioutil"
 	"os"
@@ -15,7 +16,6 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gammazero/workerpool"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
@@ -29,9 +29,9 @@ type Manager struct {
 	servers []*Server
 }
 
-// NewManager returns a new server manager instance. This will boot up all the
+// NewManager returns a new server manager instance. This will boot up all of
-// servers that are currently present on the filesystem and set them into the
+// the servers that are currently present on the filesystem and set them into
-// manager.
+// the manager.
 func NewManager(ctx context.Context, client remote.Client) (*Manager, error) {
 	m := NewEmptyManager(client)
 	if err := m.init(ctx); err != nil {
@@ -53,7 +53,7 @@ func (m *Manager) Client() remote.Client {
 	return m.client
 }
 
-// Put replaces all the current values in the collection with the value that
+// Put replaces all of the current values in the collection with the value that
 // is passed through.
 func (m *Manager) Put(s []*Server) {
 	m.mu.Lock()
@@ -61,7 +61,7 @@ func (m *Manager) Put(s []*Server) {
 	m.mu.Unlock()
 }
 
-// All returns all the items in the collection.
+// All returns all of the items in the collection.
 func (m *Manager) All() []*Server {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -73,13 +73,16 @@ func (m *Manager) Add(s *Server) {
 	m.mu.Lock()
 	m.servers = append(m.servers, s)
 	m.mu.Unlock()
+
+	// Add the server to the metrics with a offline status.
+	metrics.ServerStatus.WithLabelValues(s.Id()).Set(0)
 }
 
 // Get returns a single server instance and a boolean value indicating if it was
 // found in the global collection or not.
 func (m *Manager) Get(uuid string) (*Server, bool) {
 	match := m.Find(func(server *Server) bool {
-		return server.ID() == uuid
+		return server.Id() == uuid
 	})
 	return match, match != nil
 }
@@ -118,6 +121,9 @@ func (m *Manager) Remove(filter func(match *Server) bool) {
 	for _, v := range m.servers {
 		if !filter(v) {
 			r = append(r, v)
+		} else {
+			// Delete the server from the metric.
+			metrics.DeleteServer(v.Id())
 		}
 	}
 	m.servers = r
@@ -131,7 +137,7 @@ func (m *Manager) Remove(filter func(match *Server) bool) {
 func (m *Manager) PersistStates() error {
 	states := map[string]string{}
 	for _, s := range m.All() {
-		states[s.ID()] = s.Environment.State()
+		states[s.Id()] = s.Environment.State()
 	}
 	data, err := json.Marshal(states)
 	if err != nil {
@@ -172,18 +178,15 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 	if err != nil {
 		return nil, err
 	}
-
+	if err := s.UpdateDataStructure(data.Settings); err != nil {
-	// Setup the base server configuration data which will be used for all of the
+		return nil, err
-	// remaining functionality in this call.
-	if err := s.SyncWithConfiguration(data); err != nil {
-		return nil, errors.WithStackIf(err)
 	}
 
-	s.fs = filesystem.New(filepath.Join(config.Get().System.Data, s.ID()), s.DiskSpace(), s.Config().Egg.FileDenylist)
+	s.fs = filesystem.New(filepath.Join(config.Get().System.Data, s.Id()), s.DiskSpace(), s.Config().Egg.FileDenylist)
 
 	// Right now we only support a Docker based environment, so I'm going to hard code
 	// this logic in. When we're ready to support other environment we'll need to make
-	// some modifications here, obviously.
+	// some modifications here obviously.
 	settings := environment.Settings{
 		Mounts:      s.Mounts(),
 		Allocations: s.cfg.Allocations,
@@ -195,7 +198,7 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 		Image: s.Config().Container.Image,
 	}
 
-	if env, err := docker.New(s.ID(), &meta, envCfg); err != nil {
+	if env, err := docker.New(s.Id(), &meta, envCfg); err != nil {
 		return nil, err
 	} else {
 		s.Environment = env
@@ -203,6 +206,11 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 		s.Throttler().StartTimer(s.Context())
 	}
 
+	// Forces the configuration to be synced with the panel.
+	if err := s.SyncWithConfiguration(data); err != nil {
+		return nil, err
+	}
+
 	// If the server's data directory exists, force disk usage calculation.
 	if _, err := os.Stat(s.Filesystem().Path()); err == nil {
 		s.Filesystem().HasSpaceAvailable(true)
@@ -211,7 +219,7 @@ func (m *Manager) InitServer(data remote.ServerConfigurationResponse) (*Server,
 	return s, nil
 }
 
-// initializeFromRemoteSource iterates over a given directory and loads all
+// initializeFromRemoteSource iterates over a given directory and loads all of
 // the servers listed before returning them to the calling function.
 func (m *Manager) init(ctx context.Context) error {
 	log.Info("fetching list of servers from API")
@@ -251,7 +259,7 @@ func (m *Manager) init(ctx context.Context) error {
 		})
 	}
 
-	// Wait until we've processed all the configuration files in the directory
+	// Wait until we've processed all of the configuration files in the directory
 	// before continuing.
 	pool.StopWait()
 

server/mounts.go

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

server/power.go

@@ -6,10 +6,9 @@ import (
 	"time"
 
 	"emperror.dev/errors"
-	"golang.org/x/sync/semaphore"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
+	"golang.org/x/sync/semaphore"
 )
 
 type PowerAction string
@@ -19,7 +18,7 @@ type PowerAction string
 // example, sending two "start" actions back to back will not process the second action until
 // the first action has been completed.
 //
-// This utilizes a workerpool with a limit of one worker so that all the actions execute
+// This utilizes a workerpool with a limit of one worker so that all of the actions execute
 // in a sync manner.
 const (
 	PowerActionStart     = "start"
@@ -28,7 +27,7 @@ const (
 	PowerActionTerminate = "kill"
 )
 
-// IsValid checks if the power action being received is valid.
+// Checks if the power action being received is valid.
 func (pa PowerAction) IsValid() bool {
 	return pa == PowerActionStart ||
 		pa == PowerActionStop ||
@@ -40,7 +39,7 @@ func (pa PowerAction) IsStart() bool {
 	return pa == PowerActionStart || pa == PowerActionRestart
 }
 
-// ExecutingPowerAction checks if there is currently a power action being processed for the server.
+// Check if there is currently a power action being processed for the server.
 func (s *Server) ExecutingPowerAction() bool {
 	if s.powerLock == nil {
 		return false
@@ -55,9 +54,9 @@ func (s *Server) ExecutingPowerAction() bool {
 	return !ok
 }
 
-// HandlePowerAction is a helper function that can receive a power action and then process the
+// Helper function that can receive a power action and then process the actions that need
-// actions that need to occur for it. This guards against someone calling Start() twice at the
+// to occur for it. This guards against someone calling Start() twice at the same time, or
-// same time, or trying to restart while another restart process is currently running.
+// trying to restart while another restart process is currently running.
 //
 // However, the code design for the daemon does depend on the user correctly calling this
 // function rather than making direct calls to the start/stop/restart functions on the
@@ -108,7 +107,7 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 		// Release the lock once the process being requested has finished executing.
 		defer s.powerLock.Release(1)
 	} else {
-		// Still try to acquire the lock if terminating, and it is available, just so that other power
+		// Still try to acquire the lock if terminating and it is available, just so that other power
 		// actions are blocked until it has completed. However, if it is unavailable we won't stop
 		// the entire process.
 		if ok := s.powerLock.TryAcquire(1); ok {
@@ -128,7 +127,7 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 			return err
 		}
 
-		return s.Environment.Start(s.Context())
+		return s.Environment.Start()
 	case PowerActionStop:
 		// We're specifically waiting for the process to be stopped here, otherwise the lock is released
 		// too soon, and you can rack up all sorts of issues.
@@ -151,7 +150,7 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 			return err
 		}
 
-		return s.Environment.Start(s.Context())
+		return s.Environment.Start()
 	case PowerActionTerminate:
 		return s.Environment.Terminate(os.Kill)
 	}
@@ -191,14 +190,14 @@ func (s *Server) onBeforeStart() error {
 	// Update the configuration files defined for the server before beginning the boot process.
 	// This process executes a bunch of parallel updates, so we just block until that process
 	// is complete. Any errors as a result of this will just be bubbled out in the logger,
-	// we don't need to actively do anything about it at this point, worse comes to worst the
+	// 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.
 	s.PublishConsoleOutputFromDaemon("Updating process configuration files...")
 	s.UpdateConfigurationFiles()
 
 	if config.Get().System.CheckPermissionsOnBoot {
 		s.PublishConsoleOutputFromDaemon("Ensuring file permissions are set correctly, this could take a few seconds...")
-		// Ensure all the server file permissions are set correctly before booting the process.
+		// Ensure all of the server file permissions are set correctly before booting the process.
 		if err := s.Filesystem().Chown("/"); err != nil {
 			return errors.WithMessage(err, "failed to chown root server directory during pre-boot process")
 		}

server/resources.go

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

server/server.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"net/http"
 	"os"
@@ -12,14 +11,14 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/creasty/defaults"
-	"golang.org/x/sync/semaphore"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/environment/docker"
 	"github.com/pterodactyl/wings/events"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"github.com/pterodactyl/wings/system"
+	"golang.org/x/sync/semaphore"
 )
 
 // Server is the high level definition for a server instance being controlled
@@ -94,17 +93,9 @@ func New(client remote.Client) (*Server, error) {
 	return &s, nil
 }
 
-// ID returns the UUID for the server instance.
+// Id returns the UUID for the server instance.
-func (s *Server) ID() string {
-	return s.Config().GetUuid()
-}
-
-// Id returns the UUID for the server instance. This function is deprecated
-// in favor of Server.ID().
-//
-// Deprecated
 func (s *Server) Id() string {
-	return s.ID()
+	return s.Config().GetUuid()
 }
 
 // Cancels the context assigned to this server instance. Assuming background tasks
@@ -138,7 +129,7 @@ eloop:
 	for k := range s.Config().EnvVars {
 		// Don't allow any environment variables that we have already set above.
 		for _, e := range out {
-			if strings.HasPrefix(e, strings.ToUpper(k)+"=") {
+			if strings.HasPrefix(e, strings.ToUpper(k)) {
 				continue eloop
 			}
 		}
@@ -150,7 +141,7 @@ eloop:
 }
 
 func (s *Server) Log() *log.Entry {
-	return log.WithField("server", s.ID())
+	return log.WithField("server", s.Id())
 }
 
 // Sync syncs the state of the server on the Panel with Wings. This ensures that
@@ -160,57 +151,38 @@ func (s *Server) Log() *log.Entry {
 // This also means mass actions can be performed against servers on the Panel
 // and they will automatically sync with Wings when the server is started.
 func (s *Server) Sync() error {
-	cfg, err := s.client.GetServerConfiguration(s.Context(), s.ID())
+	cfg, err := s.client.GetServerConfiguration(s.Context(), s.Id())
 	if err != nil {
 		if err := remote.AsRequestError(err); err != nil && err.StatusCode() == http.StatusNotFound {
 			return &serverDoesNotExist{}
 		}
 		return errors.WithStackIf(err)
 	}
-
+	return s.SyncWithConfiguration(cfg)
-	if err := s.SyncWithConfiguration(cfg); err != nil {
-		return errors.WithStackIf(err)
-	}
-
-	// Update the disk space limits for the server whenever the configuration for
-	// it changes.
-	s.fs.SetDiskLimit(s.DiskSpace())
-
-	s.SyncWithEnvironment()
-
-	return nil
 }
 
-// SyncWithConfiguration accepts a configuration object for a server and will
-// sync all of the values with the existing server state. This only replaces the
-// existing configuration and process configuration for the server. The
-// underlying environment will not be affected. This is because this function
-// can be called from scoped where the server may not be fully initialized,
-// therefore other things like the filesystem and environment may not exist yet.
 func (s *Server) SyncWithConfiguration(cfg remote.ServerConfigurationResponse) error {
-	c := Configuration{
+	// Update the data structure and persist it to the disk.
-		CrashDetectionEnabled: config.Get().System.CrashDetection.CrashDetectionEnabled,
+	if err := s.UpdateDataStructure(cfg.Settings); err != nil {
+		return err
 	}
-	if err := json.Unmarshal(cfg.Settings, &c); err != nil {
-		return errors.WithStackIf(err)
-	}
-
-	s.cfg.mu.Lock()
-	defer s.cfg.mu.Unlock()
-
-	// Lock the new configuration. Since we have the deferred Unlock above we need
-	// to make sure that the NEW configuration object is already locked since that
-	// defer is running on the memory address for "s.cfg.mu" which we're explicitly
-	// changing on the next line.
-	c.mu.Lock()
-
-	//goland:noinspection GoVetCopyLock
-	s.cfg = c
 
 	s.Lock()
 	s.procConfig = cfg.ProcessConfiguration
 	s.Unlock()
 
+	// Update the disk space limits for the server whenever the configuration
+	// for it changes.
+	s.fs.SetDiskLimit(s.DiskSpace())
+
+	// If this is a Docker environment we need to sync the stop configuration with it so that
+	// the process isn't just terminated when a user requests it be stopped.
+	if e, ok := s.Environment.(*docker.Environment); ok {
+		s.Log().Debug("syncing stop configuration with configured docker environment")
+		e.SetImage(s.Config().Container.Image)
+		e.SetStopConfiguration(cfg.ProcessConfiguration.Stop)
+	}
+
 	return nil
 }
 
@@ -261,7 +233,7 @@ func (s *Server) EnsureDataDirectoryExists() error {
 	if _, err := os.Lstat(s.fs.Path()); err != nil {
 		if os.IsNotExist(err) {
 			s.Log().Debug("server: creating root directory and setting permissions")
-			if err := os.MkdirAll(s.fs.Path(), 0o700); err != nil {
+			if err := os.MkdirAll(s.fs.Path(), 0700); err != nil {
 				return errors.WithStack(err)
 			}
 			if err := s.fs.Chown("/"); err != nil {
@@ -274,7 +246,7 @@ func (s *Server) EnsureDataDirectoryExists() error {
 	return nil
 }
 
-// OnStateChange sets the state of the server internally. This function handles crash detection as
+// Sets the state of the server internally. This function handles crash detection as
 // well as reporting to event listeners for the server.
 func (s *Server) OnStateChange() {
 	prevState := s.resources.State.Load()
@@ -289,7 +261,7 @@ func (s *Server) OnStateChange() {
 		s.Events().Publish(StatusEvent, st)
 	}
 
-	// Reset the resource usage to 0 when the process fully stops so that all the UI
+	// Reset the resource usage to 0 when the process fully stops so that all of the UI
 	// views in the Panel correctly display 0.
 	if st == environment.ProcessOfflineState {
 		s.resources.Reset()
@@ -321,7 +293,7 @@ func (s *Server) OnStateChange() {
 }
 
 // IsRunning determines if the server state is running or not. This is different
-// from the environment state, it is simply the tracked state from this daemon
+// than the environment state, it is simply the tracked state from this daemon
 // instance, and not the response from Docker.
 func (s *Server) IsRunning() bool {
 	st := s.Environment.State()

server/update.go

@@ -1,41 +1,127 @@
 package server
 
 import (
-	"github.com/pterodactyl/wings/environment/docker"
+	"encoding/json"
 
+	"emperror.dev/errors"
+	"github.com/buger/jsonparser"
+	"github.com/imdario/mergo"
 	"github.com/pterodactyl/wings/environment"
 )
 
-// SyncWithEnvironment updates the environment for the server to match any of
+// UpdateDataStructure merges data passed through in JSON form into the existing
-// the changed data. This pushes new settings and environment variables to the
+// server object. Any changes to the build settings will apply immediately in
-// environment. In addition, the in-situ update method is called on the
+// the environment if the environment supports it.
-// environment which will allow environments that make use of it (such as Docker)
-// to immediately apply some settings without having to wait on a server to
-// restart.
 //
-// This functionality allows a server's resources limits to be modified on the
+// The server will be marked as requiring a rebuild on the next boot sequence,
-// fly and have them apply right away allowing for dynamic resource allocation
+// it is up to the specific environment to determine what needs to happen when
-// and responses to abusive server processes.
+// that is the case.
+func (s *Server) UpdateDataStructure(data []byte) error {
+	src := new(Configuration)
+	if err := json.Unmarshal(data, src); err != nil {
+		return errors.Wrap(err, "server/update: could not unmarshal source data into Configuration struct")
+	}
+
+	// Don't allow obviously corrupted data to pass through into this function. If the UUID
+	// doesn't match something has gone wrong and the API is attempting to meld this server
+	// instance into a totally different one, which would be bad.
+	if src.Uuid != "" && s.Id() != "" && src.Uuid != s.Id() {
+		return errors.New("server/update: attempting to merge a data stack with an invalid UUID")
+	}
+
+	// Grab a copy of the configuration to work on.
+	c := *s.Config()
+
+	// Lock our copy of the configuration since the deferred unlock will end up acting upon this
+	// new memory address rather than the old one. If we don't lock this, the deferred unlock will
+	// cause a panic when it goes to run. However, since we only update s.cfg at the end, if there
+	// is an error before that point we'll still properly unlock the original configuration for the
+	// server.
+	c.mu.Lock()
+
+	// Lock the server configuration while we're doing this merge to avoid anything
+	// trying to overwrite it or make modifications while we're sorting out what we
+	// need to do.
+	s.cfg.mu.Lock()
+	defer s.cfg.mu.Unlock()
+
+	// Merge the new data object that we have received with the existing server data object
+	// and then save it to the disk so it is persistent.
+	if err := mergo.Merge(&c, src, mergo.WithOverride); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Don't explode if we're setting CPU limits to 0. Mergo sees that as an empty value
+	// so it won't override the value we've passed through in the API call. However, we can
+	// safely assume that we're passing through valid data structures here. I foresee this
+	// backfiring at some point, but until then...
+	c.Build = src.Build
+
+	// Mergo can't quite handle this boolean value correctly, so for now we'll just
+	// handle this edge case manually since none of the other data passed through in this
+	// request is going to be boolean. Allegedly.
+	if v, err := jsonparser.GetBoolean(data, "container", "oom_disabled"); err != nil {
+		if err != jsonparser.KeyPathNotFoundError {
+			return errors.WithStack(err)
+		}
+	} else {
+		c.Build.OOMDisabled = v
+	}
+
+	// Mergo also cannot handle this boolean value.
+	if v, err := jsonparser.GetBoolean(data, "suspended"); err != nil {
+		if err != jsonparser.KeyPathNotFoundError {
+			return errors.WithStack(err)
+		}
+	} else {
+		c.Suspended = v
+	}
+
+	if v, err := jsonparser.GetBoolean(data, "skip_egg_scripts"); err != nil {
+		if err != jsonparser.KeyPathNotFoundError {
+			return errors.WithStack(err)
+		}
+	} else {
+		c.SkipEggScripts = v
+	}
+
+	// Environment and Mappings should be treated as a full update at all times, never a
+	// true patch, otherwise we can't know what we're passing along.
+	if src.EnvVars != nil && len(src.EnvVars) > 0 {
+		c.EnvVars = src.EnvVars
+	}
+
+	if src.Allocations.Mappings != nil && len(src.Allocations.Mappings) > 0 {
+		c.Allocations.Mappings = src.Allocations.Mappings
+	}
+
+	if src.Mounts != nil && len(src.Mounts) > 0 {
+		c.Mounts = src.Mounts
+	}
+
+	// Update the configuration once we have a lock on the configuration object.
+	s.cfg = c
+
+	return nil
+}
+
+// Updates the environment for the server to match any of the changed data. This pushes new settings and
+// environment variables to the environment. In addition, the in-situ update method is called on the
+// environment which will allow environments that make use of it (such as Docker) to immediately apply
+// some settings without having to wait on a server to restart.
+//
+// This functionality allows a server's resources limits to be modified on the fly and have them apply
+// right away allowing for dynamic resource allocation and responses to abusive server processes.
 func (s *Server) SyncWithEnvironment() {
 	s.Log().Debug("syncing server settings with environment")
 
-	cfg := s.Config()
-
 	// Update the environment settings using the new information from this server.
 	s.Environment.Config().SetSettings(environment.Settings{
 		Mounts:      s.Mounts(),
-		Allocations: cfg.Allocations,
+		Allocations: s.Config().Allocations,
-		Limits:      cfg.Build,
+		Limits:      s.Config().Build,
 	})
 
-	// For Docker specific environments we also want to update the configured image
-	// and stop configuration.
-	if e, ok := s.Environment.(*docker.Environment); ok {
-		s.Log().Debug("syncing stop configuration with configured docker environment")
-		e.SetImage(cfg.Container.Image)
-		e.SetStopConfiguration(s.ProcessConfiguration().Stop)
-	}
-
 	// If build limits are changed, environment variables also change. Plus, any modifications to
 	// the startup command also need to be properly propagated to this environment.
 	//

server/websockets.go

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

sftp/handler.go

@@ -11,11 +11,9 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/pkg/sftp"
-	"golang.org/x/crypto/ssh"
-
 	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
+	"golang.org/x/crypto/ssh"
 )
 
 const (
@@ -27,10 +25,8 @@ const (
 )
 
 type Handler struct {
-	mu sync.Mutex
-
 	permissions []string
-	server      *server.Server
+	mu          sync.Mutex
 	fs          *filesystem.Filesystem
 	logger      *log.Entry
 	ro          bool
@@ -38,12 +34,11 @@ type Handler struct {
 
 // Returns a new connection handler for the SFTP server. This allows a given user
 // to access the underlying filesystem.
-func NewHandler(sc *ssh.ServerConn, srv *server.Server) *Handler {
+func NewHandler(sc *ssh.ServerConn, fs *filesystem.Filesystem) *Handler {
 	return &Handler{
-		permissions: strings.Split(sc.Permissions.Extensions["permissions"], ","),
+		fs:          fs,
-		server:      srv,
-		fs:          srv.Filesystem(),
 		ro:          config.Get().System.Sftp.ReadOnly,
+		permissions: strings.Split(sc.Permissions.Extensions["permissions"], ","),
 		logger: log.WithFields(log.Fields{
 			"subsystem": "sftp",
 			"username":  sc.User(),
@@ -282,10 +277,6 @@ func (h *Handler) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
 // Determines if a user has permission to perform a specific action on the SFTP server. These
 // permissions are defined and returned by the Panel API.
 func (h *Handler) can(permission string) bool {
-	if h.server.IsSuspended() {
-		return false
-	}
-
 	// SFTPServer owners and super admins have their permissions returned as '[*]' via the Panel
 	// API, so for the sake of speed do an initial check for that before iterating over the
 	// entire array of permissions.

sftp/server.go

@@ -3,6 +3,7 @@ package sftp
 import (
 	"context"
 	"crypto/rand"
+	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
@@ -17,12 +18,10 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/pkg/sftp"
-	"golang.org/x/crypto/ed25519"
-	"golang.org/x/crypto/ssh"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
+	"golang.org/x/crypto/ssh"
 )
 
 // Usernames all follow the same format, so don't even bother hitting the API if the username is not
@@ -48,20 +47,18 @@ func New(m *server.Manager) *SFTPServer {
 	}
 }
 
-// Run starts the SFTP server and add a persistent listener to handle inbound
+// Starts the SFTP server and add a persistent listener to handle inbound SFTP connections.
-// SFTP connections. This will automatically generate an ED25519 key if one does
-// not already exist on the system for host key verification purposes.
 func (c *SFTPServer) Run() error {
-	if _, err := os.Stat(c.PrivateKeyPath()); os.IsNotExist(err) {
+	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_rsa")); os.IsNotExist(err) {
-		if err := c.generateED25519PrivateKey(); err != nil {
+		if err := c.generatePrivateKey(); err != nil {
 			return err
 		}
 	} else if err != nil {
-		return errors.Wrap(err, "sftp: could not stat private key file")
+		return errors.Wrap(err, "sftp/server: could not stat private key file")
 	}
-	pb, err := ioutil.ReadFile(c.PrivateKeyPath())
+	pb, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_rsa"))
 	if err != nil {
-		return errors.Wrap(err, "sftp: could not read private key file")
+		return errors.Wrap(err, "sftp/server: could not read private key file")
 	}
 	private, err := ssh.ParsePrivateKey(pb)
 	if err != nil {
@@ -80,9 +77,7 @@ func (c *SFTPServer) Run() error {
 		return err
 	}
 
-	public := string(ssh.MarshalAuthorizedKey(private.PublicKey()))
+	log.WithField("listen", c.Listen).Info("sftp server listening for connections")
-	log.WithField("listen", c.Listen).WithField("public_key", strings.Trim(public, "\n")).Info("sftp server listening for connections")
-
 	for {
 		if conn, _ := listener.Accept(); conn != nil {
 			go func(conn net.Conn) {
@@ -137,7 +132,7 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 			if uuid == "" {
 				return false
 			}
-			return s.ID() == uuid
+			return s.Id() == uuid
 		})
 		if srv == nil {
 			continue
@@ -145,37 +140,33 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 
 		// Spin up a SFTP server instance for the authenticated user's server allowing
 		// them access to the underlying filesystem.
-		handler := sftp.NewRequestServer(channel, NewHandler(sconn, srv).Handlers())
+		handler := sftp.NewRequestServer(channel, NewHandler(sconn, srv.Filesystem()).Handlers())
 		if err := handler.Serve(); err == io.EOF {
 			handler.Close()
 		}
 	}
 }
 
-// Generates a new ED25519 private key that is used for host authentication when
+// Generates a private key that will be used by the SFTP server.
-// a user connects to the SFTP server.
+func (c *SFTPServer) generatePrivateKey() error {
-func (c *SFTPServer) generateED25519PrivateKey() error {
+	key, err := rsa.GenerateKey(rand.Reader, 2048)
-	_, priv, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
-		return errors.Wrap(err, "sftp: failed to generate ED25519 private key")
+		return errors.WithStack(err)
 	}
-	if err := os.MkdirAll(path.Dir(c.PrivateKeyPath()), 0755); err != nil {
+	if err := os.MkdirAll(path.Join(c.BasePath, ".sftp"), 0755); err != nil {
-		return errors.Wrap(err, "sftp: could not create internal sftp data directory")
+		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
 	}
-	o, err := os.OpenFile(c.PrivateKeyPath(), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	o, err := os.OpenFile(path.Join(c.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {
 		return errors.WithStack(err)
 	}
 	defer o.Close()
 
-	b, err := x509.MarshalPKCS8PrivateKey(priv)
+	err = pem.Encode(o, &pem.Block{
-	if err != nil {
+		Type:  "RSA PRIVATE KEY",
-		return errors.Wrap(err, "sftp: failed to marshal private key into bytes")
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
-	}
+	})
-	if err := pem.Encode(o, &pem.Block{Type: "PRIVATE KEY", Bytes: b}); err != nil {
+	return errors.WithStack(err)
-		return errors.Wrap(err, "sftp: failed to write ED25519 private key to disk")
-	}
-	return nil
 }
 
 // A function capable of validating user credentials with the Panel API.
@@ -217,8 +208,3 @@ func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.
 
 	return sshPerm, nil
 }
-
-// PrivateKeyPath returns the path the host private key for this server instance.
-func (c *SFTPServer) PrivateKeyPath() string {
-	return path.Join(c.BasePath, ".sftp/id_ed25519")
-}