FWD » Core Development » Runtime Infrastructure

/*

** Module   : StandardServer.java

** Abstract : standard server application

**

** Copyright (c) 2005-2023, Golden Code Development Corporation.

**

** -#- -I- --Date-- --JPRM-- ---------------------------------Description-------------------------------------

** 001 NVS 20050831   @22451 Created the initial version. 

** 002 NVS 20050915   @22735 Alternative path /server/default/exports is

**                           tried if no /server/serverID/exports exists.

**                           Standard entry point processing added, based

**                           on directory entries under /server/serverID/

**                           entry/accountID.

** 003 NVS 20051221   @23733 Saves the reference to the queue in the session

**                           context so it can be accessed at any time.

** 004 GES 20060110   @23850 Implemented proper transaction manager

**                           infrastructure and init such that converted

**                           P2J applications can be run with this

**                           class as their launch point.

** 005 ECF 20060114   @23904 Moved instantiation of target class to the

**                           invoke() method. This is necessary to include

**                           constructors/initializers within the first

**                           TransactionManager scope created. Modified

**                           various catch statements to not discard stack

**                           traces of caught exceptions.

** 006 GES 20060130   @24143 Added quit state flag processing in invoke.

** 007 GES 20060202   @24229 Added new flag in pushScope() signature.

** 008 GES 20060203   @24244 Changed TransactionManager method name

**                           makeBackup() to blockSetup().

** 009 GES 20060210   @24528 Shifted to a simpler approach for server

**                           exports. First pass (more is coming later).

** 010 NVS 20060226   @24750 Made portions of invoke() reusable in Utils.

**                           Calling reusable invoke() method from here.

** 011 GES 20060305   @24891 Cleaned up logging.

** 012 NVS 20060306   @24901 Added exports registration for ErrorManager.

** 013 GES 20060314   @25062 Fixed exception processing to properly retry on STOP.

** 014 NVS 20060417   @25578 Added support for the password aging. Before

**                           the configured application entry point is

**                           taken, the user account is checked for the

**                           aged password, and, if so, the password

**                           change method is called..

** 015 GES 20060608   @27054 Added logging of any abnormal end before it

**                           is re-thrown.  ConditionExceptions and

**                           RetryUnwindExceptions are not logged as these

**                           are "normal" transaction manager flow of

**                           control interactions.

** 016 NVS 20060614   @27196 Fixed a problem with NET package exports of

**                           SecurityManager class.

**                           Added a call to RemoteObject to do deferred

**                           registrations.

** 017 GES 20060804   @28432 Honor new iterate() processing which only

**                           happens at the top of the block body.

** 018 NVS 20060617   @30461 Implemented stop_disposition configuration

**                           option reading and honoring when the business

**                           logic encounters STOP condition.

** 019 GES 20061212   @31666 Force "quit" processing in any fatal abend

**                           (something other than one of the "expected"

**                           4GL conditions).  This avoids a call to

**                           LogicalTerminal.pauseBeforeEnd() which will

**                           fail in any case where we are exiting because

**                           the client was forcefully disconnected.

** 020 GES 20061219   @31718 Removed dead code.

** 021 GES 20070111   @31782 Reworked notifiable interface as needed.

** 022 NVS 20070126   @32004 Application entry point is now the subject to

**                           the standardized search in the directory.

**                           The node is named "p2j-entry" to separate it

**                           from the server level entry point.

** 023 NVS 20070221   @32381 Administration Server exports are registered.

** 024 EVL 20070609   @34005 Adding explicit import of the class

**                           com.goldencode.p2j.net.Queue to eliminate

**                           conflict with the same class from java.util

**                           package to be able to compile for Java 6

** 025 GES 20071011   @35424 Eliminated compile warning.

** 026 ECF 20071112   @35892 Refactored to leverage net package changes.

**                           Replaced initialize() with bootstrap(). All

**                           non-network function that was previously in

**                           ServerBootstrap is now in this class, while

**                           the network-specific function is now handled

**                           by the net package's SessionManager.

** 027 GES 20071214   @36410 Added code to translate unexpected exceptions

**                           (but not errors) into a stop condition. This

**                           will avoid the silent drop-out to the command

**                           line unless the stop disposition is also

**                           configured to silently exit (disposition 2).

** 028 GES 20080409   @37912 Export remote directory access when the network protocol is ready.

** 029 NVS 20090312   @41522 Added initialization of the AdminServerImpl class.

** 030 SIY 20090507   @42111 Added support for context hooks.

** 031 SIY 20090511   @42142 Added support for server hooks.

** 032 SIY 20090512   @42144 Reworked server hooks to support more than one server hook.

** 033 SIY 20090515   @42188 All services now are started as server hooks and hardcoded.

** 034 NVS 20090528   @42482 Custom account extension plugin is loaded at startup, if defined

**                           in the directory

** 035 GES 20090722   @43331 Handle chained errors as errors not exceptions.

** 036 GES 20090723   @43359 Avoid logging STOP conditions.

** 037 NVS 20090817   @43684 Server hook load failures are logged but are not critical for the

**                           server startup.

** 038 NVS 20090818   @43690 Excluded the exception stack trace from the error message in #037.

** 039 NVS 20090821   @43711 Admin Enabled flag is now searched correctly scoped to the per 

**                           server scope.

** 040 NVS 20090826   @43775 Passing server name to the LogHelper.initialize().

** 041 ECF 20090827   @43787 Fixed logging to file. SecureFileHandler is now used when

**                           initializing the LogHelper, and is closed when the server is 

**                           finished shutting down.

** 042 CA  20090901   @43809 On bootstrap, SessionManager will be set a field which contains the

**                           InterruptHandler implementation.

** 043 CA  20090917   @43927 Fix abnormal connection end. In invoke(), any SilentUnwindExceptions 

**                           will stop the Conversation thread.

** 044 NVS 20090918   @43950 Reworked invoke() method to take an instance of Isolatable interface

**                           to allow the reuse of invoke for admin server purposes where some

**                           methods have to run in a transaction manager environment to be able

**                           to access the database properly, including modifications. Reworked 

**                           standardEntry() method to comply with the new requirements; added

**                           the inner class MainInvoker that encapsulates the client entry

**                           specific logic.

** 045 NVS 20090928   @44048 Server startup is protected against non-existent directory.

** 046 LMR 20101210          Edited bootstrap() and registerDefaultServices() to initialize the

**                           AdminGate service only if net/connection/secure is set to true in 

**                           the bootstrap config (if not found it defaults to false).

** 047 GES 20111004          Reworked the web server startup to more generically support multiple

**                           applets (not just admin alone).

** 048 GES 20111025          Signature changes in calling RemoteObject to export methods. Added

**                           waitUntilReady().

** 049 CA  20111130          Use the system classloader to load hooks, as Class.forName caches

**                           the loaded class in some native code from which it can never be

**                           removed. Before initializing hooks and exports, create class loaders

**                           for all the jars defined in the directory.

** 050 CA  20130529          Added appserver support.

** 051 CA  20130705          Register the appserver launcher.

** 052 SVL 20130624          Set runtime Configuration to be used.

** 053 HC  20130902          For #2164 added warning log when server persistence is inactive.

** 054 CA  20131004          Expose client-side parameter to server-side application code.

** 055 CA  20131023          At runtime, the in-memory registry plugin must be used.

** 056 MAG 20131101          Upgrade to jetty 9.1 embedded server.

** 057 MAG 20131114          Add Handler for Chui Web client.

** 058 OM  20131210          Made DatabaseTriggerManager Scopable context-local instantiation.

** 059 EVL 20131115          Adding UnstoppableExitException handling for unrecoverable errors in

**                           batch mode. The serve side of the ErrorManages is also initialized

**                           here.

** 060 MAG 20131223          Get Chui Web client target root from directory. Initialize temporary

**                           accounts pool.

** 061 MAG 20140128          Change the main return type from boolean to Result. For web 

**                           clients provide temporary account credentials.

** 062 MAG 20140131          Reverse changes at 061 (2014-01-28).

** 063 CA  20140206          Added scheduler support.

** 064 MAG 20140217          Added terminate method to web server hooker.

** 065 EVL 20140327          Adding the support to get the server properties to client. 

** 066 ECF 20140404          Initialize conversion pool during bootstrap.

** 067 ECF 20140430          Removed stack trace from conversion pool initialization warning.

**                           Enhanced warning message and added debug-level logging to provide

**                           more information and stack trace.

** 068 MAG 20140707          Implements remote launcher (broker). Exports broker API.

** 069 GES 20141229          Added support for user-specified entry points.

** 070 GES 20150310          Made web client support more generic (it isn't chui-specific now).

** 071 CA  20150622          Context-local client parameters (localParams field) must not be reset.

**                           Added database statistics collection (ECF).

** 072 CA  20160205          Added ServerKeyStore.initialize() at the server startup hooks.

** 073 IAS 20160329          Provide client-side parameters in a separate call

** 074 GES 20160121          Added WebClientLauncher service registration.

** 075 OM  20160422          Added project token implementation for multiple project support.

** 076 OM  20160527          SourceNameMapper.convertName() changed to convertNameToClass().

** 077 OM  20160927          Activated BatchMode when expressly requested by client.

** 078 HC  20170118          FWD version is printed to the log output on server start.

** 079 CA  20170228          Added PUBLISH/SUBSCRIBE/UNSUBSCRIBE extensions for global support and

**                           for external applications.

** 080 SBI 20170628          Added sessions listener to manage web client sessions.

** 081 HC  20170612          Changes related to implementation of new GWT-based Admin client.

** 082 ECF 20180615          Read list of jars containing application resources from the

**                           directory during bootstrap, so resource searches can be limited to

**                           these jars.

** 083 CA  20180724          Allow the embedded web app server to run from within FWD.

** 084 CA  20190611          Added support for legacy services (REST).

** 085 CA  20190703          Added support for WebHandler services.

** 086 ECF 20190521          Register a controller at server startup for method execution tracing.

** 087 CA  20190710          The legacy services need to be registered after their handlers have

**                           been initialized.

** 088 GES 20200213          Bypass termination of embedded mode, REST services and the web

**                           handler when if they were never initialized.

** 089 CA  20200514          Added support for SOAP web services.

**     CA  20200527          Allow the project token to be overridden via a client:project:token setting.

** 090 CA  20200915          Upgraded to Jetty 9.4.22.

** 091 CA  20200930          Force ANTLR to use Class.forName instead of loadClass.

** 092 SBI 20210413          Added web content handlers to public static content.

**     CA  20210511          The client's entry point (be it from directory's 'p2j-entry' or the client's

**                           startup-procedure configuration) will be executed as a "RUN external-program"

**                           statement, if the target is an external program which can be resolved.

**     CA  20210512          Refactored CA/20210511 so that the legacy RUN emulation and the old 'execute'

**                           method are separated.

**     IAS 20210520          Added support for session-based database auto-connect

**     HC  20210725          Added support for v6colon.

**     GES 20210827          Added driver-level diagnostics information logged at server startup.

**     SBI 20210923          Added FontTable initialization.

**     OM  20190620          Added -profile command line option for specifying the configuration profile.

**     CA  20210928          Set the temp directory for the FWD admin web app.

**     CA  20211114          The InMemoryRegistryPlugin instance at the AstManager must be context-local, for

**                           runtime conversion to work in concurrent mode.

**     CA  20220405          Added authentication and authorization for web requests.  When this is enabled, 

**                           the target API call will be executed under the authenticated FWD context, and not 

**                           the agent's context.

**     CA  20220901          Refactored scope notification support: ScopeableFactory was removed, and the 

**                           registration is now specific to each type of scopeable.  For each case, the block

**                           will be registered for scope support (for that particular scopeable) only when

**                           the scopeable is 'active' (i.e. unnamed streams or accumulators are used).  This

**                           allows a lazy registration of scopeables, to avoid the unnecessary overhead of

**                           processing all the scopeables for each and every block.

**     CA  20220906          Moved the interactive client cleaner to LogicalTerminal.registerCleaner().

**     TJD 20220504          Migration to Java 11 minor changes

**     SBI 20221215          Changed log message for loadStartup to specify the failure cause.

**     CA  20220501          Each profile has the same structure as the main 'global' config.  Allow multiple

**                           profiles to be ran at once, with the conversion switching the state between 

**                           profiles, when a resource (like a file or namespace) is being processed.  Only

**                           front phase is supported at this time.

**     CA  20220520          Initialize SourceNameMapper at server startup.

** 093 VVT 20230318          UnitTestEngine static network server registration added. See #6237.

** 094 GBB 20230412          Initialize LegacyLogManager.

** 095 GBB 20230608          Added a flag to LegacyLogManagerConfigs for server-side filesystem in use.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.p2j.main;

import java.io.*;

import java.lang.reflect.*;

import java.text.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.function.*;

import java.util.logging.*;

import java.util.logging.Formatter;

import javax.servlet.*;

import org.eclipse.jetty.server.handler.*;

import org.eclipse.jetty.util.resource.Resource;

import org.eclipse.jetty.webapp.*;

import com.goldencode.ast.*;

import com.goldencode.p2j.*;

import com.goldencode.p2j.admin.*;

import com.goldencode.p2j.admin.server.*;

import com.goldencode.p2j.aspects.ltw.*;

import com.goldencode.p2j.cfg.*;

import com.goldencode.p2j.cfg.Configuration;

import com.goldencode.p2j.classloader.*;

import com.goldencode.p2j.directory.*;

import com.goldencode.p2j.net.*;

import com.goldencode.p2j.persist.*;

import com.goldencode.p2j.persist.trigger.*;

import com.goldencode.p2j.rest.*;

import com.goldencode.p2j.scheduler.*;

import com.goldencode.p2j.security.*;

import com.goldencode.p2j.security.SecurityManager;

import com.goldencode.p2j.soap.*;

import com.goldencode.p2j.testengine.*;

import com.goldencode.p2j.ui.*;

import com.goldencode.p2j.util.*;

import com.goldencode.p2j.util.logging.*;

import com.goldencode.p2j.util.ErrorManager;

/**

 * Standard server application which is driven by the P2J directory contents.

 * <p>

 * In particular, exported entry points are read from directory objects

 * /server/serverID/exports/groupID/methodID where methodID is a named string

 * object. The name of this object is the well known exported method name.

 * The "value" attribute is a string encoding fully qualified class name,

 * method name and, possibly, the signature as in class.method(signature)

 * <p>

 * The directory also encodes the standard entry point of the P2J converted

 * application which is to be invoked.  This class provides the mechanism

 * to look up this entry point and invoke it (see {@link #standardEntry} and

 * {@link #invoke}).

 */

