Merge pull request #3319 from volundmush/startup_refactor

Refactoring Server Startup to be more idiomatic for Twisted.

evennia/__init__.py

@@ -16,6 +16,7 @@ to launch such a shell (using python or ipython depending on your install).
 See www.evennia.com for full documentation.
 
 """
+import evennia
 
 # docstring header
 
@@ -47,6 +48,7 @@ AccountDB = None
 ScriptDB = None
 ChannelDB = None
 Msg = None
+ServerConfig = None
 
 # Properties
 AttributeProperty = None
@@ -98,6 +100,8 @@ FuncParser = None
 
 # Handlers
 SESSION_HANDLER = None
+PORTAL_SESSION_HANDLER = None
+SERVER_SESSION_HANDLER = None
 TASK_HANDLER = None
 TICKER_HANDLER = None
 MONITOR_HANDLER = None
@@ -106,8 +110,11 @@ MONITOR_HANDLER = None
 GLOBAL_SCRIPTS = None
 OPTION_CLASSES = None
 
-# variables
+PROCESS_ID = None
-PORTAL_MODE = False
+
+TWISTED_APPLICATION = None
+EVENNIA_PORTAL_SERVICE = None
+EVENNIA_SERVER_SERVICE = None
 
 
 def _create_version():
@@ -140,6 +147,10 @@ def _create_version():
 __version__ = _create_version()
 del _create_version
 
+_LOADED = False
+
+PORTAL_MODE = False
+
 
 def _init(portal_mode=False):
     """
@@ -147,6 +158,10 @@ def _init(portal_mode=False):
     Evennia has fully initialized all its models. It sets up the API
     in a safe environment where all models are available already.
     """
+    global _LOADED
+    if _LOADED:
+        return
+    _LOADED = True
     global DefaultAccount, DefaultObject, DefaultGuest, DefaultCharacter
     global DefaultRoom, DefaultExit, DefaultChannel, DefaultScript
     global ObjectDB, AccountDB, ScriptDB, ChannelDB, Msg
@@ -157,18 +172,19 @@ def _init(portal_mode=False):
     global create_message, create_help_entry
     global signals
     global settings, lockfuncs, logger, utils, gametime, ansi, spawn, managers
-    global contrib, TICKER_HANDLER, MONITOR_HANDLER, SESSION_HANDLER
+    global contrib, TICKER_HANDLER, MONITOR_HANDLER, SESSION_HANDLER, PROCESS_ID
-    global TASK_HANDLER
+    global TASK_HANDLER, PORTAL_SESSION_HANDLER, SERVER_SESSION_HANDLER
-    global GLOBAL_SCRIPTS, OPTION_CLASSES
+    global GLOBAL_SCRIPTS, OPTION_CLASSES, EVENNIA_PORTAL_SERVICE, EVENNIA_SERVER_SERVICE, TWISTED_APPLICATION
     global EvMenu, EvTable, EvForm, EvMore, EvEditor
     global ANSIString, FuncParser
-    global AttributeProperty, TagProperty, TagCategoryProperty
+    global AttributeProperty, TagProperty, TagCategoryProperty, ServerConfig
     global PORTAL_MODE
     PORTAL_MODE = portal_mode
 
     # Parent typeclasses
     # utilities
     from django.conf import settings
+    import os
 
     from . import contrib
     from .accounts.accounts import DefaultAccount, DefaultGuest
@@ -192,9 +208,10 @@ def _init(portal_mode=False):
     from .scripts.taskhandler import TASK_HANDLER
     from .scripts.tickerhandler import TICKER_HANDLER
     from .server import signals
+    from .server.models import ServerConfig
     from .typeclasses.attributes import AttributeProperty
     from .typeclasses.tags import TagCategoryProperty, TagProperty
-    from .utils import ansi, gametime, logger
+    from .utils import ansi, gametime, logger, class_from_module
     from .utils.ansi import ANSIString
 
     if not PORTAL_MODE:
@@ -229,12 +246,34 @@ def _init(portal_mode=False):
     )
     from .utils.utils import class_from_module
 
-    if PORTAL_MODE:
+    PROCESS_ID = os.getpid()
+
+    from twisted.application.service import Application
+
+    TWISTED_APPLICATION = Application("Evennia")
+
+    _evennia_service_class = None
+
+    if portal_mode:
         # Set up the PortalSessionHandler
         from evennia.server.portal import portalsessionhandler
 
         portal_sess_handler_class = class_from_module(settings.PORTAL_SESSION_HANDLER_CLASS)
         portalsessionhandler.PORTAL_SESSIONS = portal_sess_handler_class()
+        SESSION_HANDLER = portalsessionhandler.PORTAL_SESSIONS
+        evennia.PORTAL_SESSION_HANDLER = evennia.SESSION_HANDLER
+        _evennia_service_class = class_from_module(settings.EVENNIA_PORTAL_SERVICE_CLASS)
+        EVENNIA_PORTAL_SERVICE = _evennia_service_class()
+        EVENNIA_PORTAL_SERVICE.setServiceParent(TWISTED_APPLICATION)
+
+        from django.db import connection
+
+        # we don't need a connection to the database so close it right away
+        try:
+            connection.close()
+        except Exception:
+            pass
+
     else:
         # Create the ServerSesssionHandler
         from evennia.server import sessionhandler
@@ -243,6 +282,10 @@ def _init(portal_mode=False):
         sessionhandler.SESSIONS = sess_handler_class()
         sessionhandler.SESSION_HANDLER = sessionhandler.SESSIONS
         SESSION_HANDLER = sessionhandler.SESSIONS
+        SERVER_SESSION_HANDLER = SESSION_HANDLER
+        _evennia_service_class = class_from_module(settings.EVENNIA_SERVER_SERVICE_CLASS)
+        EVENNIA_SERVER_SERVICE = _evennia_service_class()
+        EVENNIA_SERVER_SERVICE.setServiceParent(TWISTED_APPLICATION)
 
     # API containers
 

evennia/server/amp_client.py

@@ -9,6 +9,7 @@ import os
 from django.conf import settings
 from twisted.internet import protocol
 
+import evennia
 from evennia.server.portal import amp
 from evennia.utils import logger
 from evennia.utils.utils import class_from_module
@@ -188,9 +189,9 @@ class AMPServerClientProtocol(amp.AMPMultiConnectionProtocol):
 
         """
         sessid, kwargs = self.data_in(packed_data)
-        session = self.factory.server.sessions.get(sessid, None)
+        session = evennia.SERVER_SESSION_HANDLER.get(sessid, None)
         if session:
-            self.factory.server.sessions.data_in(session, **kwargs)
+            evennia.SERVER_SESSION_HANDLER.data_in(session, **kwargs)
         return {}
 
     @amp.AdminPortal2Server.responder
@@ -207,46 +208,45 @@ class AMPServerClientProtocol(amp.AMPMultiConnectionProtocol):
         """
         sessid, kwargs = self.data_in(packed_data)
         operation = kwargs.pop("operation", "")
-        server_sessionhandler = self.factory.server.sessions
 
         if operation == amp.PCONN:  # portal_session_connect
             # create a new session and sync it
-            server_sessionhandler.portal_connect(kwargs.get("sessiondata"))
+            evennia.SERVER_SESSION_HANDLER.portal_connect(kwargs.get("sessiondata"))
 
         elif operation == amp.PCONNSYNC:  # portal_session_sync
-            server_sessionhandler.portal_session_sync(kwargs.get("sessiondata"))
+            evennia.SERVER_SESSION_HANDLER.portal_session_sync(kwargs.get("sessiondata"))
 
         elif operation == amp.PDISCONN:  # portal_session_disconnect
             # session closed from portal sid
-            session = server_sessionhandler.get(sessid)
+            session = evennia.SERVER_SESSION_HANDLER.get(sessid)
             if session:
-                server_sessionhandler.portal_disconnect(session)
+                evennia.SERVER_SESSION_HANDLER.portal_disconnect(session)
 
         elif operation == amp.PDISCONNALL:  # portal_disconnect_all
             # portal orders all sessions to close
-            server_sessionhandler.portal_disconnect_all()
+            evennia.SERVER_SESSION_HANDLER.portal_disconnect_all()
 
         elif operation == amp.PSYNC:  # portal_session_sync
             # force a resync of sessions from the portal side. This happens on
             # first server-connect.
             server_restart_mode = kwargs.get("server_restart_mode", "shutdown")
-            self.factory.server.run_init_hooks(server_restart_mode)
+            evennia.EVENNIA_SERVER_SERVICE.run_init_hooks(server_restart_mode)
-            server_sessionhandler.portal_sessions_sync(kwargs.get("sessiondata"))
+            evennia.SERVER_SESSION_HANDLER.portal_sessions_sync(kwargs.get("sessiondata"))
-            server_sessionhandler.portal_start_time = kwargs.get("portal_start_time")
+            evennia.SERVER_SESSION_HANDLER.portal_start_time = kwargs.get("portal_start_time")
 
         elif operation == amp.SRELOAD:  # server reload
             # shut down in reload mode
-            server_sessionhandler.all_sessions_portal_sync()
+            evennia.SERVER_SESSION_HANDLER.all_sessions_portal_sync()
-            server_sessionhandler.server.shutdown(mode="reload")
+            evennia.EVENNIA_SERVER_SERVICE.shutdown(mode="reload")
 
         elif operation == amp.SRESET:
             # shut down in reset mode
-            server_sessionhandler.all_sessions_portal_sync()
+            evennia.SERVER_SESSION_HANDLER.all_sessions_portal_sync()
-            server_sessionhandler.server.shutdown(mode="reset")
+            evennia.EVENNIA_SERVER_SERVICE.shutdown(mode="reset")
 
         elif operation == amp.SSHUTD:  # server shutdown
             # shutdown in stop mode
-            server_sessionhandler.server.shutdown(mode="shutdown")
+            evennia.EVENNIA_SERVER_SERVICE.shutdown(mode="shutdown")
 
         else:
             raise Exception("operation %(op)s not recognized." % {"op": operation})

evennia/server/initial_setup.py

@@ -174,6 +174,8 @@ def reset_server():
     also checks so the warm-reset mechanism works as it should.
 
     """
+    if settings._TEST_ENVIRONMENT:
+        return
     ServerConfig.objects.conf("server_epoch", time.time())
 
     logger.log_info("Initial setup complete. Restarting Server once.")
@@ -191,12 +193,6 @@ def handle_setup(last_step=None):
             the function will exit immediately.
 
     """
-    if last_step in ("done", -1):
-        # this means we don't need to handle setup since
-        # it already ran sucessfully once. -1 is the legacy
-        # value for existing databases.
-        return
-
     # setup sequence
     setup_sequence = {
         "create_objects": create_objects,
@@ -205,6 +201,12 @@ def handle_setup(last_step=None):
         "done": reset_server,
     }
 
+    if last_step in ("done", -1):
+        # this means we don't need to handle setup since
+        # it already ran sucessfully once. -1 is the legacy
+        # value for existing databases.
+        return
+
     # determine the sequence so we can skip ahead
     steps = list(setup_sequence)
     steps = steps[steps.index(last_step) + 1 if last_step is not None else 0 :]

evennia/server/portal/amp_server.py

@@ -11,6 +11,7 @@ from subprocess import STDOUT, Popen
 from django.conf import settings
 from twisted.internet import protocol
 
+import evennia
 from evennia.server.portal import amp
 from evennia.utils import logger
 from evennia.utils.utils import class_from_module
@@ -379,9 +380,9 @@ class AMPServerProtocol(amp.AMPMultiConnectionProtocol):
         """
         try:
             sessid, kwargs = self.data_in(packed_data)
-            session = self.factory.portal.sessions.get(sessid, None)
+            session = evennia.PORTAL_SESSION_HANDLER.get(sessid, None)
             if session:
-                self.factory.portal.sessions.data_out(session, **kwargs)
+                evennia.PORTAL_SESSION_HANDLER.data_out(session, **kwargs)
         except Exception:
             logger.log_trace("packed_data len {}".format(len(packed_data)))
         return {}
@@ -405,7 +406,7 @@ class AMPServerProtocol(amp.AMPMultiConnectionProtocol):
         # logger.log_msg("Evennia Server->Portal admin data %s:%s received" % (sessid, kwargs))
 
         operation = kwargs.pop("operation")
-        portal_sessionhandler = self.factory.portal.sessions
+        portal_sessionhandler = evennia.PORTAL_SESSION_HANDLER
 
         if operation == amp.SLOGIN:  # server_session_login
             # a session has authenticated; sync it.
@@ -449,7 +450,7 @@ class AMPServerProtocol(amp.AMPMultiConnectionProtocol):
             # this defaults to 'shutdown' or whatever value set in server_stop
             server_restart_mode = self.factory.portal.server_restart_mode
 
-            sessdata = self.factory.portal.sessions.get_all_sync_data()
+            sessdata = evennia.PORTAL_SESSION_HANDLER.get_all_sync_data()
             self.send_AdminPortal2Server(
                 amp.DUMMYSESSION,
                 amp.PSYNC,
@@ -457,7 +458,7 @@ class AMPServerProtocol(amp.AMPMultiConnectionProtocol):
                 sessiondata=sessdata,
                 portal_start_time=self.factory.portal.start_time,
             )
-            self.factory.portal.sessions.at_server_connection()
+            evennia.PORTAL_SESSION_HANDLER.at_server_connection()
 
             if self.factory.server_connection:
                 # this is an indication the server has successfully connected, so

evennia/server/portal/portal.py

