Refactor environment handling logic to separate a server from the environment handler itself

This change makes the environment handling logic execute independent of the server itself and should make it much easier for people to contribute changes and additional environment handlers down the road without polluting the server object even more.

There is still a lot of work to do on this front to make things easier to work with, and there are some questionable design decisions at play I'm sure.

Welcome to additional modifications and cleanup to make this code easier to reason about and work with.

server/server.go

@@ -7,6 +7,9 @@ import (
 	"github.com/patrickmn/go-cache"
 	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
+	"github.com/pterodactyl/wings/environment"
+	"github.com/pterodactyl/wings/environment/docker"
+	"github.com/pterodactyl/wings/events"
 	"golang.org/x/sync/semaphore"
 	"strings"
 	"sync"
@@ -18,8 +21,9 @@ type Server struct {
 	// Internal mutex used to block actions that need to occur sequentially, such as
 	// writing the configuration to the disk.
 	sync.RWMutex
-	emitterLock sync.Mutex
-	powerLock   *semaphore.Weighted
+	emitterLock  sync.Mutex
+	powerLock    *semaphore.Weighted
+	throttleLock sync.RWMutex
 
 	// Maintains the configuration for the server. This is the data that gets returned by the Panel
 	// such as build settings and container images.
@@ -29,16 +33,16 @@ type Server struct {
 	crasher CrashHandler
 
 	resources   ResourceUsage
-	Archiver    Archiver    `json:"-"`
-	Environment Environment `json:"-"`
-	Filesystem  Filesystem  `json:"-"`
+	Archiver    Archiver                       `json:"-"`
+	Environment environment.ProcessEnvironment `json:"-"`
+	Filesystem  Filesystem                     `json:"-"`
 
 	// Server cache used to store frequently requested information in memory and make
 	// certain long operations return faster. For example, FS disk space usage.
 	cache *cache.Cache
 
 	// Events emitted by the server instance.
-	emitter *EventBus
+	emitter *events.EventBus
 
 	// Defines the process configuration for the server instance. This is dynamically
 	// fetched from the Pterodactyl Server instance each time the server process is
@@ -50,6 +54,9 @@ type Server struct {
 	// installation process, for example when a server is deleted from the panel while the
 	// installer process is still running.
 	installer InstallerDetails
+
+	// The console throttler instance used to control outputs.
+	throttler *ConsoleThrottler
 }
 
 type InstallerDetails struct {
@@ -131,6 +138,13 @@ func (s *Server) SyncWithConfiguration(cfg *api.ServerConfigurationResponse) err
 	s.procConfig = cfg.ProcessConfiguration
 	s.Unlock()
 
+	// 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.SetStopConfiguration(&cfg.ProcessConfiguration.Stop)
+	}
+
 	return nil
 }
 
@@ -150,6 +164,11 @@ func (s *Server) IsBootable() bool {
 // Initalizes a server instance. This will run through and ensure that the environment
 // for the server is setup, and that all of the necessary files are created.
 func (s *Server) CreateEnvironment() error {
+	// Ensure the data directory exists before getting too far through this process.
+	if err := s.Filesystem.EnsureDataDirectory(); err != nil {
+		return errors.WithStack(err)
+	}
+
 	return s.Environment.Create()
 }
 
@@ -162,3 +181,7 @@ func (s *Server) GetProcessConfiguration() (*api.ServerConfigurationResponse, *a
 func (s *Server) IsSuspended() bool {
 	return s.Config().Suspended
 }
+
+func (s *Server) Build() *environment.Limits {
+	return &s.Config().Build
+}