public class StandardServer

{

   /** Logger (this is JVM-wide rather than being context-local). */

   private static final CentralLogger LOG = 

      CentralLogger.get(StandardServer.class.getName());

   /** File name extension for jar files */

   private static final String JAR_EXT = ".jar";

   /** Name of P2J jar */

   private static final String P2J_JAR = "p2j.jar";

   /** Context-local client-side parameters exposed to the server. */

   private static final ContextLocal<ClientParameters> localParams = 

      new ContextLocal<ClientParameters>()

   {

      protected boolean isResetAllowed()

      {

         return false;

      }

   };

   /** Array of paths to jars in the classpath which hold application resources */

   private static List<String> resourceJarPaths;

   /** Lock object for shutdown synchronization. */

   private static final Object shutdownLock = new Object();

   /** Flag which is set to <code>true</code> when shutdown is done. */

   private static boolean shutdownDone = false;

   /** Server hooks. */

   private static final ArrayList<InitTermListener> serverHooks = new ArrayList<>(); 

   /** Map that keeps instantiated classes by name. */

   private final Map<String, Object> inst = new HashMap<>();

   /** Signals when the non-network portions of the server are ready. */

   private final CountDownLatch ready = new CountDownLatch(1);

   /** Admin extension. */

   private AdminServerExtension adminServerExtension;

