* Copyright 2009 Red Hat, Inc.

* Red Hat licenses this file to you under the Apache License, version

* 2.0 (the "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*    http://www.apache.org/licenses/LICENSE-2.0

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

* implied.  See the License for the specific language governing

* permissions and limitations under the License.

*/

* The HornetQ server implementation

*

* @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a>

* @author <a href="mailto:ataylor@redhat.com>Andy Taylor</a>

*/

   /**

    * JMS Topics (which are outside of the scope of the core API) will require a dumb subscription

    * with a dummy-filter at this current version as a way to keep its existence valid and TCK

    * tests. That subscription needs an invalid filter, however paging needs to ignore any

    * subscription with this filter. For that reason, this filter needs to be rejected on paging or

    * any other component on the system, and just be ignored for any purpose It's declared here as

    * this filter is considered a global ignore

    */

   public static final String GENERIC_IGNORED_FILTER = "__HQX=-1";

   enum SERVER_STATE

   {

      /**

       * start() has been called but components are not initialized. The whole point of this state,

       * is to be in a state which is different from {@link SERVER_STATE#STARTED} and

       * {@link SERVER_STATE#STOPPED}, so that methods testing for these two values such as

       * {@link #stop(boolean,boolean)} work as intended.

       */

      STARTING,

      /**

       * server is started. {@code server.isStarted()} returns {@code true}, and all assumptions

       * about it hold.

       */

      STARTED,

      /**

       * stop() was called but has not finished yet. Meant to avoids starting components while

       * stop() is executing.

       */

      STOPPING,

      /**

       * Stopped: either stop() has been called and has finished running, or start() has never been

       * called.

       */

      STOPPED;

   }

   private volatile SERVER_STATE state = SERVER_STATE.STOPPED;

   private final Version version;

   private final HornetQSecurityManager securityManager;

   private final Configuration configuration;

   private final MBeanServer mbeanServer;

   private volatile SecurityStore securityStore;

   private final HierarchicalRepository<AddressSettings> addressSettingsRepository;

   private volatile QueueFactory queueFactory;

   private volatile PagingManager pagingManager;

   private volatile PostOffice postOffice;

   private volatile ExecutorService threadPool;

   private volatile ScheduledExecutorService scheduledPool;

   private volatile ExecutorFactory executorFactory;

   private final HierarchicalRepository<Set<Role>> securityRepository;

   private volatile ResourceManager resourceManager;

   private volatile HornetQServerControlImpl messagingServerControl;

   private volatile ClusterManager clusterManager;

   private volatile StorageManager storageManager;

   private volatile RemotingService remotingService;

   private volatile ManagementService managementService;

   private volatile ConnectorsService connectorsService;

   private MemoryManager memoryManager;

   private volatile DeploymentManager deploymentManager;

   private Deployer basicUserCredentialsDeployer;

   private Deployer addressSettingsDeployer;

   private Deployer queueDeployer;

   private Deployer securityDeployer;

   private final Map<String, ServerSession> sessions = new ConcurrentHashMap<String, ServerSession>();

   /**

    * This class here has the same principle of CountDownLatch but you can reuse the counters.

    * It's based on the same super classes of {@code CountDownLatch}

    */

   private final ReusableLatch activationLatch = new ReusableLatch(0);

   private final ReusableLatch backupSyncLatch = new ReusableLatch(0);

   private final Object replicationLock = new Object();

   /**

    * Only applicable to 'remote backup servers'. If this flag is false the backup may not become

    * 'live'.

    */

   private volatile boolean backupUpToDate = true;

   private ReplicationManager replicationManager;

   private ReplicationEndpoint replicationEndpoint;

   private final Set<ActivateCallback> activateCallbacks = new ConcurrentHashSet<ActivateCallback>();

   private volatile GroupingHandler groupingHandler;

   private NodeManager nodeManager;

   // Used to identify the server on tests... useful on debugging testcases

   private String identity;

   private Thread backupActivationThread;

   private Activation activation;

   private final ShutdownOnCriticalErrorListener shutdownOnCriticalIO = new ShutdownOnCriticalErrorListener();

   private final Object failbackCheckerGuard = new Object();

   private boolean cancelFailBackChecker;

   // Constructors

   // ---------------------------------------------------------------------------------

   public HornetQServerImpl()

   {

      this(null, null, null);

   }

   public HornetQServerImpl(final Configuration configuration)

   {

      this(configuration, null, null);

   }

   public HornetQServerImpl(final Configuration configuration, final MBeanServer mbeanServer)

   {

      this(configuration, mbeanServer, null);

   }

   public HornetQServerImpl(final Configuration configuration, final HornetQSecurityManager securityManager)

   {

      this(configuration, null, securityManager);

   }

   public HornetQServerImpl(Configuration configuration,

                            MBeanServer mbeanServer,

                            final HornetQSecurityManager securityManager)

   {

      if (configuration == null)

      {

         configuration = new ConfigurationImpl();

      }

      if (mbeanServer == null)

      {

         // Just use JVM mbean server

         mbeanServer = ManagementFactory.getPlatformMBeanServer();

      }

      // We need to hard code the version information into a source file

      version = VersionLoader.getVersion();

      this.configuration = configuration;

      this.mbeanServer = mbeanServer;

      this.securityManager = securityManager;

      addressSettingsRepository = new HierarchicalObjectRepository<AddressSettings>();

      addressSettingsRepository.setDefault(new AddressSettings());

      securityRepository = new HierarchicalObjectRepository<Set<Role>>();

      securityRepository.setDefault(new HashSet<Role>());

   }

   // life-cycle methods

   // ----------------------------------------------------------------

   /*

    * Can be overridden for tests

    */

   protected NodeManager createNodeManager(final String directory, String nodeGroupName, boolean replicatingBackup)

   {

      NodeManager manager;

      if (configuration.getJournalType() == JournalType.ASYNCIO && AsynchronousFileImpl.isLoaded())

      {

         manager = new AIOFileLockNodeManager(directory, replicatingBackup);

      }

      else

      {

         manager = new FileLockNodeManager(directory, replicatingBackup);

      }

      manager.setNodeGroupName(nodeGroupName);

      return manager;

   }

   public final synchronized void start() throws Exception

   {

      if (state != SERVER_STATE.STOPPED)

      {

         HornetQServerLogger.LOGGER.debug("Server already started!");

         return;

      }

      synchronized (failbackCheckerGuard)

      {

         cancelFailBackChecker = false;

      }

      state = SERVER_STATE.STARTING;

      activationLatch.setCount(1);

      HornetQServerLogger.LOGGER.debug("Starting server " + this);

      OperationContextImpl.clearContext();

      try

      {

         checkJournalDirectory();

         nodeManager =

                  createNodeManager(configuration.getJournalDirectory(), configuration.getBackupGroupName(), false);

         nodeManager.start();

         HornetQServerLogger.LOGGER.serverStarting((configuration.isBackup() ? "backup" : "live"),  configuration);

         if (configuration.isRunSyncSpeedTest())

         {

            SyncSpeedTest test = new SyncSpeedTest();

            test.run();

         }

         final boolean wasLive = !configuration.isBackup();

         if (!configuration.isBackup())

         {

            if (configuration.isSharedStore() && configuration.isPersistenceEnabled())

            {

               activation = new SharedStoreLiveActivation();

            }

            else

            {

               activation = new SharedNothingLiveActivation();

            }

            activation.run();

         }

         // The activation on fail-back may change the value of isBackup, for that reason we are

         // checking again here

         if (configuration.isBackup())

         {

            if (configuration.isSharedStore())

            {

               activation = new SharedStoreBackupActivation();

            }

            else

            {

               assert replicationEndpoint == null;

               nodeManager.stop();

               nodeManager =

                        createNodeManager(configuration.getJournalDirectory(), configuration.getBackupGroupName(), true);

               backupUpToDate = false;

               backupSyncLatch.setCount(1);

               replicationEndpoint = new ReplicationEndpoint(this, shutdownOnCriticalIO, wasLive);

               activation = new SharedNothingBackupActivation(wasLive);

            }

            backupActivationThread = new Thread(activation, HornetQMessageBundle.BUNDLE.activationForServer(this));

            backupActivationThread.start();

         }

         else

         {

            state = SERVER_STATE.STARTED;

            HornetQServerLogger.LOGGER.serverStarted(getVersion().getFullVersion(), nodeManager.getNodeId(),

               identity != null ? identity : "");

         }

         // start connector service

         connectorsService = new ConnectorsService(configuration, storageManager, scheduledPool, postOffice);

         connectorsService.start();

      }

      finally

      {

         // this avoids embedded applications using dirty contexts from startup

         OperationContextImpl.clearContext();

      }

   }

   @Override

   protected final void finalize() throws Throwable

   {

      if (state != SERVER_STATE.STOPPED)

      {

         HornetQServerLogger.LOGGER.serverFinalisedWIthoutBeingSTopped();

         stop();

      }

      super.finalize();

   }

   /**

    * Stops the server in a different thread.

    */

   public final void stopTheServer(final boolean criticalIOError)

   {

      ExecutorService executor = Executors.newSingleThreadExecutor();

      executor.submit(new Runnable()

      {

         @Override

         public void run()

         {

            try

            {

               stop(configuration.isFailoverOnServerShutdown(), criticalIOError, false);

            }

            catch (Exception e)

            {

               HornetQServerLogger.LOGGER.errorStoppingServer(e);

            }

         }

      });

   }

   public final void stop() throws Exception

   {

      stop(configuration.isFailoverOnServerShutdown());

   }

   public void threadDump(final String reason)

   {

      StringWriter str = new StringWriter();

      PrintWriter out = new PrintWriter(str);

      Map<Thread, StackTraceElement[]> stackTrace = Thread.getAllStackTraces();

      out.println(HornetQMessageBundle.BUNDLE.generatingThreadDump(reason));

      out.println("*******************************************************************************");

      for (Map.Entry<Thread, StackTraceElement[]> el : stackTrace.entrySet())

      {

         out.println("===============================================================================");

         out.println(HornetQMessageBundle.BUNDLE.threadDump(el.getKey(), el.getKey().getName(), el.getKey().getId(), el.getKey().getThreadGroup()));

         out.println();

         for (StackTraceElement traceEl : el.getValue())

         {

            out.println(traceEl);

         }

      }

      out.println("===============================================================================");

      out.println(HornetQMessageBundle.BUNDLE.endThreadDump());

      out.println("*******************************************************************************");

      HornetQServerLogger.LOGGER.warn(str.toString());

   }

   public final void stop(boolean failoverOnServerShutdown) throws Exception

   {

      stop(failoverOnServerShutdown, false, false);

   }

   /**

    * Stops the server

    * @param failoverOnServerShutdown whether we will allow a backup server to become live when the

    *           server is stopped normally

    * @param criticalIOError whether we have encountered an IO error with the journal etc

    * @param failingBack if true don't set the flag to stop the failback checker

    */

   private void stop(boolean failoverOnServerShutdown, final boolean criticalIOError, boolean failingBack) throws Exception

   {

      if (!failingBack)

      {

         synchronized (failbackCheckerGuard)

         {

            cancelFailBackChecker = true;

         }

      }

      synchronized (this)

      {

         if (state == SERVER_STATE.STOPPED || state == SERVER_STATE.STOPPING)

         {

            return;

         }

         state = SERVER_STATE.STOPPING;

         final ReplicationManager localReplicationManager = getReplicationManager();

         if (localReplicationManager != null)

         {

            replicationManager.sendLiveIsStopping(LiveStopping.STOP_CALLED);

            // Schedule for 10 seconds

            // this pool gets a 'hard' shutdown, no need to manage the Future of this Runnable.

            scheduledPool.schedule(new Runnable()

            {

               @Override

               public void run()

               {

                  localReplicationManager.clearReplicationTokens();

               }

            }, 30, TimeUnit.SECONDS);

         }

         stopComponent(connectorsService);

         // we stop the groupingHandler before we stop the cluster manager so binding mappings

         // aren't removed in case of failover

         if (groupingHandler != null)

         {

            managementService.removeNotificationListener(groupingHandler);

            groupingHandler = null;

         }

         stopComponent(clusterManager);

         freezeConnections();

      }

      closeAllServerSessions(criticalIOError);

      // *************************************************************************************************************

      // There's no need to sync this part of the method, since the state stopped | stopping is checked within the sync

      //

      // we can't synchronized the whole method here as that would cause a deadlock

      // so stop is checking for stopped || stopping inside the lock

      // which will be already enough to guarantee that no other thread will be accessing this method here.

      //

      // *************************************************************************************************************

      if (storageManager != null)

         storageManager.clearContext();

      //before we stop any components deactivate any callbacks

      callDeActiveCallbacks();

      // Stop the deployers

      if (configuration.isFileDeploymentEnabled())

      {

         stopComponent(basicUserCredentialsDeployer);

         stopComponent(addressSettingsDeployer);