@@ -9,243 +9,23 @@ by game/evennia.py).
 """
 import os
 import sys
-import time
-from os.path import abspath, dirname
 
-import django
-from twisted.application import internet, service
-from twisted.internet import protocol, reactor
-from twisted.internet.task import LoopingCall
 from twisted.logger import globalLogPublisher
 
+import django
 django.setup()
-from django.conf import settings
-from django.db import connection
 
 import evennia
-
 evennia._init(portal_mode=True)
-from evennia.server.portal.portalsessionhandler import PORTAL_SESSIONS
+
-from evennia.server.webserver import EvenniaReverseProxyResource
+from django.conf import settings
 from evennia.utils import logger
-from evennia.utils.utils import (
-    class_from_module,
-    get_evennia_version,
-    make_iter,
-    mod_import,
-)
-
-# we don't need a connection to the database so close it right away
-try:
-    connection.close()
-except Exception:
-    pass
-
-PORTAL_SERVICES_PLUGIN_MODULES = [
-    mod_import(module) for module in make_iter(settings.PORTAL_SERVICES_PLUGIN_MODULES)
-]
-LOCKDOWN_MODE = settings.LOCKDOWN_MODE
-
-# -------------------------------------------------------------
-# Evennia Portal settings
-# -------------------------------------------------------------
-
-VERSION = get_evennia_version()
-
-SERVERNAME = settings.SERVERNAME
-
-PORTAL_RESTART = os.path.join(settings.GAME_DIR, "server", "portal.restart")
-
-TELNET_PORTS = settings.TELNET_PORTS
-SSL_PORTS = settings.SSL_PORTS
-SSH_PORTS = settings.SSH_PORTS
-WEBSERVER_PORTS = settings.WEBSERVER_PORTS
-WEBSOCKET_CLIENT_PORT = settings.WEBSOCKET_CLIENT_PORT
-
-TELNET_INTERFACES = ["127.0.0.1"] if LOCKDOWN_MODE else settings.TELNET_INTERFACES
-SSL_INTERFACES = ["127.0.0.1"] if LOCKDOWN_MODE else settings.SSL_INTERFACES
-SSH_INTERFACES = ["127.0.0.1"] if LOCKDOWN_MODE else settings.SSH_INTERFACES
-WEBSERVER_INTERFACES = ["127.0.0.1"] if LOCKDOWN_MODE else settings.WEBSERVER_INTERFACES
-WEBSOCKET_CLIENT_INTERFACE = "127.0.0.1" if LOCKDOWN_MODE else settings.WEBSOCKET_CLIENT_INTERFACE
-WEBSOCKET_CLIENT_URL = settings.WEBSOCKET_CLIENT_URL
-
-TELNET_ENABLED = settings.TELNET_ENABLED and TELNET_PORTS and TELNET_INTERFACES
-SSL_ENABLED = settings.SSL_ENABLED and SSL_PORTS and SSL_INTERFACES
-SSH_ENABLED = settings.SSH_ENABLED and SSH_PORTS and SSH_INTERFACES
-WEBSERVER_ENABLED = settings.WEBSERVER_ENABLED and WEBSERVER_PORTS and WEBSERVER_INTERFACES
-WEBCLIENT_ENABLED = settings.WEBCLIENT_ENABLED
-WEBSOCKET_CLIENT_ENABLED = (
-    settings.WEBSOCKET_CLIENT_ENABLED and WEBSOCKET_CLIENT_PORT and WEBSOCKET_CLIENT_INTERFACE
-)
-
-AMP_HOST = settings.AMP_HOST
-AMP_PORT = settings.AMP_PORT
-AMP_INTERFACE = settings.AMP_INTERFACE
-AMP_ENABLED = AMP_HOST and AMP_PORT and AMP_INTERFACE
-
-INFO_DICT = {
-    "servername": SERVERNAME,
-    "version": VERSION,
-    "errors": "",
-    "info": "",
-    "lockdown_mode": "",
-    "amp": "",
-    "telnet": [],
-    "telnet_ssl": [],
-    "ssh": [],
-    "webclient": [],
-    "webserver_proxy": [],
-    "webserver_internal": [],
-}
-
-try:
-    WEB_PLUGINS_MODULE = mod_import(settings.WEB_PLUGINS_MODULE)
-except ImportError:
-    WEB_PLUGINS_MODULE = None
-    INFO_DICT["errors"] = (
-        "WARNING: settings.WEB_PLUGINS_MODULE not found - "
-        "copy 'evennia/game_template/server/conf/web_plugins.py to "
-        "mygame/server/conf."
-    )
-
-
-_MAINTENANCE_COUNT = 0
-
-
-def _portal_maintenance():
-    """
-    Repeated maintenance tasks for the portal.
-
-    """
-    global _MAINTENANCE_COUNT
-
-    _MAINTENANCE_COUNT += 1
-
-    if _MAINTENANCE_COUNT % (60 * 7) == 0:
-        # drop database connection every 7 hrs to avoid default timeouts on MySQL
-        # (see https://github.com/evennia/evennia/issues/1376)
-        connection.close()
-
-
-# -------------------------------------------------------------
-# Portal Service object
-# -------------------------------------------------------------
-
-
-class Portal(object):
-
-    """
-    The main Portal server handler. This object sets up the database
-    and tracks and interlinks all the twisted network services that
-    make up Portal.
-
-    """
-
-    def __init__(self, application):
-        """
-        Setup the server.
-
-        Args:
-            application (Application): An instantiated Twisted application
-
-        """
-        sys.path.append(".")
-
-        # create a store of services
-        self.services = service.MultiService()
-        self.services.setServiceParent(application)
-        self.amp_protocol = None  # set by amp factory
-        self.sessions = PORTAL_SESSIONS
-        self.sessions.portal = self
-        self.process_id = os.getpid()
-
-        self.server_process_id = None
-        self.server_restart_mode = "shutdown"
-        self.server_info_dict = {}
-
-        self.start_time = time.time()
-
-        self.maintenance_task = LoopingCall(_portal_maintenance)
-        self.maintenance_task.start(60, now=True)  # call every minute
-
-        # in non-interactive portal mode, this gets overwritten by
-        # cmdline sent by the evennia launcher
-        self.server_twistd_cmd = self._get_backup_server_twistd_cmd()
-
-        # set a callback if the server is killed abruptly,
-        # by Ctrl-C, reboot etc.
-        reactor.addSystemEventTrigger(
-            "before", "shutdown", self.shutdown, _reactor_stopping=True, _stop_server=True
-        )
-
-    def _get_backup_server_twistd_cmd(self):
-        """
-        For interactive Portal mode there is no way to get the server cmdline from the launcher, so
-        we need to guess it here (it's very likely to not change)
-
-        Returns:
-            server_twistd_cmd (list): An instruction for starting the server, to pass to Popen.
-
-        """
-        server_twistd_cmd = [
-            "twistd",
-            "--python={}".format(os.path.join(dirname(dirname(abspath(__file__))), "server.py")),
-        ]
-        if os.name != "nt":
-            gamedir = os.getcwd()
-            server_twistd_cmd.append(
-                "--pidfile={}".format(os.path.join(gamedir, "server", "server.pid"))
-            )
-        return server_twistd_cmd
-
-    def get_info_dict(self):
-        """
-        Return the Portal info, for display.
-
-        """
-        return INFO_DICT
-
-    def shutdown(self, _reactor_stopping=False, _stop_server=False):
-        """
-        Shuts down the server from inside it.
-
-        Args:
-            _reactor_stopping (bool, optional): This is set if server
-                is already in the process of shutting down; in this case
-                we don't need to stop it again.
-            _stop_server (bool, optional): Only used in portal-interactive mode;
-                makes sure to stop the Server cleanly.
-
-        Note that restarting (regardless of the setting) will not work
-        if the Portal is currently running in daemon mode. In that
-        case it always needs to be restarted manually.
-
-        """
-        if _reactor_stopping and hasattr(self, "shutdown_complete"):
-            # we get here due to us calling reactor.stop below. No need
-            # to do the shutdown procedure again.
-            return
-
-        self.sessions.disconnect_all()
-        if _stop_server:
-            self.amp_protocol.stop_server(mode="shutdown")
-        if not _reactor_stopping:
-            # shutting down the reactor will trigger another signal. We set
-            # a flag to avoid loops.
-            self.shutdown_complete = True
-            reactor.callLater(0, reactor.stop)
-
-
-# -------------------------------------------------------------
-#
-# Start the Portal proxy server and add all active services
-#
-# -------------------------------------------------------------
-
 
 # twistd requires us to define the variable 'application' so it knows
 # what to execute from.
-application = service.Application("Portal")
+# The guts of the application are in the service.py file,
+# which is instantiated and attached to application in evennia._init()
+application = evennia.TWISTED_APPLICATION
 
 
 if "--nodaemon" not in sys.argv and "test" not in sys.argv:
@@ -257,186 +37,3 @@ if "--nodaemon" not in sys.argv and "test" not in sys.argv:
         max_size=settings.PORTAL_LOG_MAX_SIZE,
     )
     globalLogPublisher.addObserver(logger.GetPortalLogObserver()(logfile))
-
-# The main Portal server program. This sets up the database
-# and is where we store all the other services.
-PORTAL = Portal(application)
-
-if LOCKDOWN_MODE:
-    INFO_DICT["lockdown_mode"] = "  LOCKDOWN_MODE active: Only local connections."
-
-if AMP_ENABLED:
-    # The AMP protocol handles the communication between
-    # the portal and the mud server. Only reason to ever deactivate
-    # it would be during testing and debugging.
-
-    from evennia.server.portal import amp_server
-
-    INFO_DICT["amp"] = "amp: %s" % AMP_PORT
-
-    factory = amp_server.AMPServerFactory(PORTAL)
-    amp_service = internet.TCPServer(AMP_PORT, factory, interface=AMP_INTERFACE)
-    amp_service.setName("PortalAMPServer")
-    PORTAL.services.addService(amp_service)
-
-
-# We group all the various services under the same twisted app.
-# These will gradually be started as they are initialized below.
-
-if TELNET_ENABLED:
-    # Start telnet game connections
-
-    from evennia.server.portal import telnet
-
-    _telnet_protocol = class_from_module(settings.TELNET_PROTOCOL_CLASS)
-
-    for interface in TELNET_INTERFACES:
-        ifacestr = ""
-        if interface not in ("0.0.0.0", "::") or len(TELNET_INTERFACES) > 1:
-            ifacestr = "-%s" % interface
-        for port in TELNET_PORTS:
-            pstring = "%s:%s" % (ifacestr, port)
-            factory = telnet.TelnetServerFactory()
-            factory.noisy = False
-            factory.protocol = _telnet_protocol
-            factory.sessionhandler = PORTAL_SESSIONS
-            telnet_service = internet.TCPServer(port, factory, interface=interface)
-            telnet_service.setName("EvenniaTelnet%s" % pstring)
-            PORTAL.services.addService(telnet_service)
-
-            INFO_DICT["telnet"].append("telnet%s: %s" % (ifacestr, port))
-
-
-if SSL_ENABLED:
-    # Start Telnet+SSL game connection (requires PyOpenSSL).
-
-    from evennia.server.portal import telnet_ssl
-
-    _ssl_protocol = class_from_module(settings.SSL_PROTOCOL_CLASS)
-
-    for interface in SSL_INTERFACES:
-        ifacestr = ""
-        if interface not in ("0.0.0.0", "::") or len(SSL_INTERFACES) > 1:
-            ifacestr = "-%s" % interface
-        for port in SSL_PORTS:
-            pstring = "%s:%s" % (ifacestr, port)
-            factory = protocol.ServerFactory()
-            factory.noisy = False
-            factory.sessionhandler = PORTAL_SESSIONS
-            factory.protocol = _ssl_protocol
-
-            ssl_context = telnet_ssl.getSSLContext()
-            if ssl_context:
-                ssl_service = internet.SSLServer(
-                    port, factory, telnet_ssl.getSSLContext(), interface=interface
-                )
-                ssl_service.setName("EvenniaSSL%s" % pstring)
-                PORTAL.services.addService(ssl_service)
-
-                INFO_DICT["telnet_ssl"].append("telnet+ssl%s: %s" % (ifacestr, port))
-            else:
-                INFO_DICT["telnet_ssl"].append(
-                    "telnet+ssl%s: %s (deactivated - keys/cert unset)" % (ifacestr, port)
-                )
-
-
-if SSH_ENABLED:
-    # Start SSH game connections. Will create a keypair in
-    # evennia/game if necessary.
-
-    from evennia.server.portal import ssh
-
-    _ssh_protocol = class_from_module(settings.SSH_PROTOCOL_CLASS)
-
-    for interface in SSH_INTERFACES:
-        ifacestr = ""
-        if interface not in ("0.0.0.0", "::") or len(SSH_INTERFACES) > 1:
-            ifacestr = "-%s" % interface
-        for port in SSH_PORTS:
-            pstring = "%s:%s" % (ifacestr, port)
-            factory = ssh.makeFactory(
-                {"protocolFactory": _ssh_protocol, "protocolArgs": (), "sessions": PORTAL_SESSIONS}
-            )
-            factory.noisy = False
-            ssh_service = internet.TCPServer(port, factory, interface=interface)
-            ssh_service.setName("EvenniaSSH%s" % pstring)
-            PORTAL.services.addService(ssh_service)
-
-            INFO_DICT["ssh"].append("ssh%s: %s" % (ifacestr, port))
-
-
-if WEBSERVER_ENABLED:
-    from evennia.server.webserver import Website
-
-    # Start a reverse proxy to relay data to the Server-side webserver
-
-    websocket_started = False
-    _websocket_protocol = class_from_module(settings.WEBSOCKET_PROTOCOL_CLASS)
-    for interface in WEBSERVER_INTERFACES:
-        ifacestr = ""
-        if interface not in ("0.0.0.0", "::") or len(WEBSERVER_INTERFACES) > 1:
-            ifacestr = "-%s" % interface
-        for proxyport, serverport in WEBSERVER_PORTS:
-            web_root = EvenniaReverseProxyResource("127.0.0.1", serverport, "")
-            webclientstr = ""
-            if WEBCLIENT_ENABLED:
-                # create ajax client processes at /webclientdata
-                from evennia.server.portal import webclient_ajax
-
-                ajax_webclient = webclient_ajax.AjaxWebClient()
-                ajax_webclient.sessionhandler = PORTAL_SESSIONS
-                web_root.putChild(b"webclientdata", ajax_webclient)
-                webclientstr = "webclient (ajax only)"
-
-                if WEBSOCKET_CLIENT_ENABLED and not websocket_started:
-                    # start websocket client port for the webclient
-                    # we only support one websocket client
-                    from autobahn.twisted.websocket import WebSocketServerFactory
-
-                    from evennia.server.portal import webclient  # noqa
-
-                    w_interface = WEBSOCKET_CLIENT_INTERFACE
-                    w_ifacestr = ""
-                    if w_interface not in ("0.0.0.0", "::") or len(WEBSERVER_INTERFACES) > 1:
-                        w_ifacestr = "-%s" % w_interface
-                    port = WEBSOCKET_CLIENT_PORT
-
-                    class Websocket(WebSocketServerFactory):
-                        "Only here for better naming in logs"
-                        pass
-
-                    factory = Websocket()
-                    factory.noisy = False
-                    factory.protocol = _websocket_protocol
-                    factory.sessionhandler = PORTAL_SESSIONS
-                    websocket_service = internet.TCPServer(port, factory, interface=w_interface)
-                    websocket_service.setName("EvenniaWebSocket%s:%s" % (w_ifacestr, port))
-                    PORTAL.services.addService(websocket_service)
-                    websocket_started = True
-                    webclientstr = "webclient-websocket%s: %s" % (w_ifacestr, port)
-                INFO_DICT["webclient"].append(webclientstr)
-
-            if WEB_PLUGINS_MODULE:
-                try:
-                    web_root = WEB_PLUGINS_MODULE.at_webproxy_root_creation(web_root)
-                except Exception:
-                    # Legacy user has not added an at_webproxy_root_creation function in existing
-                    # web plugins file
-                    INFO_DICT["errors"] = (
-                        "WARNING: WEB_PLUGINS_MODULE is enabled but at_webproxy_root_creation() "
-                        "not found copy 'evennia/game_template/server/conf/web_plugins.py to "
-                        "mygame/server/conf."
-                    )
-            web_root = Website(web_root, logPath=settings.HTTP_LOG_FILE)
-            web_root.is_portal = True
-            proxy_service = internet.TCPServer(proxyport, web_root, interface=interface)
-            proxy_service.setName("EvenniaWebProxy%s:%s" % (ifacestr, proxyport))
-            PORTAL.services.addService(proxy_service)
-            INFO_DICT["webserver_proxy"].append("webserver-proxy%s: %s" % (ifacestr, proxyport))
-            INFO_DICT["webserver_internal"].append("webserver: %s" % serverport)
-
-
-for plugin_module in PORTAL_SERVICES_PLUGIN_MODULES:
-    # external plugin services to start
-    if plugin_module:
-        plugin_module.start_plugin_services(PORTAL)

evennia/server/portal/portalsessionhandler.py

@@ -11,6 +11,7 @@ from django.conf import settings
 from django.utils.translation import gettext as _
 from twisted.internet import reactor
 
+import evennia
 from evennia.server.portal.amp import PCONN, PCONNSYNC, PDISCONN, PDISCONNALL
 from evennia.server.sessionhandler import SessionHandler
 from evennia.utils.logger import log_trace
@@ -62,7 +63,6 @@ class PortalSessionHandler(SessionHandler):
 
         """
         super().__init__(*args, **kwargs)
-        self.portal = None
         self.latest_sessid = 0
         self.uptime = time.time()
         self.connection_time = 0
@@ -132,7 +132,7 @@ class PortalSessionHandler(SessionHandler):
         now = time.time()
         if (
             now - self.connection_last < _MIN_TIME_BETWEEN_CONNECTS
-        ) or not self.portal.amp_protocol:
+        ) or not evennia.EVENNIA_PORTAL_SERVICE.amp_protocol:
             if not session or not self.connection_task:
                 self.connection_task = reactor.callLater(
                     _MIN_TIME_BETWEEN_CONNECTS, self.connect, None
@@ -156,7 +156,7 @@ class PortalSessionHandler(SessionHandler):
 
             self[session.sessid] = session
             session.server_connected = True
-            self.portal.amp_protocol.send_AdminPortal2Server(
+            evennia.EVENNIA_PORTAL_SERVICE.amp_protocol.send_AdminPortal2Server(
                 session, operation=PCONN, sessiondata=sessdata
             )
 
@@ -175,7 +175,7 @@ class PortalSessionHandler(SessionHandler):
             # once to the server - if so we must re-sync woth the server, otherwise
             # we skip this step.
             sessdata = session.get_sync_data()
-            if self.portal.amp_protocol:
+            if evennia.EVENNIA_PORTAL_SERVICE.amp_protocol:
                 # we only send sessdata that should not have changed
                 # at the server level at this point
                 sessdata = dict(
@@ -192,7 +192,7 @@ class PortalSessionHandler(SessionHandler):
                         "server_data",
                     )
                 )
-                self.portal.amp_protocol.send_AdminPortal2Server(
+                evennia.EVENNIA_PORTAL_SERVICE.amp_protocol.send_AdminPortal2Server(
                     session, operation=PCONNSYNC, sessiondata=sessdata
                 )
 
@@ -222,13 +222,17 @@ class PortalSessionHandler(SessionHandler):
             del self[session.sessid]
 
         # Tell the Server to disconnect its version of the Session as well.
-        self.portal.amp_protocol.send_AdminPortal2Server(session, operation=PDISCONN)
+        evennia.EVENNIA_PORTAL_SERVICE.amp_protocol.send_AdminPortal2Server(
+            session, operation=PDISCONN
+        )
 
     def disconnect_all(self):
         """
         Disconnect all sessions, informing the Server.
 
         """
+        if settings._TEST_ENVIRONMENT:
+            return
 
         def _callback(result, sessionhandler):
             # we set a watchdog to stop self.disconnect from deleting
@@ -240,7 +244,8 @@ class PortalSessionHandler(SessionHandler):
 
         # inform Server; wait until finished sending before we continue
         # removing all the sessions.
-        self.portal.amp_protocol.send_AdminPortal2Server(
+
+        evennia.EVENNIA_PORTAL_SERVICE.amp_protocol.send_AdminPortal2Server(
             DUMMYSESSION, operation=PDISCONNALL
         ).addCallback(_callback, self)
 
@@ -434,7 +439,7 @@ class PortalSessionHandler(SessionHandler):
                 self.data_out(session, text=[[_ERROR_COMMAND_OVERFLOW], {}])
                 return
 
-            if not self.portal.amp_protocol:
+            if not evennia.EVENNIA_PORTAL_SERVICE.amp_protocol:
                 # this can happen if someone connects before AMP connection
                 # was established (usually on first start)
                 reactor.callLater(1.0, self.data_in, session, **kwargs)
@@ -445,7 +450,7 @@ class PortalSessionHandler(SessionHandler):
 
             # relay data to Server
             session.cmd_last = now
-            self.portal.amp_protocol.send_MsgPortal2Server(session, **kwargs)
+            evennia.EVENNIA_PORTAL_SERVICE.amp_protocol.send_MsgPortal2Server(session, **kwargs)
 
             # eventual local echo (text input only)
             if "text" in kwargs and session.protocol_flags.get("LOCALECHO", False):

evennia/server/portal/service.py

@@ -0,0 +1,346 @@
+import os
+import sys
+import time
+from os.path import abspath, dirname
+from twisted.application.service import MultiService
+from django.conf import settings
+from django.db import connection
+from twisted.application import internet, service
+from twisted.internet import protocol, reactor
+from twisted.internet.task import LoopingCall
+import evennia
+from evennia.utils.utils import (
+    class_from_module,
+    get_evennia_version,
+    make_iter,
+    mod_import,
+)
+
+
+class EvenniaPortalService(MultiService):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.amp_protocol = None
+        self.server_process_id = None
+        self.server_restart_mode = "shutdown"
+        self.server_info_dict = dict()
+
+        self.start_time = 0
+        self._maintenance_count = 0
+        self.maintenance_task = None
+
+        self.info_dict = {
+            "servername": settings.SERVERNAME,
+            "version": get_evennia_version(),
+            "errors": "",
+            "info": "",
+            "lockdown_mode": "",
+            "amp": "",
+            "telnet": [],
+            "telnet_ssl": [],
+            "ssh": [],
+            "webclient": [],
+            "webserver_proxy": [],
+            "webserver_internal": [],
+        }
+
+        # in non-interactive portal mode, this gets overwritten by
+        # cmdline sent by the evennia launcher
+        self.server_twistd_cmd = self._get_backup_server_twistd_cmd()
+
+    def portal_maintenance(self):
+        """
+        Repeated maintenance tasks for the portal.
+
+        """
+
+        self._maintenance_count += 1
+
+        if self._maintenance_count % (60 * 7) == 0:
+            # drop database connection every 7 hrs to avoid default timeouts on MySQL
+            # (see https://github.com/evennia/evennia/issues/1376)
+            connection.close()
+
+    def privilegedStartService(self):
+        self.start_time = time.time()
+        self.maintenance_task = LoopingCall(self.portal_maintenance)
+        self.maintenance_task.start(60, now=True)  # call every minute
+        # set a callback if the server is killed abruptly,
+        # by Ctrl-C, reboot etc.
+        reactor.addSystemEventTrigger(
+            "before", "shutdown", self.shutdown, _reactor_stopping=True, _stop_server=True
+        )
+
+        if settings.AMP_HOST and settings.AMP_PORT and settings.AMP_INTERFACE:
+            self.register_amp()
+
+        if settings.TELNET_ENABLED and settings.TELNET_PORTS and settings.TELNET_INTERFACES:
+            self.register_telnet()
+
+        if settings.SSL_ENABLED and settings.SSL_PORTS and settings.SSL_INTERFACES:
+            self.register_ssl()
+        
+        if settings.SSH_ENABLED and settings.SSH_PORTS and settings.SSH_INTERFACES:
+            self.register_ssh()
+            
+        if settings.WEBSERVER_ENABLED:
+            self.register_webserver()
+
+        if settings.LOCKDOWN_MODE:
+            self.info_dict["lockdown_mode"] = "  LOCKDOWN_MODE active: Only local connections."
+
+        super().privilegedStartService()
+
+    def register_plugins(self):
+        PORTAL_SERVICES_PLUGIN_MODULES = [
+            mod_import(module) for module in make_iter(settings.PORTAL_SERVICES_PLUGIN_MODULES)
+        ]
+        for plugin_module in PORTAL_SERVICES_PLUGIN_MODULES:
+            # external plugin services to start
+            if plugin_module:
+                plugin_module.start_plugin_services(self)
+
+    def check_lockdown(self, interfaces: list[str]):
+        if settings.LOCKDOWN_MODE:
+            return ["127.0.0.1"]
+        return interfaces
+    
+    def register_ssl(self):
+
+        # Start Telnet+SSL game connection (requires PyOpenSSL).
+
+        from evennia.server.portal import telnet_ssl
+
+        _ssl_protocol = class_from_module(settings.SSL_PROTOCOL_CLASS)
+        
+        interfaces = self.check_lockdown(settings.SSL_INTERFACES)
+        
+        for interface in interfaces:
+            ifacestr = ""
+            if interface not in ("0.0.0.0", "::") or len(interfaces) > 1:
+                ifacestr = "-%s" % interface
+            for port in settings.SSL_PORTS:
+                pstring = "%s:%s" % (ifacestr, port)
+                factory = protocol.ServerFactory()
+                factory.noisy = False
+                factory.sessionhandler = evennia.PORTAL_SESSION_HANDLER
+                factory.protocol = _ssl_protocol
+
+                ssl_context = telnet_ssl.getSSLContext()
+                if ssl_context:
+                    ssl_service = internet.SSLServer(
+                        port, factory, telnet_ssl.getSSLContext(), interface=interface
+                    )
+                    ssl_service.setName("EvenniaSSL%s" % pstring)
+                    ssl_service.setServiceParent(self)
+
+                    self.info_dict["telnet_ssl"].append("telnet+ssl%s: %s" % (ifacestr, port))
+                else:
+                    self.info_dict["telnet_ssl"].append(
+                        "telnet+ssl%s: %s (deactivated - keys/cert unset)" % (ifacestr, port)
+                    )
+
+    def register_ssh(self):
+        # Start SSH game connections. Will create a keypair in
+        # evennia/game if necessary.
+
+        from evennia.server.portal import ssh
+
+        _ssh_protocol = class_from_module(settings.SSH_PROTOCOL_CLASS)
+        
+        interfaces = self.check_lockdown(settings.SSH_INTERFACES)
+        
+        for interface in interfaces:
+            ifacestr = ""
+            if interface not in ("0.0.0.0", "::") or len(interfaces) > 1:
+                ifacestr = "-%s" % interface
+            for port in settings.SSH_PORTS:
+                pstring = "%s:%s" % (ifacestr, port)
+                factory = ssh.makeFactory(
+                    {"protocolFactory": _ssh_protocol, "protocolArgs": (), "sessions": evennia.PORTAL_SESSION_HANDLER}
+                )
+                factory.noisy = False
+                ssh_service = internet.TCPServer(port, factory, interface=interface)
+                ssh_service.setName("EvenniaSSH%s" % pstring)
+                ssh_service.setServiceParent(self)
+
+                self.info_dict["ssh"].append("ssh%s: %s" % (ifacestr, port))
+
+    def register_webserver(self):
+        from evennia.server.webserver import Website, EvenniaReverseProxyResource
+
+        # Start a reverse proxy to relay data to the Server-side webserver
+        interfaces = self.check_lockdown(settings.WEBSERVER_INTERFACES)
+        websocket_started = False
+        _websocket_protocol = class_from_module(settings.WEBSOCKET_PROTOCOL_CLASS)
+        for interface in interfaces:
+            ifacestr = ""
+            if interface not in ("0.0.0.0", "::") or len(interfaces) > 1:
+                ifacestr = "-%s" % interface
+                
+            for proxyport, serverport in settings.WEBSERVER_PORTS:
+                web_root = EvenniaReverseProxyResource("127.0.0.1", serverport, "")
+                webclientstr = ""
+                if settings.WEBCLIENT_ENABLED:
+                    # create ajax client processes at /webclientdata
+                    from evennia.server.portal import webclient_ajax
+
+                    ajax_webclient = webclient_ajax.AjaxWebClient()
+                    ajax_webclient.sessionhandler = evennia.PORTAL_SESSION_HANDLER
+                    web_root.putChild(b"webclientdata", ajax_webclient)
+                    webclientstr = "webclient (ajax only)"
+
+                    if (settings.WEBSOCKET_CLIENT_ENABLED and settings.WEBSOCKET_CLIENT_PORT and 
+                        settings.WEBSOCKET_CLIENT_INTERFACE) and not websocket_started:
+                        # start websocket client port for the webclient
+                        # we only support one websocket client
+                        from autobahn.twisted.websocket import WebSocketServerFactory
+
+                        from evennia.server.portal import webclient  # noqa
+
+                        w_interface = "127.0.0.1" if settings.LOCKDOWN_MODE else settings.WEBSOCKET_CLIENT_INTERFACE
+                        w_ifacestr = ""
+                        if w_interface not in ("0.0.0.0", "::") or len(settings.WEBSERVER_INTERFACES) > 1:
+                            w_ifacestr = "-%s" % w_interface
+                        port = settings.WEBSOCKET_CLIENT_PORT
+
+                        class Websocket(WebSocketServerFactory):
+                            "Only here for better naming in logs"
+                            pass
+
+                        factory = Websocket()
+                        factory.noisy = False
+                        factory.protocol = _websocket_protocol
+                        factory.sessionhandler = evennia.PORTAL_SESSION_HANDLER
+                        websocket_service = internet.TCPServer(port, factory, interface=w_interface)
+                        websocket_service.setName("EvenniaWebSocket%s:%s" % (w_ifacestr, port))
+                        websocket_service.setServiceParent(self)
+                        websocket_started = True
+                        webclientstr = "webclient-websocket%s: %s" % (w_ifacestr, port)
+                    self.info_dict["webclient"].append(webclientstr)
+
+                try:
+                    WEB_PLUGINS_MODULE = mod_import(settings.WEB_PLUGINS_MODULE)
+                except ImportError:
+                    WEB_PLUGINS_MODULE = None
+                    self.info_dict["errors"] = (
+                        "WARNING: settings.WEB_PLUGINS_MODULE not found - "
+                        "copy 'evennia/game_template/server/conf/web_plugins.py to "
+                        "mygame/server/conf."
+                    )
+
+                if WEB_PLUGINS_MODULE:
+                    try:
+                        web_root = WEB_PLUGINS_MODULE.at_webproxy_root_creation(web_root)
+                    except Exception:
+                        # Legacy user has not added an at_webproxy_root_creation function in existing
+                        # web plugins file
+                        self.info_dict["errors"] = (
+                            "WARNING: WEB_PLUGINS_MODULE is enabled but at_webproxy_root_creation() "
+                            "not found copy 'evennia/game_template/server/conf/web_plugins.py to "
+                            "mygame/server/conf."
+                        )
+                web_root = Website(web_root, logPath=settings.HTTP_LOG_FILE)
+                web_root.is_portal = True
+                proxy_service = internet.TCPServer(proxyport, web_root, interface=interface)
+                proxy_service.setName("EvenniaWebProxy%s:%s" % (ifacestr, proxyport))
+                proxy_service.setServiceParent(self)
+                self.info_dict["webserver_proxy"].append("webserver-proxy%s: %s" % (ifacestr, proxyport))
+                self.info_dict["webserver_internal"].append("webserver: %s" % serverport)
+
+    def register_telnet(self):
+        # Start telnet game connections
+
+        from evennia.server.portal import telnet
+
+        _telnet_protocol = class_from_module(settings.TELNET_PROTOCOL_CLASS)
+
+        interfaces = self.check_lockdown(settings.TELNET_INTERFACES)
+
+        for interface in interfaces:
+            ifacestr = ""
+            if interface not in ("0.0.0.0", "::") or len(interfaces) > 1:
+                ifacestr = "-%s" % interface
+            for port in settings.TELNET_PORTS:
+                pstring = "%s:%s" % (ifacestr, port)
+                factory = telnet.TelnetServerFactory()
+                factory.noisy = False
+                factory.protocol = _telnet_protocol
+                factory.sessionhandler = evennia.PORTAL_SESSION_HANDLER
+                telnet_service = internet.TCPServer(port, factory, interface=interface)
+                telnet_service.setName("EvenniaTelnet%s" % pstring)
+                telnet_service.setServiceParent(self)
+
+                self.info_dict["telnet"].append("telnet%s: %s" % (ifacestr, port))
+
+    def register_amp(self):
+        # The AMP protocol handles the communication between
+        # the portal and the mud server. Only reason to ever deactivate
+        # it would be during testing and debugging.
+
+        from evennia.server.portal import amp_server
+
+        self.info_dict["amp"] = "amp: %s" % settings.AMP_PORT
+
+        factory = amp_server.AMPServerFactory(self)
+        amp_service = internet.TCPServer(settings.AMP_PORT, factory, interface=settings.AMP_INTERFACE)
+        amp_service.setName("PortalAMPServer")
+        amp_service.setServiceParent(self)
+
+    def _get_backup_server_twistd_cmd(self):
+        """
+        For interactive Portal mode there is no way to get the server cmdline from the launcher, so
+        we need to guess it here (it's very likely to not change)
+
+        Returns:
+            server_twistd_cmd (list): An instruction for starting the server, to pass to Popen.
+
+        """
+        server_twistd_cmd = [
+            "twistd",
+            "--python={}".format(os.path.join(dirname(dirname(abspath(__file__))), "server.py")),
+        ]
+        if os.name != "nt":
+            gamedir = os.getcwd()
+            server_twistd_cmd.append(
+                "--pidfile={}".format(os.path.join(gamedir, "server", "server.pid"))
+            )
+        return server_twistd_cmd
+
+    def get_info_dict(self):
+        """
+        Return the Portal info, for display.
+
+        """
+        return self.info_dict
+
+    def shutdown(self, _reactor_stopping=False, _stop_server=False):
+        """
+        Shuts down the server from inside it.
+
+        Args:
+            _reactor_stopping (bool, optional): This is set if server
+                is already in the process of shutting down; in this case
+                we don't need to stop it again.
+            _stop_server (bool, optional): Only used in portal-interactive mode;
+                makes sure to stop the Server cleanly.
+
+        Note that restarting (regardless of the setting) will not work
+        if the Portal is currently running in daemon mode. In that
+        case it always needs to be restarted manually.
+
+        """
+        if _reactor_stopping and hasattr(self, "shutdown_complete"):
+            # we get here due to us calling reactor.stop below. No need
+            # to do the shutdown procedure again.
+            return
+
+        evennia.PORTAL_SESSION_HANDLER.disconnect_all()
+        if _stop_server:
+            self.amp_protocol.stop_server(mode="shutdown")
+        if not _reactor_stopping:
+            # shutting down the reactor will trigger another signal. We set
+            # a flag to avoid loops.
+            self.shutdown_complete = True
+            reactor.callLater(0, reactor.stop)

evennia/server/portal/tests.py

@@ -21,8 +21,11 @@ from twisted.internet.base import DelayedCall
 from twisted.test import proto_helpers
 from twisted.trial.unittest import TestCase as TwistedTestCase
 
+import evennia
 from evennia.server.portal import irc
 from evennia.utils.test_resources import BaseEvenniaTest
+from evennia.server.portal.service import EvenniaPortalService
+from evennia.server.portal.portalsessionhandler import PortalSessionHandler
 
 from .amp import (
     AMP_MAXLEN,
@@ -35,7 +38,6 @@ from .mccp import MCCP
 from .mssp import MSSP
 from .mxp import MXP
 from .naws import DEFAULT_HEIGHT, DEFAULT_WIDTH
-from .portal import PORTAL_SESSIONS
 from .suppress_ga import SUPPRESS_GA
 from .telnet import TelnetProtocol, TelnetServerFactory
 from .telnet_oob import MSDP, MSDP_VAL, MSDP_VAR
@@ -221,9 +223,14 @@ class TestIRC(TestCase):
 class TestTelnet(TwistedTestCase):
     def setUp(self):
         super().setUp()
+        self.portal = EvenniaPortalService()
+        evennia.EVENNIA_PORTAL_SERVICE = self.portal
+        self.amp_server_factory = AMPServerFactory(self.portal)
+        self.amp_server = self.amp_server_factory.buildProtocol("127.0.0.1")
         factory = TelnetServerFactory()
         factory.protocol = TelnetProtocol
-        factory.sessionhandler = PORTAL_SESSIONS
+        evennia.PORTAL_SESSION_HANDLER = PortalSessionHandler()
+        factory.sessionhandler = evennia.PORTAL_SESSION_HANDLER
         factory.sessionhandler.portal = Mock()
         self.proto = factory.buildProtocol(("localhost", 0))
         self.transport = proto_helpers.StringTransport()
@@ -287,10 +294,15 @@ class TestTelnet(TwistedTestCase):
 class TestWebSocket(BaseEvenniaTest):
     def setUp(self):
         super().setUp()
+        self.portal = EvenniaPortalService()
+        evennia.EVENNIA_PORTAL_SERVICE = self.portal
+        self.amp_server_factory = AMPServerFactory(self.portal)
+        self.amp_server = self.amp_server_factory.buildProtocol("127.0.0.1")
         self.proto = WebSocketClient()
         self.proto.factory = WebSocketServerFactory()
-        self.proto.factory.sessionhandler = PORTAL_SESSIONS
+        evennia.PORTAL_SESSION_HANDLER = PortalSessionHandler()
-        self.proto.sessionhandler = PORTAL_SESSIONS
+        self.proto.factory.sessionhandler = evennia.PORTAL_SESSION_HANDLER
+        self.proto.sessionhandler = evennia.PORTAL_SESSION_HANDLER
         self.proto.sessionhandler.portal = Mock()
         self.proto.transport = proto_helpers.StringTransport()
         # self.proto.transport = proto_helpers.FakeDatagramTransport()

evennia/server/server.py

@@ -9,684 +9,23 @@ evennia/server/server_runner.py).
 """
 import os
 import sys
-import time
+
-import traceback
+from twisted.logger import globalLogPublisher
 
 import django
-from twisted.application import internet, service
-from twisted.internet import defer, reactor
-from twisted.internet.task import LoopingCall
-from twisted.logger import globalLogPublisher
-from twisted.web import static
-
 django.setup()
 
-import importlib
-
 import evennia
-
 evennia._init()
 
 from django.conf import settings
-from django.db import connection
-from django.db.utils import OperationalError
-from django.utils.translation import gettext as _
-
-from evennia.accounts.models import AccountDB
-from evennia.scripts.models import ScriptDB
-from evennia.server.models import ServerConfig
-from evennia.server.sessionhandler import SESSIONS
 from evennia.utils import logger
-from evennia.utils.utils import get_evennia_version, make_iter, mod_import
-
-_SA = object.__setattr__
-
-# a file with a flag telling the server to restart after shutdown or not.
-SERVER_RESTART = os.path.join(settings.GAME_DIR, "server", "server.restart")
-
-# modules containing hook methods called during start_stop
-SERVER_STARTSTOP_MODULES = [
-    mod_import(mod)
-    for mod in make_iter(settings.AT_SERVER_STARTSTOP_MODULE)
-    if isinstance(mod, str)
-]
-
-# modules containing plugin services
-SERVER_SERVICES_PLUGIN_MODULES = make_iter(settings.SERVER_SERVICES_PLUGIN_MODULES)
-
-
-# ------------------------------------------------------------
-# Evennia Server settings
-# ------------------------------------------------------------
-
-SERVERNAME = settings.SERVERNAME
-VERSION = get_evennia_version()
-
-AMP_ENABLED = True
-AMP_HOST = settings.AMP_HOST
-AMP_PORT = settings.AMP_PORT
-AMP_INTERFACE = settings.AMP_INTERFACE
-
-WEBSERVER_PORTS = settings.WEBSERVER_PORTS
-WEBSERVER_INTERFACES = settings.WEBSERVER_INTERFACES
-
-GUEST_ENABLED = settings.GUEST_ENABLED
-
-# server-channel mappings
-WEBSERVER_ENABLED = settings.WEBSERVER_ENABLED and WEBSERVER_PORTS and WEBSERVER_INTERFACES
-IRC_ENABLED = settings.IRC_ENABLED
-RSS_ENABLED = settings.RSS_ENABLED
-GRAPEVINE_ENABLED = settings.GRAPEVINE_ENABLED
-WEBCLIENT_ENABLED = settings.WEBCLIENT_ENABLED
-GAME_INDEX_ENABLED = settings.GAME_INDEX_ENABLED
-
-INFO_DICT = {
-    "servername": SERVERNAME,
-    "version": VERSION,
-    "amp": "",
-    "errors": "",
-    "info": "",
-    "webserver": "",
-    "irc_rss": "",
-}
-
-try:
-    WEB_PLUGINS_MODULE = mod_import(settings.WEB_PLUGINS_MODULE)
-except ImportError:
-    WEB_PLUGINS_MODULE = None
-    INFO_DICT["errors"] = (
-        "WARNING: settings.WEB_PLUGINS_MODULE not found - "
-        "copy 'evennia/game_template/server/conf/web_plugins.py to mygame/server/conf."
-    )
-
-# Maintenance function - this is called repeatedly by the server
-
-_IDMAPPER_CACHE_MAXSIZE = settings.IDMAPPER_CACHE_MAXSIZE
-_IDLE_TIMEOUT = settings.IDLE_TIMEOUT
-_LAST_SERVER_TIME_SNAPSHOT = 0
-
-_MAINTENANCE_COUNT = 0
-_FLUSH_CACHE = None
-_GAMETIME_MODULE = None
-_OBJECTDB = None
-
-
-def _server_maintenance():
-    """
-    This maintenance function handles repeated checks and updates that
-    the server needs to do. It is called every minute.
-    """
-    global EVENNIA, _MAINTENANCE_COUNT, _FLUSH_CACHE, _GAMETIME_MODULE
-    global _LAST_SERVER_TIME_SNAPSHOT
-    global _OBJECTDB
-
-    if not _OBJECTDB:
-        from evennia.objects.models import ObjectDB as _OBJECTDB
-    if not _GAMETIME_MODULE:
-        from evennia.utils import gametime as _GAMETIME_MODULE
-    if not _FLUSH_CACHE:
-        from evennia.utils.idmapper.models import conditional_flush as _FLUSH_CACHE
-
-    _MAINTENANCE_COUNT += 1
-
-    now = time.time()
-    if _MAINTENANCE_COUNT == 1:
-        # first call after a reload
-        _GAMETIME_MODULE.SERVER_START_TIME = now
-        _GAMETIME_MODULE.SERVER_RUNTIME = ServerConfig.objects.conf("runtime", default=0.0)
-        _LAST_SERVER_TIME_SNAPSHOT = now
-    else:
-        # adjust the runtime not with 60s but with the actual elapsed time
-        # in case this may varies slightly from 60s.
-        _GAMETIME_MODULE.SERVER_RUNTIME += now - _LAST_SERVER_TIME_SNAPSHOT
-    _LAST_SERVER_TIME_SNAPSHOT = now
-
-    # update game time and save it across reloads
-    _GAMETIME_MODULE.SERVER_RUNTIME_LAST_UPDATED = now
-    ServerConfig.objects.conf("runtime", _GAMETIME_MODULE.SERVER_RUNTIME)
-
-    if _MAINTENANCE_COUNT % 5 == 0:
-        # check cache size every 5 minutes
-        _FLUSH_CACHE(_IDMAPPER_CACHE_MAXSIZE)
-    if _MAINTENANCE_COUNT % (60 * 7) == 0:
-        # drop database connection every 7 hrs to avoid default timeouts on MySQL
-        # (see https://github.com/evennia/evennia/issues/1376)
-        connection.close()
-
-    # handle idle timeouts
-    if _IDLE_TIMEOUT > 0:
-        reason = _("idle timeout exceeded")
-        to_disconnect = []
-        for session in (
-            sess for sess in SESSIONS.values() if (now - sess.cmd_last) > _IDLE_TIMEOUT
-        ):
-            if not session.account or not session.account.access(
-                session.account, "noidletimeout", default=False
-            ):
-                to_disconnect.append(session)
-
-        for session in to_disconnect:
-            SESSIONS.disconnect(session, reason=reason)
-
-    # run unpuppet hooks for objects that are marked as being puppeted,
-    # but which lacks an account (indicates a broken unpuppet operation
-    # such as a server crash)
-    if _MAINTENANCE_COUNT > 1:
-        unpuppet_count = 0
-        for obj in _OBJECTDB.objects.get_by_tag(key="puppeted", category="account"):
-            if not obj.has_account:
-                obj.at_pre_unpuppet()
-                obj.at_post_unpuppet(None, reason=_(" (connection lost)"))
-                obj.tags.remove("puppeted", category="account")
-                unpuppet_count += 1
-        if unpuppet_count:
-            logger.log_msg(f"Ran unpuppet-hooks for {unpuppet_count} link-dead puppets.")
-
-
-# ------------------------------------------------------------
-# Evennia Main Server object
-# ------------------------------------------------------------
-
-
-class Evennia:
-
-    """
-    The main Evennia server handler. This object sets up the database and
-    tracks and interlinks all the twisted network services that make up
-    evennia.
-
-    """
-
-    def __init__(self, application):
-        """
-        Setup the server.
-
-        application - an instantiated Twisted application
-
-        """
-        sys.path.insert(1, ".")
-
-        # create a store of services
-        self.services = service.MultiService()
-        self.services.setServiceParent(application)
-        self.amp_protocol = None  # set by amp factory
-        self.sessions = SESSIONS
-        self.sessions.server = self
-        self.process_id = os.getpid()
-
-        # Database-specific startup optimizations.
-        self.sqlite3_prep()
-
-        self.start_time = time.time()
-
-        # wrap the SIGINT handler to make sure we empty the threadpool
-        # even when we reload and we have long-running requests in queue.
-        # this is necessary over using Twisted's signal handler.
-        # (see https://github.com/evennia/evennia/issues/1128)
-        def _wrap_sigint_handler(*args):
-            from twisted.internet.defer import Deferred
-
-            if hasattr(self, "web_root"):
-                d = self.web_root.empty_threadpool()
-                d.addCallback(lambda _: self.shutdown("reload", _reactor_stopping=True))
-            else:
-                d = Deferred(lambda _: self.shutdown("reload", _reactor_stopping=True))
-            d.addCallback(lambda _: reactor.stop())
-            reactor.callLater(1, d.callback, None)
-
-        reactor.sigInt = _wrap_sigint_handler
-
-    # Server startup methods
-
-    def sqlite3_prep(self):
-        """
-        Optimize some SQLite stuff at startup since we
-        can't save it to the database.
-        """
-        if (
-            ".".join(str(i) for i in django.VERSION) < "1.2"
-            and settings.DATABASES.get("default", {}).get("ENGINE") == "sqlite3"
-        ) or (
-            hasattr(settings, "DATABASES")
-            and settings.DATABASES.get("default", {}).get("ENGINE", None)
-            == "django.db.backends.sqlite3"
-        ):
-            cursor = connection.cursor()
-            cursor.execute("PRAGMA cache_size=10000")
-            cursor.execute("PRAGMA synchronous=OFF")
-            cursor.execute("PRAGMA count_changes=OFF")
-            cursor.execute("PRAGMA temp_store=2")
-
-    def update_defaults(self):
-        """
-        We make sure to store the most important object defaults here, so
-        we can catch if they change and update them on-objects automatically.
-        This allows for changing default cmdset locations and default
-        typeclasses in the settings file and have them auto-update all
-        already existing objects.
-
-        """
-        global INFO_DICT
-
-        # setting names
-        settings_names = (
-            "CMDSET_CHARACTER",
-            "CMDSET_ACCOUNT",
-            "BASE_ACCOUNT_TYPECLASS",
-            "BASE_OBJECT_TYPECLASS",
-            "BASE_CHARACTER_TYPECLASS",
-            "BASE_ROOM_TYPECLASS",
-            "BASE_EXIT_TYPECLASS",
-            "BASE_SCRIPT_TYPECLASS",
-            "BASE_CHANNEL_TYPECLASS",
-        )
-        # get previous and current settings so they can be compared
-        settings_compare = list(
-            zip(
-                [ServerConfig.objects.conf(name) for name in settings_names],
-                [settings.__getattr__(name) for name in settings_names],
-            )
-        )
-        mismatches = [
-            i for i, tup in enumerate(settings_compare) if tup[0] and tup[1] and tup[0] != tup[1]
-        ]
-        if len(
-            mismatches
-        ):  # can't use any() since mismatches may be [0] which reads as False for any()
-            # we have a changed default. Import relevant objects and
-            # run the update
-            from evennia.comms.models import ChannelDB
-            from evennia.objects.models import ObjectDB
-
-            # from evennia.accounts.models import AccountDB
-            for i, prev, curr in (
-                (i, tup[0], tup[1]) for i, tup in enumerate(settings_compare) if i in mismatches
-            ):
-                # update the database
-                INFO_DICT[
-                    "info"
-                ] = " %s:\n '%s' changed to '%s'. Updating unchanged entries in database ..." % (
-                    settings_names[i],
-                    prev,
-                    curr,
-                )
-                if i == 0:
-                    ObjectDB.objects.filter(db_cmdset_storage__exact=prev).update(
-                        db_cmdset_storage=curr
-                    )
-                if i == 1:
-                    AccountDB.objects.filter(db_cmdset_storage__exact=prev).update(
-                        db_cmdset_storage=curr
-                    )
-                if i == 2:
-                    AccountDB.objects.filter(db_typeclass_path__exact=prev).update(
-                        db_typeclass_path=curr
-                    )
-                if i in (3, 4, 5, 6):
-                    ObjectDB.objects.filter(db_typeclass_path__exact=prev).update(
-                        db_typeclass_path=curr
-                    )
-                if i == 7:
-                    ScriptDB.objects.filter(db_typeclass_path__exact=prev).update(
-                        db_typeclass_path=curr
-                    )
-                if i == 8:
-                    ChannelDB.objects.filter(db_typeclass_path__exact=prev).update(
-                        db_typeclass_path=curr
-                    )
-                # store the new default and clean caches
-                ServerConfig.objects.conf(settings_names[i], curr)
-                ObjectDB.flush_instance_cache()
-                AccountDB.flush_instance_cache()
-                ScriptDB.flush_instance_cache()
-                ChannelDB.flush_instance_cache()
-        # if this is the first start we might not have a "previous"
-        # setup saved. Store it now.
-        [
-            ServerConfig.objects.conf(settings_names[i], tup[1])
-            for i, tup in enumerate(settings_compare)
-            if not tup[0]
-        ]
-
-    def run_initial_setup(self):
-        """
-        This is triggered by the amp protocol when the connection
-        to the portal has been established.
-        This attempts to run the initial_setup script of the server.
-        It returns if this is not the first time the server starts.
-        Once finished the last_initial_setup_step is set to 'done'
-
-        """
-        global INFO_DICT
-        initial_setup = importlib.import_module(settings.INITIAL_SETUP_MODULE)
-        last_initial_setup_step = ServerConfig.objects.conf("last_initial_setup_step")
-        try:
-            if not last_initial_setup_step:
-                # None is only returned if the config does not exist,
-                # i.e. this is an empty DB that needs populating.
-                INFO_DICT["info"] = " Server started for the first time. Setting defaults."
-                initial_setup.handle_setup()
-            elif last_initial_setup_step not in ("done", -1):
-                # last step crashed, so we weill resume from this step.
-                # modules and setup will resume from this step, retrying
-                # the last failed module. When all are finished, the step
-                # is set to 'done' to show it does not need to be run again.
-                INFO_DICT["info"] = " Resuming initial setup from step '{last}'.".format(
-                    last=last_initial_setup_step
-                )
-                initial_setup.handle_setup(last_initial_setup_step)
-        except Exception:
-            # stop server if this happens.
-            print(traceback.format_exc())
-            print("Error in initial setup. Stopping Server + Portal.")
-            self.sessions.portal_shutdown()
-
-    def create_default_channels(self):
-        """
-        check so default channels exist on every restart, create if not.
-
-        """
-
-        from evennia.accounts.models import AccountDB
-        from evennia.comms.models import ChannelDB
-        from evennia.utils.create import create_channel
-
-        superuser = AccountDB.objects.get(id=1)
-
-        # mudinfo
-        mudinfo_chan = settings.CHANNEL_MUDINFO
-        if mudinfo_chan and not ChannelDB.objects.filter(db_key__iexact=mudinfo_chan["key"]):
-            channel = create_channel(**mudinfo_chan)
-            channel.connect(superuser)
-        # connectinfo
-        connectinfo_chan = settings.CHANNEL_CONNECTINFO
-        if connectinfo_chan and not ChannelDB.objects.filter(
-            db_key__iexact=connectinfo_chan["key"]
-        ):
-            channel = create_channel(**connectinfo_chan)
-        # default channels
-        for chan_info in settings.DEFAULT_CHANNELS:
-            if not ChannelDB.objects.filter(db_key__iexact=chan_info["key"]):
-                channel = create_channel(**chan_info)
-                channel.connect(superuser)
-
-    def run_init_hooks(self, mode):
-        """
-        Called by the amp client once receiving sync back from Portal
-
-        Args:
-            mode (str): One of shutdown, reload or reset
-
-        """
-        from evennia.typeclasses.models import TypedObject
-
-        # start server time and maintenance task
-        self.maintenance_task = LoopingCall(_server_maintenance)
-        self.maintenance_task.start(60, now=True)  # call every minute
-
-        # update eventual changed defaults
-        self.update_defaults()
-
-        # run at_init() on all cached entities on reconnect
-        [
-            [entity.at_init() for entity in typeclass_db.get_all_cached_instances()]
-            for typeclass_db in TypedObject.__subclasses__()
-        ]
-
-        self.at_server_init()
-
-        # call correct server hook based on start file value
-        if mode == "reload":
-            logger.log_msg("Server successfully reloaded.")
-            self.at_server_reload_start()
-        elif mode == "reset":
-            # only run hook, don't purge sessions
-            self.at_server_cold_start()
-            logger.log_msg("Evennia Server successfully restarted in 'reset' mode.")
-        elif mode == "shutdown":
-            from evennia.objects.models import ObjectDB
-
-            self.at_server_cold_start()
-            # clear eventual lingering session storages
-            ObjectDB.objects.clear_all_sessids()
-            logger.log_msg("Evennia Server successfully started.")
-
-        # always call this regardless of start type
-        self.at_server_start()
-
-        # Moved here from evennia._init() to ensure it only runs after
-        # setup is complete and only in server mode.
-        evennia.GLOBAL_SCRIPTS.start()
-
-    @defer.inlineCallbacks
-    def shutdown(self, mode="reload", _reactor_stopping=False):
-        """
-        Shuts down the server from inside it.
-
-        mode - sets the server restart mode.
-           - 'reload' - server restarts, no "persistent" scripts
-             are stopped, at_reload hooks called.
-           - 'reset' - server restarts, non-persistent scripts stopped,
-             at_shutdown hooks called but sessions will not
-             be disconnected.
-           - 'shutdown' - like reset, but server will not auto-restart.
-        _reactor_stopping - this is set if server is stopped by a kill
-           command OR this method was already called
-           once - in both cases the reactor is
-           dead/stopping already.
-        """
-        if _reactor_stopping and hasattr(self, "shutdown_complete"):
-            # this means we have already passed through this method
-            # once; we don't need to run the shutdown procedure again.
-            defer.returnValue(None)
-
-        from evennia.objects.models import ObjectDB
-        from evennia.server.models import ServerConfig
-        from evennia.utils import gametime as _GAMETIME_MODULE
-
-        if mode == "reload":
-            # call restart hooks
-            ServerConfig.objects.conf("server_restart_mode", "reload")
-            yield [o.at_server_reload() for o in ObjectDB.get_all_cached_instances()]
-            yield [p.at_server_reload() for p in AccountDB.get_all_cached_instances()]
-            yield [
-                (s._pause_task(auto_pause=True) if s.is_active else None, s.at_server_reload())
-                for s in ScriptDB.get_all_cached_instances()
-                if s.id
-            ]
-            yield self.sessions.all_sessions_portal_sync()
-            self.at_server_reload_stop()
-            # only save monitor state on reload, not on shutdown/reset
-            from evennia.scripts.monitorhandler import MONITOR_HANDLER
-
-            MONITOR_HANDLER.save()
-        else:
-            if mode == "reset":
-                # like shutdown but don't unset the is_connected flag and don't disconnect sessions
-                yield [o.at_server_shutdown() for o in ObjectDB.get_all_cached_instances()]
-                yield [p.at_server_shutdown() for p in AccountDB.get_all_cached_instances()]
-                if self.amp_protocol:
-                    yield self.sessions.all_sessions_portal_sync()
-            else:  # shutdown
-                yield [_SA(p, "is_connected", False) for p in AccountDB.get_all_cached_instances()]
-                yield [o.at_server_shutdown() for o in ObjectDB.get_all_cached_instances()]
-                yield [
-                    (p.unpuppet_all(), p.at_server_shutdown())
-                    for p in AccountDB.get_all_cached_instances()
-                ]
-                yield ObjectDB.objects.clear_all_sessids()
-            yield [
-                (s._pause_task(auto_pause=True), s.at_server_shutdown())
-                for s in ScriptDB.get_all_cached_instances()
-                if s.id and s.is_active
-            ]
-            ServerConfig.objects.conf("server_restart_mode", "reset")
-            self.at_server_cold_stop()
-
-        # tickerhandler state should always be saved.
-        from evennia.scripts.tickerhandler import TICKER_HANDLER
-
-        TICKER_HANDLER.save()
-
-        # always called, also for a reload
-        self.at_server_stop()
-
-        if hasattr(self, "web_root"):  # not set very first start
-            yield self.web_root.empty_threadpool()
-
-        if not _reactor_stopping:
-            # kill the server
-            self.shutdown_complete = True
-            reactor.callLater(1, reactor.stop)
-
-        # we make sure the proper gametime is saved as late as possible
-        ServerConfig.objects.conf("runtime", _GAMETIME_MODULE.runtime())
-
-    def get_info_dict(self):
-        """
-        Return the server info, for display.
-
-        """
-        return INFO_DICT
-
-    # server start/stop hooks
-
-    def at_server_init(self):
-        """
-        This is called first when the server is starting, before any other hooks, regardless of how it's starting.
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_init"):
-                mod.at_server_init()
-
-    def at_server_start(self):
-        """
-        This is called every time the server starts up, regardless of
-        how it was shut down.
-
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_start"):
-                mod.at_server_start()
-
-    def at_server_stop(self):
-        """
-        This is called just before a server is shut down, regardless
-        of it is fore a reload, reset or shutdown.
-
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_stop"):
-                mod.at_server_stop()
-
-    def at_server_reload_start(self):
-        """
-        This is called only when server starts back up after a reload.
-
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_reload_start"):
-                mod.at_server_reload_start()
-
-    def at_post_portal_sync(self, mode):
-        """
-        This is called just after the portal has finished syncing back data to the server
-        after reconnecting.
-
-        Args:
-            mode (str): One of 'reload', 'reset' or 'shutdown'.
-
-        """
-
-        from evennia.scripts.monitorhandler import MONITOR_HANDLER
-
-        MONITOR_HANDLER.restore(mode == "reload")
-
-        from evennia.scripts.tickerhandler import TICKER_HANDLER
-
-        TICKER_HANDLER.restore(mode == "reload")
-
-        # Un-pause all scripts, stop non-persistent timers
-        ScriptDB.objects.update_scripts_after_server_start()
-
-        # start the task handler
-        from evennia.scripts.taskhandler import TASK_HANDLER
-
-        TASK_HANDLER.load()
-        TASK_HANDLER.create_delays()
-
-        # create/update channels
-        self.create_default_channels()
-
-        # delete the temporary setting
-        ServerConfig.objects.conf("server_restart_mode", delete=True)
-
-    def at_server_reload_stop(self):
-        """
-        This is called only time the server stops before a reload.
-
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_reload_stop"):
-                mod.at_server_reload_stop()
-
-    def at_server_cold_start(self):
-        """
-        This is called only when the server starts "cold", i.e. after a
-        shutdown or a reset.
-
-        """
-        # We need to do this just in case the server was killed in a way where
-        # the normal cleanup operations did not have time to run.
-        from evennia.objects.models import ObjectDB
-
-        ObjectDB.objects.clear_all_sessids()
-
-        # Remove non-persistent scripts
-        from evennia.scripts.models import ScriptDB
-
-        for script in ScriptDB.objects.filter(db_persistent=False):
-            script._stop_task()
-
-        if GUEST_ENABLED:
-            for guest in AccountDB.objects.all().filter(
-                db_typeclass_path=settings.BASE_GUEST_TYPECLASS
-            ):
-                for character in guest.characters:
-                    character.delete()
-                guest.delete()
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_cold_start"):
-                mod.at_server_cold_start()
-
-    def at_server_cold_stop(self):
-        """
-        This is called only when the server goes down due to a shutdown or reset.
-
-        """
-        for mod in SERVER_STARTSTOP_MODULES:
-            if hasattr(mod, "at_server_cold_stop"):
-                mod.at_server_cold_stop()
-
-
-# ------------------------------------------------------------
-#
-# Start the Evennia game server and add all active services
-#
-# ------------------------------------------------------------
-
-
-# Tell the system the server is starting up; some things are not available yet
-try:
-    ServerConfig.objects.conf("server_starting_mode", True)
-except OperationalError:
-    print("Server server_starting_mode couldn't be set - database not set up.")
-
 
 # twistd requires us to define the variable 'application' so it knows
 # what to execute from.
-application = service.Application("Evennia")
+# The guts of the application are in the service.py file,
-
+# which is instantiated and attached to application in evennia._init()
+application = evennia.TWISTED_APPLICATION
 
 if "--nodaemon" not in sys.argv and "test" not in sys.argv:
     # activate logging for interactive/testing mode
@@ -699,101 +38,3 @@ if "--nodaemon" not in sys.argv and "test" not in sys.argv:
     globalLogPublisher.addObserver(logger.GetServerLogObserver()(logfile))
 
 
-# The main evennia server program. This sets up the database
-# and is where we store all the other services.
-EVENNIA = Evennia(application)
-
-if AMP_ENABLED:
-    # The AMP protocol handles the communication between
-    # the portal and the mud server. Only reason to ever deactivate
-    # it would be during testing and debugging.
-
-    ifacestr = ""
-    if AMP_INTERFACE != "127.0.0.1":
-        ifacestr = "-%s" % AMP_INTERFACE
-
-    INFO_DICT["amp"] = "amp %s: %s" % (ifacestr, AMP_PORT)
-
-    from evennia.server import amp_client
-
-    factory = amp_client.AMPClientFactory(EVENNIA)
-    amp_service = internet.TCPClient(AMP_HOST, AMP_PORT, factory)
-    amp_service.setName("ServerAMPClient")
-    EVENNIA.services.addService(amp_service)
-
-if WEBSERVER_ENABLED:
-    # Start a django-compatible webserver.
-
-    from evennia.server.webserver import (
-        DjangoWebRoot,
-        LockableThreadPool,
-        PrivateStaticRoot,
-        Website,
-        WSGIWebServer,
-    )
-
-    # start a thread pool and define the root url (/) as a wsgi resource
-    # recognized by Django
-    threads = LockableThreadPool(
-        minthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[0]),
-        maxthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[1]),
-    )
-
-    web_root = DjangoWebRoot(threads)
-    # point our media resources to url /media
-    web_root.putChild(b"media", PrivateStaticRoot(settings.MEDIA_ROOT))
-    # point our static resources to url /static
-    web_root.putChild(b"static", PrivateStaticRoot(settings.STATIC_ROOT))
-    EVENNIA.web_root = web_root
-
-    if WEB_PLUGINS_MODULE:
-        # custom overloads
-        web_root = WEB_PLUGINS_MODULE.at_webserver_root_creation(web_root)
-
-    web_site = Website(web_root, logPath=settings.HTTP_LOG_FILE)
-    web_site.is_portal = False
-
-    INFO_DICT["webserver"] = ""
-    for proxyport, serverport in WEBSERVER_PORTS:
-        # create the webserver (we only need the port for this)
-        webserver = WSGIWebServer(threads, serverport, web_site, interface="127.0.0.1")
-        webserver.setName("EvenniaWebServer%s" % serverport)
-        EVENNIA.services.addService(webserver)
-
-        INFO_DICT["webserver"] += "webserver: %s" % serverport
-
-ENABLED = []
-if IRC_ENABLED:
-    # IRC channel connections
-    ENABLED.append("irc")
-
-if RSS_ENABLED:
-    # RSS feed channel connections
-    ENABLED.append("rss")
-
-if GRAPEVINE_ENABLED:
-    # Grapevine channel connections
-    ENABLED.append("grapevine")
-
-if GAME_INDEX_ENABLED:
-    from evennia.server.game_index_client.service import EvenniaGameIndexService
-
-    egi_service = EvenniaGameIndexService()
-    EVENNIA.services.addService(egi_service)
-
-if ENABLED:
-    INFO_DICT["irc_rss"] = ", ".join(ENABLED) + " enabled."
-
-for plugin_module in SERVER_SERVICES_PLUGIN_MODULES:
-    # external plugin protocols - load here
-    plugin_module = mod_import(plugin_module)
-    if plugin_module:
-        plugin_module.start_plugin_services(EVENNIA)
-    else:
-        print(f"Could not load plugin module {plugin_module}")
-
-# clear server startup mode
-try:
-    ServerConfig.objects.conf("server_starting_mode", delete=True)
-except OperationalError:
-    print("Server server_starting_mode couldn't unset - db not set up.")

evennia/server/service.py

@@ -0,0 +1,693 @@
+"""
+This module contains the main EvenniaService class, which is the very core of the
+Evennia server. It is instantiated by the evennia/server/server.py module.
+"""
+import time
+import traceback
+import importlib
+
+from twisted.application import internet
+from twisted.application.service import MultiService
+from twisted.internet import defer, reactor
+from twisted.internet.defer import Deferred
+from twisted.internet.task import LoopingCall
+
+import django
+from django.db import connection
+from django.db.utils import OperationalError
+from django.conf import settings
+from django.utils.translation import gettext as _
+
+import evennia
+from evennia.utils.utils import get_evennia_version, make_iter, mod_import
+from evennia.utils import logger
+
+_SA = object.__setattr__
+
+
+class EvenniaServerService(MultiService):
+    def _wrap_sigint_handler(self, *args):
+        if hasattr(self, "web_root"):
+            d = self.web_root.empty_threadpool()
+            d.addCallback(lambda _: self.shutdown("reload", _reactor_stopping=True))
+        else:
+            d = Deferred(lambda _: self.shutdown("reload", _reactor_stopping=True))
+        d.addCallback(lambda _: reactor.stop())
+        reactor.callLater(1, d.callback, None)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.maintenance_count = 0
+        self.amp_protocol = None  # set by amp factory
+        self.amp_service = None
+        self.info_dict = {
+            "servername": settings.SERVERNAME,
+            "version": get_evennia_version(),
+            "amp": "",
+            "errors": "",
+            "info": "",
+            "webserver": "",
+            "irc_rss": "",
+        }
+        self._flush_cache = None
+        self._last_server_time_snapshot = 0
+        self.maintenance_task = None
+
+        # Database-specific startup optimizations.
+        self.sqlite3_prep()
+
+        self.start_time = 0
+
+        # wrap the SIGINT handler to make sure we empty the threadpool
+        # even when we reload and we have long-running requests in queue.
+        # this is necessary over using Twisted's signal handler.
+        # (see https://github.com/evennia/evennia/issues/1128)
+
+        reactor.sigInt = self._wrap_sigint_handler
+
+        self.start_stop_modules = [
+            mod_import(mod)
+            for mod in make_iter(settings.AT_SERVER_STARTSTOP_MODULE)
+            if isinstance(mod, str)
+        ]
+
+    def server_maintenance(self):
+        """
+        This maintenance function handles repeated checks and updates that
+        the server needs to do. It is called every minute.
+        """
+        if not self._flush_cache:
+            from evennia.utils.idmapper.models import conditional_flush as _FLUSH_CACHE
+
+            self._flush_cache = _FLUSH_CACHE
+
+        self.maintenance_count += 1
+
+        now = time.time()
+        if self.maintenance_count == 1:
+            # first call after a reload
+            evennia.gametime.SERVER_START_TIME = now
+            evennia.gametime.SERVER_RUNTIME = evennia.ServerConfig.objects.conf(
+                "runtime", default=0.0
+            )
+            _LAST_SERVER_TIME_SNAPSHOT = now
+        else:
+            # adjust the runtime not with 60s but with the actual elapsed time
+            # in case this may varies slightly from 60s.
+            evennia.gametime.SERVER_RUNTIME += now - self._last_server_time_snapshot
+        self._last_server_time_snapshot = now
+
+        # update game time and save it across reloads
+        evennia.gametime.SERVER_RUNTIME_LAST_UPDATED = now
+        evennia.ServerConfig.objects.conf("runtime", evennia.gametime.SERVER_RUNTIME)
+
+        if self.maintenance_count % 5 == 0:
+            # check cache size every 5 minutes
+            self._flush_cache(settings.IDMAPPER_CACHE_MAXSIZE)
+        if self.maintenance_count % (60 * 7) == 0:
+            # drop database connection every 7 hrs to avoid default timeouts on MySQL
+            # (see https://github.com/evennia/evennia/issues/1376)
+            connection.close()
+
+        self.process_idle_timeouts()
+
+        # run unpuppet hooks for objects that are marked as being puppeted,
+        # but which lacks an account (indicates a broken unpuppet operation
+        # such as a server crash)
+        if self.maintenance_count > 1:
+            unpuppet_count = 0
+            for obj in evennia.ObjectDB.objects.get_by_tag(key="puppeted", category="account"):
+                if not obj.has_account:
+                    obj.at_pre_unpuppet()
+                    obj.at_post_unpuppet(None, reason=_(" (connection lost)"))
+                    obj.tags.remove("puppeted", category="account")
+                    unpuppet_count += 1
+            if unpuppet_count:
+                logger.log_msg(f"Ran unpuppet-hooks for {unpuppet_count} link-dead puppets.")
+
+    def process_idle_timeouts(self):
+        # handle idle timeouts
+        if settings.IDLE_TIMEOUT > 0:
+            now = time.time()
+            reason = _("idle timeout exceeded")
+            to_disconnect = []
+            for session in (
+                sess
+                for sess in evennia.SESSION_HANDLER.values()
+                if (now - sess.cmd_last) > settings.IDLE_TIMEOUT
+            ):
+                if not session.account or not session.account.access(
+                    session.account, "noidletimeout", default=False
+                ):
+                    to_disconnect.append(session)
+
+            for session in to_disconnect:
+                evennia.SESSION_HANDLER.disconnect(session, reason=reason)
+
+    # Server startup methods
+    def privilegedStartService(self):
+        self.start_time = time.time()
+
+        # Tell the system the server is starting up; some things are not available yet
+        try:
+            evennia.ServerConfig.objects.conf("server_starting_mode", True)
+        except OperationalError:
+            print("Server server_starting_mode couldn't be set - database not set up.")
+
+        if settings.AMP_ENABLED:
+            self.register_amp()
+
+        if settings.WEBSERVER_ENABLED:
+            self.register_webserver()
+
+        ENABLED = []
+        if settings.IRC_ENABLED:
+            # IRC channel connections
+            ENABLED.append("irc")
+
+        if settings.RSS_ENABLED:
+            # RSS feed channel connections
+            ENABLED.append("rss")
+
+        if settings.GRAPEVINE_ENABLED:
+            # Grapevine channel connections
+            ENABLED.append("grapevine")
+
+        if settings.GAME_INDEX_ENABLED:
+            from evennia.server.game_index_client.service import EvenniaGameIndexService
+
+            egi_service = EvenniaGameIndexService()
+            egi_service.setServiceParent(self)
+
+        if ENABLED:
+            self.info_dict["irc_rss"] = ", ".join(ENABLED) + " enabled."
+
+        self.register_plugins()
+
+        super().privilegedStartService()
+
+        # clear server startup mode
+        try:
+            evennia.ServerConfig.objects.conf("server_starting_mode", delete=True)
+        except OperationalError:
+            print("Server server_starting_mode couldn't unset - db not set up.")
+
+    def register_plugins(self):
+        SERVER_SERVICES_PLUGIN_MODULES = make_iter(settings.SERVER_SERVICES_PLUGIN_MODULES)
+        for plugin_module in SERVER_SERVICES_PLUGIN_MODULES:
+            # external plugin protocols - load here
+            plugin_module = mod_import(plugin_module)
+            if plugin_module:
+                plugin_module.start_plugin_services(self)
+            else:
+                print(f"Could not load plugin module {plugin_module}")
+
+    def register_amp(self):
+        # The AMP protocol handles the communication between
+        # the portal and the mud server. Only reason to ever deactivate
+        # it would be during testing and debugging.
+
+        ifacestr = ""
+        if settings.AMP_INTERFACE != "127.0.0.1":
+            ifacestr = "-%s" % settings.AMP_INTERFACE
+
+        self.info_dict["amp"] = "amp %s: %s" % (ifacestr, settings.AMP_PORT)
+
+        from evennia.server import amp_client
+
+        factory = amp_client.AMPClientFactory(self)
+        self.amp_service = internet.TCPClient(settings.AMP_HOST, settings.AMP_PORT, factory)
+        self.amp_service.setName("ServerAMPClient")
+        self.amp_service.setServiceParent(self)
+
+    def register_webserver(self):
+        # Start a django-compatible webserver.
+
+        from evennia.server.webserver import (
+            DjangoWebRoot,
+            LockableThreadPool,
+            PrivateStaticRoot,
+            Website,
+            WSGIWebServer,
+        )
+
+        # start a thread pool and define the root url (/) as a wsgi resource
+        # recognized by Django
+        threads = LockableThreadPool(
+            minthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[0]),
+            maxthreads=max(1, settings.WEBSERVER_THREADPOOL_LIMITS[1]),
+        )
+
+        web_root = DjangoWebRoot(threads)
+        # point our media resources to url /media
+        web_root.putChild(b"media", PrivateStaticRoot(settings.MEDIA_ROOT))
+        # point our static resources to url /static
+        web_root.putChild(b"static", PrivateStaticRoot(settings.STATIC_ROOT))
+        self.web_root = web_root
+
+        try:
+            WEB_PLUGINS_MODULE = mod_import(settings.WEB_PLUGINS_MODULE)
+        except ImportError:
+            WEB_PLUGINS_MODULE = None
+            self.info_dict["errors"] = (
+                "WARNING: settings.WEB_PLUGINS_MODULE not found - "
+                "copy 'evennia/game_template/server/conf/web_plugins.py to mygame/server/conf."
+            )
+
+        if WEB_PLUGINS_MODULE:
+            # custom overloads
+            web_root = WEB_PLUGINS_MODULE.at_webserver_root_creation(web_root)
+
+        web_site = Website(web_root, logPath=settings.HTTP_LOG_FILE)
+        web_site.is_portal = False
+
+        self.info_dict["webserver"] = ""
+        for proxyport, serverport in settings.WEBSERVER_PORTS:
+            # create the webserver (we only need the port for this)
+            webserver = WSGIWebServer(threads, serverport, web_site, interface="127.0.0.1")
+            webserver.setName("EvenniaWebServer%s" % serverport)
+            webserver.setServiceParent(self)
+
+            self.info_dict["webserver"] += "webserver: %s" % serverport
+
+    def sqlite3_prep(self):
+        """
+        Optimize some SQLite stuff at startup since we
+        can't save it to the database.
+        """
+        if (
+            ".".join(str(i) for i in django.VERSION) < "1.2"
+            and settings.DATABASES.get("default", {}).get("ENGINE") == "sqlite3"
+        ) or (
+            hasattr(settings, "DATABASES")
+            and settings.DATABASES.get("default", {}).get("ENGINE", None)
+            == "django.db.backends.sqlite3"
+        ):
+            cursor = connection.cursor()
+            cursor.execute("PRAGMA cache_size=10000")
+            cursor.execute("PRAGMA synchronous=OFF")
+            cursor.execute("PRAGMA count_changes=OFF")
+            cursor.execute("PRAGMA temp_store=2")
+
+    def update_defaults(self):
+        """
+        We make sure to store the most important object defaults here, so
+        we can catch if they change and update them on-objects automatically.
+        This allows for changing default cmdset locations and default
+        typeclasses in the settings file and have them auto-update all
+        already existing objects.
+
+        """
+
+        # setting names
+        settings_names = (
+            "CMDSET_CHARACTER",
+            "CMDSET_ACCOUNT",
+            "BASE_ACCOUNT_TYPECLASS",
+            "BASE_OBJECT_TYPECLASS",
+            "BASE_CHARACTER_TYPECLASS",
+            "BASE_ROOM_TYPECLASS",
+            "BASE_EXIT_TYPECLASS",
+            "BASE_SCRIPT_TYPECLASS",
+            "BASE_CHANNEL_TYPECLASS",
+        )
+        # get previous and current settings so they can be compared
+        settings_compare = list(
+            zip(
+                [evennia.ServerConfig.objects.conf(name) for name in settings_names],
+                [settings.__getattr__(name) for name in settings_names],
+            )
+        )
+        mismatches = [
+            i for i, tup in enumerate(settings_compare) if tup[0] and tup[1] and tup[0] != tup[1]
+        ]
+        if len(
+            mismatches
+        ):  # can't use any() since mismatches may be [0] which reads as False for any()
+            # we have a changed default. Import relevant objects and
+            # run the update
+
+            # from evennia.accounts.models import AccountDB
+            for i, prev, curr in (
+                (i, tup[0], tup[1]) for i, tup in enumerate(settings_compare) if i in mismatches
+            ):
+                # update the database
+                self.info_dict[
+                    "info"
+                ] = " %s:\n '%s' changed to '%s'. Updating unchanged entries in database ..." % (
+                    settings_names[i],
+                    prev,
+                    curr,
+                )
+                if i == 0:
+                    evennia.ObjectDB.objects.filter(db_cmdset_storage__exact=prev).update(
+                        db_cmdset_storage=curr
+                    )
+                if i == 1:
+                    evennia.AccountDB.objects.filter(db_cmdset_storage__exact=prev).update(
+                        db_cmdset_storage=curr
+                    )
+                if i == 2:
+                    evennia.AccountDB.objects.filter(db_typeclass_path__exact=prev).update(
+                        db_typeclass_path=curr
+                    )
+                if i in (3, 4, 5, 6):
+                    evennia.ObjectDB.objects.filter(db_typeclass_path__exact=prev).update(
+                        db_typeclass_path=curr
+                    )
+                if i == 7:
+                    evennia.ScriptDB.objects.filter(db_typeclass_path__exact=prev).update(
+                        db_typeclass_path=curr
+                    )
+                if i == 8:
+                    evennia.ChannelDB.objects.filter(db_typeclass_path__exact=prev).update(
+                        db_typeclass_path=curr
+                    )
+                # store the new default and clean caches
+                evennia.ServerConfig.objects.conf(settings_names[i], curr)
+                evennia.ObjectDB.flush_instance_cache()
+                evennia.AccountDB.flush_instance_cache()
+                evennia.ScriptDB.flush_instance_cache()
+                evennia.ChannelDB.flush_instance_cache()
+        # if this is the first start we might not have a "previous"
+        # setup saved. Store it now.
+        [
+            evennia.ServerConfig.objects.conf(settings_names[i], tup[1])
+            for i, tup in enumerate(settings_compare)
+            if not tup[0]
+        ]
+
+    def run_initial_setup(self):
+        """
+        This is triggered by the amp protocol when the connection
+        to the portal has been established.
+        This attempts to run the initial_setup script of the server.
+        It returns if this is not the first time the server starts.
+        Once finished the last_initial_setup_step is set to 'done'
+
+        """
+
+        initial_setup = importlib.import_module(settings.INITIAL_SETUP_MODULE)
+        last_initial_setup_step = evennia.ServerConfig.objects.conf("last_initial_setup_step")
+        try:
+            if not last_initial_setup_step:
+                # None is only returned if the config does not exist,
+                # i.e. this is an empty DB that needs populating.
+                self.info_dict["info"] = " Server started for the first time. Setting defaults."
+                initial_setup.handle_setup()
+            elif last_initial_setup_step not in ("done", -1):
+                # last step crashed, so we weill resume from this step.
+                # modules and setup will resume from this step, retrying
+                # the last failed module. When all are finished, the step
+                # is set to 'done' to show it does not need to be run again.
+                self.info_dict["info"] = " Resuming initial setup from step '{last}'.".format(
+                    last=last_initial_setup_step
+                )
+                initial_setup.handle_setup(last_initial_setup_step)
+        except Exception:
+            # stop server if this happens.
+            print(traceback.format_exc())
+            if not settings._TEST_ENVIRONMENT or not evennia.SESSION_HANDLER:
+                print("Error in initial setup. Stopping Server + Portal.")
+                evennia.SESSION_HANDLER.portal_shutdown()
+
+    def create_default_channels(self):
+        """
+        check so default channels exist on every restart, create if not.
+
+        """
+
+        from evennia import AccountDB
+        from evennia import ChannelDB
+        from evennia.utils.create import create_channel
+
+        superuser = AccountDB.objects.get(id=1)
+
+        # mudinfo
+        mudinfo_chan = settings.CHANNEL_MUDINFO
+        if mudinfo_chan and not ChannelDB.objects.filter(db_key__iexact=mudinfo_chan["key"]):
+            channel = create_channel(**mudinfo_chan)
+            channel.connect(superuser)
+        # connectinfo
+        connectinfo_chan = settings.CHANNEL_CONNECTINFO
+        if connectinfo_chan and not ChannelDB.objects.filter(
+            db_key__iexact=connectinfo_chan["key"]
+        ):
+            channel = create_channel(**connectinfo_chan)
+        # default channels
+        for chan_info in settings.DEFAULT_CHANNELS:
+            if not ChannelDB.objects.filter(db_key__iexact=chan_info["key"]):
+                channel = create_channel(**chan_info)
+                channel.connect(superuser)
+
+    def run_init_hooks(self, mode):
+        """
+        Called by the amp client once receiving sync back from Portal
+
+        Args:
+            mode (str): One of shutdown, reload or reset
+
+        """
+        from evennia.typeclasses.models import TypedObject
+
+        # start server time and maintenance task
+        self.maintenance_task = LoopingCall(self.server_maintenance)
+        self.maintenance_task.start(60, now=True)  # call every minute
+
+        # update eventual changed defaults
+        self.update_defaults()
+
+        # run at_init() on all cached entities on reconnect
+        [
+            [entity.at_init() for entity in typeclass_db.get_all_cached_instances()]
+            for typeclass_db in TypedObject.__subclasses__()
+        ]
+
+        self.at_server_init()
+
+        # call correct server hook based on start file value
+        if mode == "reload":
+            logger.log_msg("Server successfully reloaded.")
+            self.at_server_reload_start()
+        elif mode == "reset":
+            # only run hook, don't purge sessions
+            self.at_server_cold_start()
+            logger.log_msg("Evennia Server successfully restarted in 'reset' mode.")
+        elif mode == "shutdown":
+            from evennia.objects.models import ObjectDB
+
+            self.at_server_cold_start()
+            # clear eventual lingering session storages
+            ObjectDB.objects.clear_all_sessids()
+            logger.log_msg("Evennia Server successfully started.")
+
+        # always call this regardless of start type
+        self.at_server_start()
+
+    @defer.inlineCallbacks
+    def shutdown(self, mode="reload", _reactor_stopping=False):
+        """
+        Shuts down the server from inside it.
+
+        mode - sets the server restart mode.
+           - 'reload' - server restarts, no "persistent" scripts
+             are stopped, at_reload hooks called.
+           - 'reset' - server restarts, non-persistent scripts stopped,
+             at_shutdown hooks called but sessions will not
+             be disconnected.
+           - 'shutdown' - like reset, but server will not auto-restart.
+        _reactor_stopping - this is set if server is stopped by a kill
+           command OR this method was already called
+           once - in both cases the reactor is
+           dead/stopping already.
+        """
+        if _reactor_stopping and hasattr(self, "shutdown_complete"):
+            # this means we have already passed through this method
+            # once; we don't need to run the shutdown procedure again.
+            defer.returnValue(None)
+
+        if mode == "reload":
+            # call restart hooks
+            evennia.ServerConfig.objects.conf("server_restart_mode", "reload")
+            yield [o.at_server_reload() for o in evennia.ObjectDB.get_all_cached_instances()]
+            yield [p.at_server_reload() for p in evennia.AccountDB.get_all_cached_instances()]
+            yield [
+                (s._pause_task(auto_pause=True) if s.is_active else None, s.at_server_reload())
+                for s in evennia.ScriptDB.get_all_cached_instances()
+                if s.id
+            ]
+            yield evennia.SESSION_HANDLER.all_sessions_portal_sync()
+            self.at_server_reload_stop()
+            # only save monitor state on reload, not on shutdown/reset
+            from evennia.scripts.monitorhandler import MONITOR_HANDLER
+
+            MONITOR_HANDLER.save()
+        else:
+            if mode == "reset":
+                # like shutdown but don't unset the is_connected flag and don't disconnect sessions
+                yield [o.at_server_shutdown() for o in evennia.ObjectDB.get_all_cached_instances()]
+                yield [p.at_server_shutdown() for p in evennia.AccountDB.get_all_cached_instances()]
+                if self.amp_protocol:
+                    yield evennia.SESSION_HANDLER.all_sessions_portal_sync()
+            else:  # shutdown
+                yield [
+                    _SA(p, "is_connected", False)
+                    for p in evennia.AccountDB.get_all_cached_instances()
+                ]
+                yield [o.at_server_shutdown() for o in evennia.ObjectDB.get_all_cached_instances()]
+                yield [
+                    (p.unpuppet_all(), p.at_server_shutdown())
+                    for p in evennia.AccountDB.get_all_cached_instances()
+                ]
+                yield evennia.ObjectDB.objects.clear_all_sessids()
+            yield [
+                (s._pause_task(auto_pause=True), s.at_server_shutdown())
+                for s in evennia.ScriptDB.get_all_cached_instances()
+                if s.id and s.is_active
+            ]
+            evennia.ServerConfig.objects.conf("server_restart_mode", "reset")
+            self.at_server_cold_stop()
+
+        # tickerhandler state should always be saved.
+        from evennia.scripts.tickerhandler import TICKER_HANDLER
+
+        TICKER_HANDLER.save()
+
+        # always called, also for a reload
+        self.at_server_stop()
+
+        if hasattr(self, "web_root"):  # not set very first start
+            yield self.web_root.empty_threadpool()
+
+        if not _reactor_stopping:
+            # kill the server
+            self.shutdown_complete = True
+            reactor.callLater(1, reactor.stop)
+
+        # we make sure the proper gametime is saved as late as possible
+        evennia.ServerConfig.objects.conf("runtime", evennia.gametime.runtime())
+
+    def get_info_dict(self):
+        """
+        Return the server info, for display.
+
+        """
+        return self.info_dict
+
+    # server start/stop hooks
+
+    def _call_start_stop(self, hookname):
+        """
+        Helper method for calling hooks on all modules.
+
+        Args:
+            hookname (str): Name of hook to call.
+
+        """
+        for mod in self.start_stop_modules:
+            if hook := getattr(mod, hookname, None):
+                hook()
+
+    def at_server_init(self):
+        """
+        This is called first when the server is starting, before any other hooks, regardless of how it's starting.
+        """
+        self._call_start_stop("at_server_init")
+
+    def at_server_start(self):
+        """
+        This is called every time the server starts up, regardless of
+        how it was shut down.
+
+        """
+        self._call_start_stop("at_server_start")
+
+    def at_server_stop(self):
+        """
+        This is called just before a server is shut down, regardless
+        of it is fore a reload, reset or shutdown.
+
+        """
+        self._call_start_stop("at_server_stop")
+
+    def at_server_reload_start(self):
+        """
+        This is called only when server starts back up after a reload.
+
+        """
+        self._call_start_stop("at_server_reload_start")
+
+    def at_post_portal_sync(self, mode):
+        """
+        This is called just after the portal has finished syncing back data to the server
+        after reconnecting.
+
+        Args:
+            mode (str): One of 'reload', 'reset' or 'shutdown'.
+
+        """
+
+        from evennia.scripts.monitorhandler import MONITOR_HANDLER
+
+        MONITOR_HANDLER.restore(mode == "reload")
+
+        from evennia.scripts.tickerhandler import TICKER_HANDLER
+
+        TICKER_HANDLER.restore(mode == "reload")
+
+        # Un-pause all scripts, stop non-persistent timers
+        evennia.ScriptDB.objects.update_scripts_after_server_start()
+
+        # start the task handler
+        from evennia.scripts.taskhandler import TASK_HANDLER
+
+        TASK_HANDLER.load()
+        TASK_HANDLER.create_delays()
+
+        # create/update channels
+        self.create_default_channels()
+
+        # delete the temporary setting
+        evennia.ServerConfig.objects.conf("server_restart_mode", delete=True)
+
+    def at_server_reload_stop(self):
+        """
+        This is called only time the server stops before a reload.
+
+        """
+        self._call_start_stop("at_server_reload_stop")
+
+    def at_server_cold_start(self):
+        """
+        This is called only when the server starts "cold", i.e. after a
+        shutdown or a reset.
+
+        """
+        # We need to do this just in case the server was killed in a way where
+        # the normal cleanup operations did not have time to run.
+        from evennia.objects.models import ObjectDB
+
+        ObjectDB.objects.clear_all_sessids()
+
+        # Remove non-persistent scripts
+        from evennia.scripts.models import ScriptDB
+
+        for script in ScriptDB.objects.filter(db_persistent=False):
+            script._stop_task()
+
+        if settings.GUEST_ENABLED:
+            for guest in evennia.AccountDB.objects.all().filter(
+                db_typeclass_path=settings.BASE_GUEST_TYPECLASS
+            ):
+                for character in guest.db._playable_characters:
+                    if character:
+                        character.delete()
+                guest.delete()
+        self._call_start_stop("at_server_cold_start")
+
+    def at_server_cold_stop(self):
+        """
+        This is called only when the server goes down due to a shutdown or reset.
+
+        """
+        self._call_start_stop("at_server_cold_stop")