   /**

    * Set the client parameters.

    * 

    * @param   params

    *          A container with any client-related parameters.

    *           

    */

   public static void setClientParams(ClientParameters params)

   {

      localParams.set(params);

   }

   /**

    * The method loads client startup parameters from the directory.

    *

    * @return  Object holding the client startup parameters.

    */

   public static StartupParameters loadStartupParameters()

   {

      StartupParametersLoader loader = new StartupParametersLoader();

      return loader.load(DirectoryService.getInstance());

   }

   /**

    * Set the project token to the server-side.

    * 

    * @param   token

    *          the token that identifies the project.

    *          

    * @see   Utils#setProjectToken(String)

    */

   public static void setProjectToken(String token)

   {

      // access the directory service

      DirectoryService ds = DirectoryService.getInstance();

      if (!ds.bind())

      {

         throw new RuntimeException("directory bind failed");

      }

      // set the token before we do directory lookup

      if (token == null || token.isEmpty())

      {

         // client's client:project:token overrides any directory setting.

         token = Utils.getDirectoryNodeString(ds, "project_token", null);

      }

      if (token != null && !token.isEmpty())

      {

         Utils.setProjectToken(token);

         // some settings could have been already set at a previous moment when project_token was

         // not available yet

         EnvironmentOps.setSearchPath(Utils.getDirectoryNodeString(ds, "searchpath", "."), false);

         // TODO: update other settings

      }

      ds.unbind();

   }

