Class AbstractServerApplication

java.lang.Object
org.tentackle.app.AbstractApplication
org.tentackle.persist.app.AbstractServerApplication
All Implemented Interfaces:
Application, ConnectionManagerProvider, DomainContextProvider, org.tentackle.session.SessionPoolProvider, org.tentackle.session.SessionProvider
Direct Known Subclasses:
ServerApplication

public abstract class AbstractServerApplication extends AbstractApplication implements org.tentackle.session.SessionPoolProvider, ConnectionManagerProvider
Base class for server applications.

A server application is either connected directly to the database (and serves the client sessions from a SessionPool via its own ConnectionManager), or is itself a client of another server (and serves the client sessions from a MultiUserSessionPool of remote sessions). Server applications may also run within a container, such as a servlet engine.

Author:
harald
  • Constructor Details

    • AbstractServerApplication

      public AbstractServerApplication(String name, String version)
      Creates a server.
      Parameters:
      name - the application name, null for default name
      version - the application version, null for the default version
  • Method Details

    • getSessionPool

      public org.tentackle.session.SessionPool getSessionPool()

      The pool is created by finishStartup() if the server is connected directly to the database.

      Specified by:
      getSessionPool in interface org.tentackle.session.SessionPoolProvider
      Returns:
      the session pool, null if the server's session is remote or not started yet
    • getRemoteSessionPool

      public org.tentackle.session.MultiUserSessionPool getRemoteSessionPool()

      The pool is created by finishStartup() if the server is a client of another server.

      Specified by:
      getRemoteSessionPool in interface org.tentackle.session.SessionPoolProvider
      Returns:
      the remote session pool, null if the server's session is local or not started yet
    • isServer

      public boolean isServer()
      Specified by:
      isServer in interface Application
      Overrides:
      isServer in class AbstractApplication
    • setSessionInfo

      protected void setSessionInfo(org.tentackle.session.SessionInfo sessionInfo)

      Overridden to protect the SessionInfo once it is set. The session info is made immutable.

      Overrides:
      setSessionInfo in class AbstractApplication
      Throws:
      org.tentackle.session.PersistenceException - if the session info is already set
    • configurePreferences

      protected void configurePreferences()

      Overridden to restrict the server to system preferences.

      Overrides:
      configurePreferences in class AbstractApplication
    • configureModificationTracker

      protected void configureModificationTracker()

      Overridden to set the tracker's sleep interval to 1 second.

      Overrides:
      configureModificationTracker in class AbstractApplication
    • initializeScripting

      protected void initializeScripting()

      Overridden to validate the validators afterward.

      Overrides:
      initializeScripting in class AbstractApplication
      See Also:
    • validateValidators

      protected void validateValidators()
      Validates the validators.
      The default implementation loads all field- and object-Validators of all PDO classes and invokes Validator.validate(). This will load all CompoundValues and compile the scripts, if any. Thus, configuration errors are detected at server startup.
    • finishStartup

      protected void finishStartup()

      Overridden to create the session pool and connection manager for local sessions, or the remote session pool if this server is a client of another server.

      Overrides:
      finishStartup in class AbstractApplication
    • createSessionPool

      public org.tentackle.session.SessionPool createSessionPool()
      Creates the session pool to serve the client sessions.
      Returns:
      the session pool
    • createRemoteSessionPool

      public org.tentackle.session.MultiUserSessionPool createRemoteSessionPool()
      Creates the remote session pool to serve the client sessions.
      If the server's main session does not belong to a session group yet, a new group is created with the main session, so that all pooled sessions are closed if the main session dies.
      Returns:
      the session pool
    • getSession

      public Db getSession()
      Specified by:
      getSession in interface org.tentackle.session.SessionProvider
      Overrides:
      getSession in class AbstractApplication
    • createConnectionManager

      protected ConnectionManager createConnectionManager()
      Creates the connection manager for the client sessions.
      The default creates an MpxConnectionManager with session IDs following those of the server's own connection manager.
      Returns:
      the connection manager
    • getConnectionManager

      public ConnectionManager getConnectionManager()
      Specified by:
      getConnectionManager in interface ConnectionManagerProvider
    • configureSessionInfo

      protected void configureSessionInfo(org.tentackle.session.SessionInfo sessionInfo)
      Configures the session info of the server's main session.
      Loads the session properties and merges the application properties into them. Application properties override those from a file or the classpath.
      Parameters:
      sessionInfo - the session info
    • startup

      protected void startup()

      Registers and initializes the server, logs into the backend, configures the server and finishes the startup.

      Specified by:
      startup in class AbstractApplication
    • login

      protected void login()
      Connects the server to the database backend or another remote server.
      Creates the server's main session, makes it the current session and sets the application's session info and domain context.
    • cleanup

      protected void cleanup()

      Overridden to shut down the session pools and the connection manager. If running in a container, the JDBC drivers loaded by the application are deregistered.

      Overrides:
      cleanup in class AbstractApplication
    • isRunningInContainer

      public boolean isRunningInContainer()
      Indicates whether this application is running within a container.
      Returns:
      true if running in a container, false if not
    • isSystemExitNecessaryToStop

      protected boolean isSystemExitNecessaryToStop()
      Overrides:
      isSystemExitNecessaryToStop in class AbstractApplication
    • detectContainer

      protected void detectContainer()
      Detects whether this application is running within a container.
      The result can be retrieved by isRunningInContainer().
    • deregisterJdbcDrivers

      protected void deregisterJdbcDrivers(ClassLoader cl)
      Deregisters all JDBC drivers loaded by the app's classloader.
      Necessary in containers only (in case connected directly via JDBC and not via JNDI). Avoids memory leaks.
      Parameters:
      cl - the app's classloader
    • activateStatistics

      protected void activateStatistics()

      Overridden to collect the statistics of remote invocations, connections and transactions as well.

      Overrides:
      activateStatistics in class AbstractApplication
    • logStatistics

      public void logStatistics()
      Logs and clears the statistics.
      Overridden to log the statement and transaction statistics as well.
      Overrides:
      logStatistics in class AbstractApplication