evennia/server/sessionhandler.py

@@ -18,6 +18,7 @@ from codecs import decode as codecs_decode
 from django.conf import settings
 from django.utils.translation import gettext as _
 
+import evennia
 from evennia.commands.cmdhandler import CMD_LOGINSTART
 from evennia.server.portal import amp
 from evennia.server.signals import (
@@ -306,8 +307,7 @@ class ServerSessionHandler(SessionHandler):
 
         """
         super().__init__(*args, **kwargs)
-        self.server = None  # set at server initialization
+        evennia.server_data = {"servername": _SERVERNAME}
-        self.server_data = {"servername": _SERVERNAME}
         # will be set on psync
         self.portal_start_time = 0.0
 
@@ -411,7 +411,7 @@ class ServerSessionHandler(SessionHandler):
         mode = "reload"
 
         # tell the server hook we synced
-        self.server.at_post_portal_sync(mode)
+        evennia.EVENNIA_SERVER_SERVICE.at_post_portal_sync(mode)
         # announce the reconnection
         if _BROADCAST_SERVER_RESTART_MESSAGES:
             self.announce_all(_(" ... Server restarted."))
@@ -467,7 +467,7 @@ class ServerSessionHandler(SessionHandler):
             the Server.
 
         """
-        self.server.amp_protocol.send_AdminServer2Portal(
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
             DUMMYSESSION, operation=amp.SCONN, protocol_path=protocol_path, config=configdict
         )
 
@@ -476,14 +476,18 @@ class ServerSessionHandler(SessionHandler):
         Called by server when reloading. We tell the portal to start a new server instance.
 
         """
-        self.server.amp_protocol.send_AdminServer2Portal(DUMMYSESSION, operation=amp.SRELOAD)
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
+            DUMMYSESSION, operation=amp.SRELOAD
+        )
 
     def portal_reset_server(self):
         """
         Called by server when reloading. We tell the portal to start a new server instance.
 
         """
-        self.server.amp_protocol.send_AdminServer2Portal(DUMMYSESSION, operation=amp.SRESET)
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
+            DUMMYSESSION, operation=amp.SRESET
+        )
 
     def portal_shutdown(self):
         """
@@ -491,7 +495,9 @@ class ServerSessionHandler(SessionHandler):
         itself down)
 
         """
-        self.server.amp_protocol.send_AdminServer2Portal(DUMMYSESSION, operation=amp.PSHUTD)
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
+            DUMMYSESSION, operation=amp.PSHUTD
+        )
 
     def login(self, session, account, force=False, testmode=False):
         """