   /**

    * Serves as a standard transaction entry point to be called from the client which reroutes control to a 

    * specific entry point which is defined in the directory.

    * <p>

    * The entry point definition is the subject to a standardized directory lookup, which allows server or 

    * account specific definitions as well as server-wide or system-wide defaults.

    * <p>

    * p2j-entry can refer to a public method of the class. It can be either a static or an instance method 

    * taking no arguments. The class is instantiated before calling the named method. The returned object, if

    * any, is discarded.

    * <p>

    * If the resolved class name is mapped to a legacy external program, and the method's name is 

    * <code>execute</code>, the {@link LegacyInvoker} will be used to execute the program.  Otherwise, the

    * {@link MainInvoker} will invoke the method, which will bypass the normal state processing for a legacy 

    * external program.

    * <p>

    * The {@link #invoke} method is the worker that actually handles the method's invocation using reflection.

    * <p>

    * If directory contains definition for context hook, then it is instantiated. Hook definition directory 

    * entry is searched using the same rules as application entry point (refer to

    * {@link Utils#findDirectoryNodePath(DirectoryService, String, String, boolean)} for more details), 

    * appropriate variable has name <b>context-hook</b>.

    * Context hook class must implement {@link InitTermListener} interface.

    * 

    * @return  <code>true</code> if re-logon should be performed.  

    */

   public static boolean standardEntry()

