Fix startup variables not being properly updated on server reboot; closes pterodactyl/panel#2255

server/update.go

@@ -15,7 +15,7 @@ import (
 // The server will be marked as requiring a rebuild on the next boot sequence,
 // it is up to the specific environment to determine what needs to happen when
 // that is the case.
-func (s *Server) UpdateDataStructure(data []byte, background bool) error {
+func (s *Server) UpdateDataStructure(data []byte) error {
 	src := new(Configuration)
 	if err := json.Unmarshal(data, src); err != nil {
 		return errors.WithStack(err)
@@ -97,36 +97,50 @@ func (s *Server) UpdateDataStructure(data []byte, background bool) error {
 	// Update the configuration once we have a lock on the configuration object.
 	s.cfg = c
 
-	if background {
-		go s.runBackgroundActions()
-	}
-
 	return nil
 }
 
-// Runs through different actions once a server's configuration has been persisted
-// to the disk. This function does not return anything as any failures should be logged
-// but have no effect on actually updating the server itself.
+// 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.
 //
-// These tasks run in independent threads where relevant to speed up any updates
-// that need to happen.
-func (s *Server) runBackgroundActions() {
-	// Check if the s is now suspended, and if so and the process is not terminated
-	// yet, do it immediately.
-	if s.IsSuspended() && s.GetState() != environment.ProcessOfflineState {
-		s.Log().Info("server suspended with running process state, terminating now")
+// 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")
 
-		if err := s.Environment.WaitForStop(10, true); err != nil {
-			s.Log().WithField("error", err).Warn("failed to terminate server environment after suspension")
-		}
-	}
+	// Update the environment settings using the new information from this server.
+	s.Environment.Config().SetSettings(environment.Settings{
+		Mounts:      s.Mounts(),
+		Allocations: s.Config().Allocations,
+		Limits:      s.Config().Build,
+	})
+
+	// 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.
+	//
+	// @see https://github.com/pterodactyl/panel/issues/2255
+	s.Environment.Config().SetEnvironmentVariables(s.GetEnvironmentVariables())
 
 	if !s.IsSuspended() {
 		// Update the environment in place, allowing memory and CPU usage to be adjusted
 		// on the fly without the user needing to reboot (theoretically).
 		s.Log().Info("performing server limit modification on-the-fly")
 		if err := s.Environment.InSituUpdate(); err != nil {
+			// This is not a failure, the process is still running fine and will fix itself on the
+			// next boot, or fail out entirely in a more logical position.
 			s.Log().WithField("error", err).Warn("failed to perform on-the-fly update of the server environment")
 		}
+	} else {
+		// Checks if the server is now in a suspended state. If so and a server process is currently running it
+		// will be gracefully stopped (and terminated if it refuses to stop).
+		s.Log().Info("server suspended with running process state, terminating now")
+
+		go func (s *Server) {
+			if err := s.Environment.WaitForStop(60, true); err != nil {
+				s.Log().WithField("error", err).Warn("failed to terminate server environment after suspension")
+			}
+		}(s)
 	}
 }