@@ -537,7 +543,7 @@ class ServerSessionHandler(SessionHandler):
         session.logged_in = True
         # sync the portal to the session
         if not testmode:
-            self.server.amp_protocol.send_AdminServer2Portal(
+            evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
                 session, operation=amp.SLOGIN, sessiondata={"logged_in": True, "uid": session.uid}
             )
         account.at_post_login(session=session)
@@ -582,7 +588,7 @@ class ServerSessionHandler(SessionHandler):
             del self[sessid]
         if sync_portal:
             # inform portal that session should be closed.
-            self.server.amp_protocol.send_AdminServer2Portal(
+            evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
                 session, operation=amp.SDISCONN, reason=reason
             )
 
@@ -593,7 +599,7 @@ class ServerSessionHandler(SessionHandler):
 
         """
         sessdata = self.get_all_sync_data()
-        return self.server.amp_protocol.send_AdminServer2Portal(
+        return evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
             DUMMYSESSION, operation=amp.SSYNC, sessiondata=sessdata
         )
 
@@ -604,7 +610,7 @@ class ServerSessionHandler(SessionHandler):
 
         """
         sessdata = {session.sessid: session.get_sync_data()}
-        return self.server.amp_protocol.send_AdminServer2Portal(
+        return evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
             DUMMYSESSION, operation=amp.SSYNC, sessiondata=sessdata, clean=False
         )
 