   {

      SecurityManager sm = SecurityManager.getInstance();

      String userId = sm.getUserId();

      ClientParameters params = localParams.get();

      boolean isServerSideFileSystem = OSResourceManager.getInstance().isServerSideFileSystem();

      LegacyLogManagerConfigs legacyLogManagerConfigs = new LegacyLogManagerConfigs(params.clientLog,

                                                                                    params.loggingLevel,

                                                                                    params.logEntryTypes,

                                                                                    params.logThreshold,

                                                                                    params.numLogFiles,

                                                                                    params.pid,

                                                                                    params.inp,

                                                                                    params.osUserName,

                                                                                    userId,

                                                                                    isServerSideFileSystem);

      // this is an app server and needs its own management

      if (AppServerManager.startAppServer(legacyLogManagerConfigs))

      {

         return false;

      }

      LegacyLogManager logManager = LegacyLogOps.logMgr();

      logManager.initialize(legacyLogManagerConfigs);

      if (params.batchMode > 0)

      {

         // run this connection in batch mode (as requested from client command-line)

         EnvironmentOps.setBatchMode(true);

         // LogicalTerminal.activateBatchMode(true); -- should already be set ?

      }

      // access the directory service

      DirectoryService ds = DirectoryService.getInstance();

      if (!ds.bind())

      {

         throw new RuntimeException("directory bind failed");

      }

      // get the entry point method definition and any configured session hooks; these values

      // need no security check since the directory is an inherently trusted source; anyone that

      // can control the directory can control everything about the server so there is no

      // security check that can make this any better here

      String entryPath = Utils.findDirectoryNodePath(ds, "p2j-entry", "string", true);

      String method    = Utils.getDirectoryNodeString(ds, "p2j-entry", "");

      String hookPath  = Utils.findDirectoryNodePath(ds, "context-hook", "string", true);

      String hook      = Utils.getDirectoryNodeString(ds, "context-hook", "");

      // obtain the STOP disposition parameter:

      // 0 - retry without logging off

      // 1 - force logoff and then re-logon

      // 2 - force logoff

      int stopDisp = Utils.getDirectoryNodeInt(ds, "stop_disposition", 1);

      if (stopDisp < 0 || stopDisp > 2)

      {

         LOG.warning("stop_disposition configuration item is rejected: " + stopDisp);

         stopDisp = 1;

      }

      // last use of the directory, end our session with it

      ds.unbind();

      DatabaseManager.autoConnect();

      // these are used only for a 'com.foo.Bar.execute' p2j-entry case

      String className  = null;

      String methodName = null;

      Isolatable invoker = null;

      if (params.startupProc != null && params.startupProc.length() > 0)

      {

         // this is emulated via a RUN always, and that will take care to resolve any errors if the program is

         // not found.  just do the ACL check here.

         EntryPointResource epr = (EntryPointResource) sm.getPluginInstance("entrypoint");

         // security check is needed here because this data is user-supplied (which is an untrusted source)

         if (epr == null || !epr.isAllowed(params.startupProc))

         {

            if (LOG.isLoggable(Level.WARNING))

            {

               if (epr == null)

               {

                  String spec1 = "User-specified startup program '%s' cannot be accessed " +

                                 "because the EntryPointResource is NOT enabled.";

                  LOG.logp(Level.WARNING,

                           "StandardServer.standardEntry",

                           "",

                           CentralLogger.generate(spec1, params.startupProc));

               }

               else

               {

                  String spec2 = "Access to user-specified startup program '%s' not " +

                                 "allowed for user %s.  Falling back to default.";

                  LOG.logp(Level.WARNING,

                           "StandardServer.standardEntry",

                           "",

                           CentralLogger.generate(spec2, params.startupProc, sm.getUserId()));

               }

            }

            // disallow access

            return false;

         }

         else

         {

            invoker = new LegacyInvoker(params.startupProc);

         }

      }

      else

      {

         // check if there is an entry point to execute

         if (method.length() == 0)

         {

            throw new RuntimeException("no entry point definition found");

         }

         // resolve the p2j-entry - either a 'com.foo.Bar.execute' Java method or a legacy program name. 

         // try to resolve the legacy program name first

         String javaClass = SourceNameMapper.convertNameToClass(method);

         if (javaClass != null)

         {

            // the program name exists, use an emulated RUN statement

            invoker = new LegacyInvoker(method);

            // TODO: always use a LegacyInvoker

         }

         else

         {

            // TODO: this code will become obsolete and needs to be removed.

            // fallback to a 'com.foo.Bar.Execute' Java method

            // parse the definition into class name and method name

            int l = method.lastIndexOf(".");

            if (l == -1)

            {

               throw new RuntimeException("incorrect syntax for method definition " + method + " for " + 

                                           entryPath);

            }

            else

            {

               className = method.substring(0, l);

               methodName = method.substring(l + 1);

            }

            // inspect the class

            Class<?> cl = null;

            try

            {

               cl = Class.forName(className);

            }

            catch (Exception e)

            {

               // something's wrong with the class

               throw new RuntimeException("can't load " + className + " for " + entryPath, e);

            }

            // inspect the method

            Method entry = null;

            try

            {

               entry = cl.getMethod(methodName, (Class[]) null);

            }

            catch (Exception ex)

            {

               throw new RuntimeException(

                     "no method " + methodName + " defined in " + className + " for " + entryPath,

                     ex);

            }

            invoker = new MainInvoker(cl, entry, stopDisp);

         }

      }

      // load hook, if any

      InitTermListener listener = loadHook(hook, hookPath);

      // instantiate the class (if necessary) and invoke the entry point method

      boolean mainResult = false;

      Throwable t = null;

      try

      {

         if (listener != null)

         {

            listener.initialize();

         }

         invoke(stopDisp, invoker);

      }

      catch (InstantiationException ex)

      {

         t = ex;

         throw new RuntimeException("unable to instantiate " + className, ex);

      }

      catch (IllegalAccessException ex)

      {

         t = ex;

         throw new RuntimeException("access problem in " + methodName, ex);

      }

      catch (IllegalArgumentException ex)

      {

         t = ex;

         throw new RuntimeException("invalid argument to " + methodName, ex);

      }

      catch (ReflectiveOperationException ex)

      {

         t = ex;

         throw new RuntimeException("exception in " + methodName, ex);

      }

      catch (StopConditionException sce)

      {

         t = sce;

         if (stopDisp == 1)

         {

            // this value forces logoff and then re-logon (continued operation)

            mainResult = true;

         }

         else

         {

            // this value forces logoff (exit)

            mainResult = false;

         }

      }

      catch (UnstoppableExitException uee)

      {

         // this value forces logoff (exit)

         mainResult = false;

      }

      catch (RuntimeException re)

      {

         t = re;

         throw re;

      }

      finally

      {

         if (listener != null)

         {

            listener.terminate(t);

         }

      }

      return mainResult;

   }

   /**

    * Get the registered hook which is defined in the given jar, if any.

    * 

    * @param   jarName

    *          The jar file name.

    * 

    * @return  See above.

    */

   public static String getHookForJar(String jarName)

   {

      synchronized (shutdownLock)

      {

         for (InitTermListener listener : serverHooks)

         {

            if (MultiClassLoader.handledByJar(listener.getClass(), jarName))

            {

               return listener.getClass().getName();

            }

         }

      }

      return null;

   }

   /**

    * Terminate and remove the given server hook.

    * 

    * @param   hookClass

    *          The hook class name.

    */

   public static void removeHook(String hookClass)

   {

      synchronized (shutdownLock)

      {

         Iterator<InitTermListener> iter = serverHooks.iterator();

         while (iter.hasNext())

         {

            InitTermListener listener = iter.next();

            if (listener.getClass().getName().equals(hookClass))

            {

               listener.terminate(null);

               iter.remove();

               break;

            }

         }

      }

   }

   /**

    * Add server hook which will be notified about server startup and shutdown. 

    * 

    * @param    hook

    *           Server hook to add.

    */

   public static void register(InitTermListener hook)

   {

      synchronized (shutdownLock)

      {

         serverHooks.add(hook);

      }

   }

   /**

    * Load {@link InitTermListener} hook using specified class and path.

    *

    * @param    hook

    *           Full class name.

    * @param    hookPath

    *           Hook path in directory.

    *

    * @return   Instance of loaded hook if any.

    */

   public static InitTermListener loadHook(String hook, String hookPath)

   {

      InitTermListener listener = null;

      if (hook != null && hook.length() > 0)

      {

         Class<?> hookCl = null;

         try

         {

            // can not use Class.forName, as it caches the loaded class in

            // some native code from which it can never be removed

            hookCl = ClassLoader.getSystemClassLoader().loadClass(hook);

         }

         catch (Exception e)

         {

            // something's wrong with the hook class

            throw new RuntimeException("can't load " + hook + " for "

                                       + hookPath,

                                       e);

         }

         if (!InitTermListener.class.isAssignableFrom(hookCl))

            // something's wrong with the hook class

            throw new RuntimeException("class " + hook + " must implement "

                                       + InitTermListener.class.getSimpleName()

                                       + " interface.");

         try

         {

            listener = (InitTermListener) hookCl.getDeclaredConstructor().newInstance();

         }

         catch (InstantiationException e)

         {

            throw new RuntimeException("unable to instantiate " + hook, e);

         }

         catch (InvocationTargetException e)

         {

            throw new RuntimeException("wrapped exception in " + hook + " constructor", e.getTargetException());

         }

         catch (NoSuchMethodException e)

         {

            throw new RuntimeException("access problem in " + hook + " constructor", e);

         }

         catch (SecurityException e)

         {

            throw new RuntimeException("security problem in " + hook + " constructor", e);

         }

         catch (IllegalAccessException e)

         {

            throw new RuntimeException("access problem in " + hook + " constructor", e);

         }

         catch (IllegalArgumentException e)

         {

            throw new RuntimeException("argument problem in " + hook + " constructor", e);

         }

      }

      return listener;

   }

   /**

    * Get the parameters exposed by the client-side exposed, for this context.

    * 

    * @return   A {@link ClientParameters} instance, with the context's parameters.

    */

   public static ClientParameters getClientParameters()

   {

      return localParams.get();

   }

   /**

    * Return the paths, relative to the server starting directory, of jars from which resources

    * are to be loaded. This will be a subset of the server process' classpath.

    * 

    * @return  List of resource jar paths.

    */

   public static List<String> getResourceJarPaths()

   {

      return resourceJarPaths;

   }

   /**

    * Block the calling thread until the non-network portions of the server

    * are fully initialized.  At that point the server is ready to execute

    * real logic.

    */

   public void waitUntilReady()

   throws InterruptedException

   {

      ready.await();

   }

   /**

    * Bootstrap the server environment by initializing network services,

    * exporting all standard entry points for this server, loading all

    * application specific startup classes, and starting the server socket

    * listening loop.

    * <p>

    * The implementation looks up the directory under the path

    * <code>/server/serverID/exports</code> to figure out the subtree of

    * registrations.

    * <p>

    * If no such subtree exists, <code>/server/default/exports</code> is

    * checked next.

    * <p>

    * Entries have the format <code>export-group-ID/export-method-ID</code>

    * where the <code>export-group-ID</code> is a container naming a group and

    * <code>export-method-ID</code> is an object naming the export and

    * providing its implementation location through its string type "value"

    * attribute as <code>class-name.method-name(signature)</code>.

    * <p>

    * <code>method-name</code> should refer to a public method of the class.

    * It can be either a static or instance method. The class is instantiated

    * once for the first instance method reference.

    * <p>

    * Specifying a method without signature is allowed if the method is not

    * overloaded.

    * <p>

    * Once all the generic directory-driven exports are processed, then all

    * the following are registered using the simpler <code>RemoteObject</code>

    * mechanism:

    * <p>

    * 

    * <pre>

    * Interface         Type        Target

    * ----------------- ----------- ----------------------------------

    * ServerExports     static      LogicalTerminal

    * RemoteErrorData   static      ErrorManager

    * MainEntry         static      StandardServer

    * </pre>

    * <p>

    * When basic initialization is finished, this method registers default

    * services and then loads user defined services if they are defined in

    * <b>startups</b> directory entry under either

    * <code>/server/serverID</code> or <code>/server/default</code> entry.

    * <p>

    * User defined services must implement {@link InitTermListener} interface

    * and its {@link InitTermListener#initialize()} will be invoked right

    * before server will start listen for incoming connections while its

    * {@link InitTermListener#terminate(Throwable)} method will be invoked

    * when server stopped accepting incoming connections and all active

    * sessions are terminated. If server is stopped in graceful way (via

    * remote request) then <code>null</code> is passed as a parameter into

    * {@link InitTermListener#terminate(Throwable)} method. If server is

    * stopped in abnormal way, for example, because user typed Ctrl-C, then

    * some non-null value is passed as a parameter. Passed value should not be

    * relied on to determine real cause of server stop.

    * 

    * @param   config

    *          Bootstrap configuration information for this server.

    * @param   diagnostics

    *          Details about the driver state that can help diagnose server startup issues.

    * @param   cfgProfile

    *          The optional configuration profile.

    *           

    * @throws  Exception

    *          Various exceptions generated by invalid configurations.

    */