@@ -617,7 +623,7 @@ class ServerSessionHandler(SessionHandler):
                 more sessions in detail.
 
         """
-        return self.server.amp_protocol.send_AdminServer2Portal(
+        return evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
             DUMMYSESSION, operation=amp.SSYNC, sessiondata=session_data, clean=False
         )
 
@@ -633,7 +639,7 @@ class ServerSessionHandler(SessionHandler):
         for session in self:
             del session
         # tell portal to disconnect all sessions
-        self.server.amp_protocol.send_AdminServer2Portal(
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_AdminServer2Portal(
             DUMMYSESSION, operation=amp.SDISCONNALL, reason=reason
         )
 
@@ -817,7 +823,7 @@ class ServerSessionHandler(SessionHandler):
         kwargs = self.clean_senddata(session, kwargs)
 
         # send across AMP
-        self.server.amp_protocol.send_MsgServer2Portal(session, **kwargs)
+        evennia.EVENNIA_SERVER_SERVICE.amp_protocol.send_MsgServer2Portal(session, **kwargs)
 
     def get_inputfuncs(self):
         """

evennia/server/tests/test_amp_connection.py

@@ -11,9 +11,14 @@ from model_mommy import mommy
 from twisted.internet.base import DelayedCall
 from twisted.trial.unittest import TestCase as TwistedTestCase
 
+import evennia
 from evennia.server import amp_client, server, serversession, session
 from evennia.server.portal import amp, amp_server, portal
 from evennia.utils import create
+from evennia.server.service import EvenniaServerService
+from evennia.server.portal.service import EvenniaPortalService
+from evennia.server.sessionhandler import ServerSessionHandler
+from evennia.server.portal.portalsessionhandler import PortalSessionHandler
 
 DelayedCall.debug = True
 
@@ -24,22 +29,23 @@ class _TestAMP(TwistedTestCase):
     def setUp(self):
         super().setUp()
         self.account = mommy.make("accounts.AccountDB", id=1)
-        self.server = server.Evennia(MagicMock())
+        self.server = EvenniaServerService()
-        self.server.sessions.data_in = MagicMock()
+        evennia.SERVER_SESSION_HANDLER = ServerSessionHandler()
-        self.server.sessions.data_out = MagicMock()
+        evennia.SERVER_SESSION_HANDLER.data_in = MagicMock()
+        evennia.SERVER_SESSION_HANDLER.data_out = MagicMock()
         self.amp_client_factory = amp_client.AMPClientFactory(self.server)
         self.amp_client = self.amp_client_factory.buildProtocol("127.0.0.1")
         self.session = MagicMock()  # serversession.ServerSession()
         self.session.sessid = 1