   public void bootstrap(BootstrapConfig config, Supplier<String> diagnostics, String cfgProfile)

   throws Exception

   {

      // set a global property to for Antlr to use Class.forName

      System.setProperty("ANTLR_USE_DIRECT_CLASS_LOADING", "true");

      LOG.info(Version.getFWDVersion() + " Server starting initialization." );

      LOG.info(diagnostics.get());

      LOG.info("BootstrapConfig " + config.toString());

      Configuration.setRuntimeConfig(true);

      // instantiate the directory service with must_exist option

      config.setConfigItem("directory", "xml", "must_exist", "true");

      DirectoryService ds = DirectoryService.createInstance(config);

      // bind to the directory

      ds.bind();

      // instantiate security manager

      final SecurityManager sm     = SecurityManager.createInstance(config);

      final SessionManager sessMgr = SessionManagerFactory.createRouterNode(config);

      // initialize the class loaders for the jars set in the directory

      initClassLoaders(ds);

      // enumerate exported groups

      String path = Utils.findDirectoryNodePath(ds, "exports", "container", false);

      String[] groups = ds.enumerateNodes(path);

      if (groups == null || groups.length == 0)

         LOG.info("No exported entry points defined in the P2J directory");

      // put instance references into the map for these special cases

      Class<?> cl = ds.getClass();

      inst.put(cl.getName(), ds);       // reference to DirectoryService

      cl = sm.getClass();

      inst.put(cl.getName(), sm);       // reference to SecurityManager

      cl = this.getClass();

      inst.put(cl.getName(), this);     // reference to StandardServer

      if (groups != null)

      {

         // process groups

         for (String group : groups)

         {

            // enumerate exports for this group

            String methodPath = path + "/" + group;

            String[] methods = ds.enumerateNodes(methodPath);

            if (methods == null)

               continue;

            // process exports

            for (String s : methods)

            {

               // read the method specification

               String valuePath = methodPath + "/" + s;

               String method = ds.getNodeString(valuePath, "value");

               // register method

               if (exportMethod(group, s, method))

                  LOG.finer(" exported " + group + ":" + s);

               else

                  LOG.finer("export failed " + group + ":" + s);

            }

         }

      }

      // simple form (not directory based)

      Class<?>[] ifaces = new Class[] { ServerExports.class };

      RemoteObject.registerStaticNetworkServer(ifaces, LogicalTerminal.class);

      ifaces = new Class[] { RemoteErrorData.class };

      RemoteObject.registerStaticNetworkServer(ifaces, ErrorManager.class);

      ifaces = new Class[] { MainEntry.class };

      RemoteObject.registerStaticNetworkServer(ifaces, StandardServer.class);

      ifaces = new Class[] { AppServerEntry.class };

      RemoteObject.registerStaticNetworkServer(ifaces, AppServerManager.class);

      ifaces = new Class[] { AppServer.class };

      RemoteObject.registerStaticNetworkServer(ifaces, AppServerLauncher.class);

      ifaces = new Class[] { BatchProcess.class };

      RemoteObject.registerStaticNetworkServer(ifaces, ProcessClientSpawner.class);

      ifaces = new Class[] { RemoteSpawner.class };

      RemoteObject.registerStaticNetworkServer(ifaces, ClientBuilder.class);

      ifaces = new Class[] { BrokerServerServices.class };

      RemoteObject.registerStaticNetworkServer(ifaces, BrokerManager.class);

      ifaces = new Class[] { ServerPropertiesInspector.class };

      RemoteObject.registerStaticNetworkServer(ifaces, ServerPropertiesDaemon.class);

      ifaces = new Class[] { CentralLogService.class };

      RemoteObject.registerStaticNetworkServer(ifaces, CentralLogStaticService.class);

      RemoteObject.registerStaticNetworkServer(new Class[] { UnitTestEngine.class }, UnitTestServer.class);

      AdminServerImpl.initialize();

      DirectoryManager.initServer();

      // set the optional configuration profile must be called after initialization of Configuration

      // and DirectoryManager

      if (cfgProfile != null)

      {

         Configuration.setDefaultProfile(cfgProfile);

      }

      registerDefaultServices(sm, config);

      AstManager.initialize(() -> new InMemoryRegistryPlugin());

      Throwable poolExc = null;

      try

      {

         ConversionPool.initialize();

      }

      catch (RuntimeException exc)

      {

         poolExc = exc;

      }

      catch (ConfigurationException exc)

      {

         poolExc = exc.getCause();

      }

      finally

      {

         if (poolExc != null)

         {

            // not all apps use runtime conversion services, so this is not a fatal error, but

            // log a warning

            if (LOG.isLoggable(Level.WARNING))

            {

               LOG.log(Level.WARNING,

                       "Unable to initialize runtime conversion pool; if dynamic database " +

                       "features are not in use, this warning can be ignored safely (otherwise " +

                       "restart server with FINE logging for additional information)");

               if (LOG.isLoggable(Level.FINE))

               {

                  LOG.log(Level.FINE,

                          "Ensure configuration items for runtime conversion are stored in the " +

                          "application jar file",

                          poolExc);

               }

            }

         }

      }

      // set the interrupt handler in the session manager.

      sessMgr.setInterruptHandler(new InterruptedExceptionHandler());

      // load the standard startup classes (must be after the dispatcher,

      // directory, security manager are all initialized)

      loadStartup(ds);

      // initialize the list of jar files from which to load resources

      initResourceJarPaths(ds);

      hookInitialize();

      Runtime.getRuntime().addShutdownHook(new Thread(() -> {

         Throwable t = new Throwable();

         try

         {

            sm.setInitialSecurityContext();

            sessMgr.waitForShutdown();

         }

         catch (Throwable e)

         {

            t = e;

         }

         hookTerminate(t);

      }));

      long n1 = System.nanoTime();

      for (int i = 0; i < 1_000_000; i++)

      {

         LOG.log(Level.WARNING, "something");

         // LOG2.log(Level.WARNING, "something");

      }

      long n2 = System.nanoTime();

      System.out.println("centralLogger " + (n2 - n1) / 1_000_000L);

      Logger rootLogger = Logger.getLogger("");

      ConsoleHandler consoleHandler = new ConsoleHandler();

      consoleHandler.setFormatter(new CleanFormatter());

      rootLogger.addHandler(consoleHandler);

      Logger anotherLogger = Logger.getLogger("random");

      n1 = System.nanoTime();

      for (int i = 0; i < 1_000_000; i++)

      {

         anotherLogger.log(Level.WARNING, "something");

      }

      n2 = System.nanoTime();

      System.out.println("java console logger " + (n2 - n1) / 1_000_000L);

      try

      {

         // wake up any waiting threads, the non-network portions of the

         // server are fully initialized now

         ready.countDown();

         SessionListener webClientsManager;

         if (Utils.getDirectoryNodeBoolean(ds, "webClient/enabled", false, false))

         {

            webClientsManager = WebClientsManager.getInstance();

         }

         else

         {

            webClientsManager = null;

         }

         // main listening loop;  service incoming socket connections

         sessMgr.listen(webClientsManager);

      }

      finally

      {

         sessMgr.waitForShutdown();

         hookTerminate(null);

      }

   }