-        self.server.sessions[1] = self.session
+        evennia.SERVER_SESSION_HANDLER[1] = self.session
 
-        self.portal = portal.Portal(MagicMock())
+        self.portal = EvenniaPortalService()
-        self.portal.maintenance_task.stop()
         self.portalsession = session.Session()
         self.portalsession.sessid = 1
-        self.portal.sessions[1] = self.portalsession
+        evennia.PORTAL_SESSION_HANDLER = PortalSessionHandler()
-        self.portal.sessions.data_in = MagicMock()
+        evennia.PORTAL_SESSION_HANDLER[1] = self.portalsession
-        self.portal.sessions.data_out = MagicMock()
+        evennia.PORTAL_SESSION_HANDLER.data_in = MagicMock()
+        evennia.PORTAL_SESSION_HANDLER.data_out = MagicMock()
         self.amp_server_factory = amp_server.AMPServerFactory(self.portal)
         self.amp_server = self.amp_server_factory.buildProtocol("127.0.0.1")
 
@@ -72,7 +78,7 @@ class _TestAMP(TwistedTestCase):
         return all_sent
 
 
-@patch("evennia.server.server.LoopingCall", MagicMock())
+@patch("evennia.server.service.LoopingCall", MagicMock())
 @patch("evennia.server.portal.amp.amp.BinaryBoxProtocol.transport")
 class TestAMPClientSend(_TestAMP):
     """Test amp client sending data"""
@@ -84,7 +90,9 @@ class TestAMPClientSend(_TestAMP):
 
         self._connect_server(mocktransport)
         self.amp_server.dataReceived(wire_data)
-        self.portal.sessions.data_out.assert_called_with(self.portalsession, text={"foo": "bar"})
+        evennia.PORTAL_SESSION_HANDLER.data_out.assert_called_with(
+            self.portalsession, text={"foo": "bar"}
+        )
 
     def test_adminserver2portal(self, mocktransport):
         self._connect_client(mocktransport)
@@ -111,7 +119,7 @@ class TestAMPClientRecv(_TestAMP):
 
         self._connect_client(mocktransport)
         self.amp_client.dataReceived(wire_data)
-        self.server.sessions.data_in.assert_called_with(self.session, text={"foo": "bar"})
+        evennia.SERVER_SESSION_HANDLER.data_in.assert_called_with(self.session, text={"foo": "bar"})
 
     def test_adminportal2server(self, mocktransport):
         self._connect_server(mocktransport)
@@ -120,6 +128,6 @@ class TestAMPClientRecv(_TestAMP):
         wire_data = self._catch_wire_read(mocktransport)[0]
 
         self._connect_client(mocktransport)
-        self.server.sessions.portal_disconnect_all = MagicMock()
+        evennia.SERVER_SESSION_HANDLER.portal_disconnect_all = MagicMock()
         self.amp_client.dataReceived(wire_data)
-        self.server.sessions.portal_disconnect_all.assert_called()
+        evennia.SERVER_SESSION_HANDLER.portal_disconnect_all.assert_called()

evennia/server/tests/test_server.py

@@ -2,14 +2,14 @@
 Test the main server component
 
 """
-
+import evennia
 from unittest import TestCase
 
 from django.test import override_settings
 from mock import DEFAULT, MagicMock, call, patch
 
 
-@patch("evennia.server.server.LoopingCall", new=MagicMock())
+@patch("evennia.server.service.LoopingCall", new=MagicMock())
 class TestServer(TestCase):
     """
     Test server module.
@@ -17,78 +17,76 @@ class TestServer(TestCase):
     """
 
     def setUp(self):
+        # Running this first line ensures that the EVENNIA_SERVICE is instantiated.
         from evennia.server import server
 
-        self.server = server
+        self.server = evennia.EVENNIA_SERVER_SERVICE
 
+    @override_settings(IDMAPPER_CACHE_MAXSIZE=1000)
     def test__server_maintenance_reset(self):
-        with patch.multiple(
+        with patch.object(self.server, "_flush_cache", new=MagicMock()) as mockflush, patch.object(
-            "evennia.server.server",
+            evennia, "ServerConfig", new=MagicMock()
+        ) as mockconf, patch.multiple(
+            "evennia.server.service",
             LoopingCall=DEFAULT,
-            Evennia=DEFAULT,
-            _FLUSH_CACHE=DEFAULT,
             connection=DEFAULT,
-            _IDMAPPER_CACHE_MAXSIZE=1000,
-            _MAINTENANCE_COUNT=0,
-            ServerConfig=DEFAULT,
         ) as mocks:
+            self.server.maintenance_count = 0
+
             mocks["connection"].close = MagicMock()
-            mocks["ServerConfig"].objects.conf = MagicMock(return_value=456)
+            mockconf.objects.conf = MagicMock(return_value=456)
 
             # flush cache
-            self.server._server_maintenance()
+            self.server.server_maintenance()
-            mocks["ServerConfig"].objects.conf.assert_called_with("runtime", 456)
+            mockconf.objects.conf.assert_called_with("runtime", 456)
 
+    @override_settings(IDMAPPER_CACHE_MAXSIZE=1000)
     def test__server_maintenance_flush(self):
         with patch.multiple(
-            "evennia.server.server",
+            "evennia.server.service",
             LoopingCall=DEFAULT,
-            Evennia=DEFAULT,
-            _FLUSH_CACHE=DEFAULT,
             connection=DEFAULT,
-            _IDMAPPER_CACHE_MAXSIZE=1000,
+        ) as mocks, patch.object(
-            _MAINTENANCE_COUNT=5 - 1,
+            evennia, "ServerConfig", new=MagicMock()
-            ServerConfig=DEFAULT,
+        ) as mockconf, patch.object(
-        ) as mocks:
+            self.server, "_flush_cache", new=MagicMock()
+        ) as mockflush:
             mocks["connection"].close = MagicMock()
-            mocks["ServerConfig"].objects.conf = MagicMock(return_value=100)
+            mockconf.objects.conf = MagicMock(return_value=100)
-
+            self.server.maintenance_count = 5 - 1
             # flush cache
-            self.server._server_maintenance()
+            self.server.server_maintenance()
-            mocks["_FLUSH_CACHE"].assert_called_with(1000)
+            self.server._flush_cache.assert_called_with(1000)
 
+    @override_settings(IDMAPPER_CACHE_MAXSIZE=1000)
     def test__server_maintenance_close_connection(self):
         with patch.multiple(
-            "evennia.server.server",
+            "evennia.server.service",
             LoopingCall=DEFAULT,
-            Evennia=DEFAULT,
-            _FLUSH_CACHE=DEFAULT,
             connection=DEFAULT,
-            _IDMAPPER_CACHE_MAXSIZE=1000,
+        ) as mocks, patch.object(evennia, "ServerConfig", new=MagicMock()) as mockconf:
-            _MAINTENANCE_COUNT=(60 * 7) - 1,
+            self.server._flush_cache = MagicMock()
-            _LAST_SERVER_TIME_SNAPSHOT=0,
+            self.server.maintenance_count = (60 * 7) - 1
-            ServerConfig=DEFAULT,
+            self.server._last_server_time_snapshot = 0
-        ) as mocks:
             mocks["connection"].close = MagicMock()
-            mocks["ServerConfig"].objects.conf = MagicMock(return_value=100)
+            mockconf.objects.conf = MagicMock(return_value=100)
-            self.server._server_maintenance()
+            self.server.server_maintenance()
             mocks["connection"].close.assert_called()
 
+    @override_settings(IDLE_TIMEOUT=10)
     def test__server_maintenance_idle_time(self):
         with patch.multiple(
-            "evennia.server.server",
+            "evennia.server.service",
             LoopingCall=DEFAULT,
-            Evennia=DEFAULT,
-            _FLUSH_CACHE=DEFAULT,
             connection=DEFAULT,
-            _IDMAPPER_CACHE_MAXSIZE=1000,
-            _MAINTENANCE_COUNT=(3600 * 7) - 1,
-            _LAST_SERVER_TIME_SNAPSHOT=0,
-            SESSIONS=DEFAULT,
-            _IDLE_TIMEOUT=10,
             time=DEFAULT,
-            ServerConfig=DEFAULT,
+        ) as mocks, patch.object(
-        ) as mocks:
+            evennia, "ServerConfig", new=MagicMock()
+        ) as mockconf, patch.object(
+            evennia, "SESSION_HANDLER", new=MagicMock()
+        ) as mocksess:
+            self.server.maintenance_count = (3600 * 7) - 1
+            self.server._last_server_time_snapshot = 0
             sess1 = MagicMock()
             sess2 = MagicMock()
             sess3 = MagicMock()
@@ -105,31 +103,25 @@ class TestServer(TestCase):
 
             mocks["time"].time = MagicMock(return_value=1000)
 
-            mocks["ServerConfig"].objects.conf = MagicMock(return_value=100)
+            mockconf.objects.conf = MagicMock(return_value=100)
-            mocks["SESSIONS"].values = MagicMock(return_value=[sess1, sess2, sess3, sess4])
+            mocksess.values = MagicMock(return_value=[sess1, sess2, sess3, sess4])
-            mocks["SESSIONS"].disconnect = MagicMock()
+            mocksess.disconnect = MagicMock()
 
-            self.server._server_maintenance()
+            self.server.server_maintenance()
             reason = "idle timeout exceeded"
             calls = [call(sess1, reason=reason), call(sess4, reason=reason)]
-            mocks["SESSIONS"].disconnect.assert_has_calls(calls, any_order=True)
+            mocksess.disconnect.assert_has_calls(calls, any_order=True)
 
-    def test_evennia_start(self):
+    def test_update_defaults(self):
-        with patch.multiple("evennia.server.server", time=DEFAULT, service=DEFAULT) as mocks:
+        with patch.object(evennia, "ObjectDB", new=MagicMock()) as mockobj, patch.object(
-            mocks["time"].time = MagicMock(return_value=1000)
+            evennia, "AccountDB", new=MagicMock()
-            evennia = self.server.Evennia(MagicMock())
+        ) as mockacc, patch.object(evennia, "ScriptDB", new=MagicMock()) as mockscr, patch.object(
-            self.assertEqual(evennia.start_time, 1000)
+            evennia, "ChannelDB", new=MagicMock()
-
+        ) as mockchan, patch.object(
-    @patch("evennia.objects.models.ObjectDB")
+            evennia, "ServerConfig", new=MagicMock()
-    @patch("evennia.server.server.AccountDB")
+        ) as mockconf:
-    @patch("evennia.server.server.ScriptDB")
+            for m in (mockscr, mockobj, mockacc, mockchan):
-    @patch("evennia.comms.models.ChannelDB")
+                m.objects.filter = MagicMock()
-    def test_update_defaults(self, mockchan, mockscript, mockacct, mockobj):
-        with patch.multiple("evennia.server.server", ServerConfig=DEFAULT) as mocks:
-            mockchan.objects.filter = MagicMock()
-            mockscript.objects.filter = MagicMock()
-            mockacct.objects.filter = MagicMock()
-            mockobj.objects.filter = MagicMock()
 
             # fake mismatches
             settings_names = (
@@ -148,16 +140,14 @@ class TestServer(TestCase):
             def _mock_conf(key, *args):
                 return fakes[key]
 
-            mocks["ServerConfig"].objects.conf = _mock_conf
+            mockconf.objects.conf = _mock_conf
 
-            evennia = self.server.Evennia(MagicMock())
+            self.server.update_defaults()
-            evennia.update_defaults()
 
-            mockchan.objects.filter.assert_called()
+            for m in (mockscr, mockobj, mockacc, mockchan):
-            mockscript.objects.filter.assert_called()
+                m.objects.filter.assert_called()
-            mockacct.objects.filter.assert_called()
-            mockobj.objects.filter.assert_called()
 
+    @override_settings(_TEST_ENVIRONMENT=True)
     def test_initial_setup(self):
         from evennia.utils.create import create_account
 
@@ -167,10 +157,10 @@ class TestServer(TestCase):
             "evennia.server.initial_setup", reset_server=DEFAULT, AccountDB=DEFAULT
         ) as mocks:
             mocks["AccountDB"].objects.get = MagicMock(return_value=acct)
-            evennia = self.server.Evennia(MagicMock())
+            self.server.run_initial_setup()
-            evennia.run_initial_setup()
         acct.delete()
 
+    @override_settings(_TEST_ENVIRONMENT=True)
     def test_initial_setup_retry(self):
         from evennia.utils.create import create_account
 
@@ -185,14 +175,12 @@ class TestServer(TestCase):
             mocks["AccountDB"].objects.get = MagicMock(return_value=acct)
             # a last_initial_setup_step > 0
             mocks["ServerConfig"].objects.conf = MagicMock(return_value=4)
-            evennia = self.server.Evennia(MagicMock())
+            self.server.run_initial_setup()
-            evennia.run_initial_setup()
         acct.delete()
 
-    @patch("evennia.server.server.INFO_DICT", {"test": "foo"})
     def test_get_info_dict(self):
-        evennia = self.server.Evennia(MagicMock())
+        with patch.object(self.server, "get_info_dict", return_value={"test": "foo"}) as mocks:
-        self.assertEqual(evennia.get_info_dict(), {"test": "foo"})
+            self.assertEqual(self.server.get_info_dict(), {"test": "foo"})
 
 
 class TestInitHooks(TestCase):
@@ -200,7 +188,7 @@ class TestInitHooks(TestCase):
         from evennia.server import server
         from evennia.utils import create
 
-        self.server = server
+        self.server = evennia.EVENNIA_SERVER_SERVICE
 
         self.obj1 = create.object(key="HookTestObj1")
         self.obj2 = create.object(key="HookTestObj2")
@@ -211,44 +199,35 @@ class TestInitHooks(TestCase):
         self.script1 = create.script(key="script1")
         self.script2 = create.script(key="script2")
 
-        self.obj1.at_init = MagicMock()
+        self.objects = [
-        self.obj2.at_init = MagicMock()
+            self.obj1,
-        self.acct1.at_init = MagicMock()
+            self.obj2,
-        self.acct2.at_init = MagicMock()
+            self.acct1,
-        self.chan1.at_init = MagicMock()
+            self.acct2,
-        self.chan2.at_init = MagicMock()
+            self.chan1,
-        self.script1.at_init = MagicMock()
+            self.chan2,
-        self.script2.at_init = MagicMock()
+            self.script1,
+            self.script2,
+        ]
+
+        for obj in self.objects:
+            obj.at_init = MagicMock()
 
     def tearDown(self):
-        self.obj1.delete()
+        for obj in self.objects:
-        self.obj2.delete()
+            obj.delete()
-        self.acct1.delete()
-        self.acct2.delete()
-        self.chan1.delete()
-        self.chan2.delete()
-        self.script1.delete()
-        self.script2.delete()
 
     @override_settings(_TEST_ENVIRONMENT=True)
     def test_run_init_hooks(self):
-        evennia = self.server.Evennia(MagicMock())
+        with patch.object(
+            self.server, "at_server_reload_start", new=MagicMock()
+        ) as reload, patch.object(self.server, "at_server_cold_start", new=MagicMock()) as cold:
+            self.server.run_init_hooks("reload")
+            self.server.run_init_hooks("reset")
+            self.server.run_init_hooks("shutdown")
 
-        evennia.at_server_reload_start = MagicMock()
+            for obj in self.objects:
-        evennia.at_server_cold_start = MagicMock()
+                obj.at_init.assert_called()
 
-        evennia.run_init_hooks("reload")
+            for hook in (reload, cold):
-        evennia.run_init_hooks("reset")
+                hook.assert_called()
-        evennia.run_init_hooks("shutdown")
-
-        self.acct1.at_init.assert_called()
-        self.acct2.at_init.assert_called()
-        self.obj1.at_init.assert_called()
-        self.obj2.at_init.assert_called()
-        self.chan1.at_init.assert_called()
-        self.chan2.at_init.assert_called()
-        self.script1.at_init.assert_called()
-        self.script2.at_init.assert_called()
-
-        evennia.at_server_reload_start.assert_called()
-        evennia.at_server_cold_start.assert_called()

evennia/server/tests/testrunner.py

@@ -5,8 +5,6 @@ all over the code base and runs them.
 Runs as part of the Evennia's test suite with 'evennia test evennia"
 
 """
-from unittest import mock
-
 from django.test.runner import DiscoverRunner
 
 
@@ -19,16 +17,7 @@ class EvenniaTestSuiteRunner(DiscoverRunner):
     """
 
     def setup_test_environment(self, **kwargs):
-        # the portal looping call starts before the unit-test suite so we
-        # can't mock it - instead we stop it before starting the test - otherwise
-        # we'd get unclean reactor errors across test boundaries.
-        from evennia.server.portal.portal import PORTAL
-
-        PORTAL.maintenance_task.stop()
-
-        # initialize evennia itself
         import evennia
-
         evennia._init()
 
         from django.conf import settings

evennia/settings_default.py

@@ -127,6 +127,7 @@ EVENNIA_ADMIN = True
 # operating between two processes on the same machine. You usually don't need to
 # change this unless you cannot use the default AMP port/host for
 # whatever reason.
+AMP_ENABLED = True
 AMP_HOST = "localhost"
 AMP_PORT = 4006
 AMP_INTERFACE = "127.0.0.1"
@@ -1155,6 +1156,10 @@ REST_API_ENABLED = False
 # together with your own variations. You should usually never have to touch
 # this, and if so, you really need to know what you are doing.
 
+# The primary Twisted Services used to start up Evennia.
+EVENNIA_SERVER_SERVICE_CLASS = "evennia.server.service.EvenniaServerService"
+EVENNIA_PORTAL_SERVICE_CLASS = "evennia.server.portal.service.EvenniaPortalService"
+
 # The Base Session Class is used as a parent class for all Protocols such as
 # Telnet and SSH.) Changing this could be really dangerous. It will cascade
 # to tons of classes. You generally shouldn't need to touch protocols.