   /**

    * Simple formatter to emit a very clean, condensed output.

    */

   public static class CleanFormatter

      extends Formatter

   {

      /** Date format string. */

      private static final String FMT = "MM/dd/yyyy HH:mm:ss z";

      /** Date and time formatter. */

      private static final ThreadLocal<SimpleDateFormat> sdf = new ThreadLocal<SimpleDateFormat>()

      {

         @Override

         protected SimpleDateFormat initialValue()

         {

            return new SimpleDateFormat(FMT);

         }

      };

      /** Platform-specific line separator. */

      private static final String SEP = System.getProperty("line.separator");

      /**

       * Format the given log record and return the formatted string.

       *

       * @param    record

       *           The log record to be formatted. 

       *

       * @return   The formatted log record.

       */

      public String format(LogRecord record)

      {

         String spec = "[%s] (%s:%s) %s%s";

         Date dat = new Date(record.getMillis());

         Object[] parms = new Object[]

            {

               sdf.get().format(dat),

               record.getSourceClassName(),

               record.getLevel().toString(),

               record.getMessage(),

               SEP

            };

         String out = String.format(spec, parms);

         Throwable t = record.getThrown();

         if (t != null)

         {

            StringBuilder sb = new StringBuilder(out);

            dumpThrowable(t, sb);

            out = sb.toString();

         }

         return out;

      }

      /**

       * Dump all details of the throwable into the given string buffer.

       * Includes exception type, message, complete stack trace, and chained

       * throwables, if any.

       *

       * @param    t

       *           The throwable to dump.

       * @param    buf

       *           String buffer into which details are written.

       */

      private void dumpThrowable(Throwable t, StringBuilder buf)

      {

         Throwable cause = t;

         do

         {

            if (cause != t)

            {

               buf.append("Caused by: ");

            }

            buf.append(cause.getClass().getName());

            String msg = cause.getMessage();

            if (msg != null && msg.trim().length() > 0)

            {

               buf.append(": ");

               buf.append(msg);

            }

            buf.append(SEP);

            StackTraceElement[] trace = cause.getStackTrace();

            for (int i = 0; i < trace.length; i++)

            {

               buf.append("        at ");

               buf.append(trace[i]);

               buf.append(SEP);

            }

            cause = cause.getCause();

         }

         while (cause != null);

      }

   }

   /**

    * Initialize the class loaders for all the jars defined in the directory.

    * This can be done only if the <code>java.system.class.loader</code>

    * property is set to the {@link MultiClassLoader custom class loader}.

    * 

    * @param   ds

    *          The directory service.

    */