* 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>

* @version <tt>$Revision: 3543 $</tt> <p/> $Id: ServerPeer.java 3543 2008-01-07 22:31:58Z clebert.suconic@jboss.com $

*/

   // Constants

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

   private static final Logger log = Logger.getLogger(HornetQServerImpl.class);

   // 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";

   // Static

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

   // Attributes

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

   private final Version version;

   private final HornetQSecurityManager securityManager;

   private final Configuration configuration;

   private final MBeanServer mbeanServer;

   private volatile boolean started;

   private volatile boolean stopped;

   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>();

   private final Object initialiseLock = new Object();

   private boolean initialised;

   // private FailoverManager replicationFailoverManager;

   private ReplicationManager replicationManager;

   private ReplicationEndpoint replicationEndpoint;

   private final Set<ActivateCallback> activateCallbacks = new HashSet<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();

   // 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>());

   }

   // lifecycle methods

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

   /*

    * Can be overridden for tests

    */

   protected NodeManager createNodeManager(final String directory)

   {

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

      {

         return new AIOFileLockNodeManager(directory);

      }

      else

      {

         return new FileLockNodeManager(directory);

      }

   }

   public synchronized void start() throws Exception

   {

      if (started)

      {

         log.debug("Server already started!");

         return;

      }

      log.debug("Starting server " + this);

      OperationContextImpl.clearContext();

      try

      {

         stopped = false;

         initialiseLogging();

         checkJournalDirectory();

         nodeManager = createNodeManager(configuration.getJournalDirectory());

         nodeManager.start();

         if (started)

         {

            HornetQServerImpl.log.info((configuration.isBackup() ? "backup" : "live") + " is already started, ignoring the call to start..");

            return;

         }

         HornetQServerImpl.log.info((configuration.isBackup() ? "backup" : "live") + " server is starting with configuration " +

                                    configuration);

         if (configuration.isRunSyncSpeedTest())

         {

            SyncSpeedTest test = new SyncSpeedTest();

            test.run();

         }

         if (!configuration.isBackup())

         {

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

            {

               activation = new SharedStoreLiveActivation();

               // This should block until the lock is got

               activation.run();

            }

            else

            {

               activation = new NoSharedStoreLiveActivation();

               activation.run();

            }

            started = true;

            HornetQServerImpl.log.info("HornetQ Server version " + getVersion().getFullVersion() +

                                       " [" +

                                       nodeManager.getNodeId() +

                                       "]" +

                                       (this.identity != null ? " (" + identity : ")") +

                                       " started");

         }

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

         if (configuration.isBackup())

         {

            if (configuration.isSharedStore())

            {

               activation = new SharedStoreBackupActivation();

            }

            else

            {

               // Replicated

               activation = new SharedNothingBackupActivation();

            }

            backupActivationThread = new Thread(activation, "Activation for server " + this);

            backupActivationThread.start();

         }

         // 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 void finalize() throws Throwable

   {

      if (started)

      {

         HornetQServerImpl.log.warn("HornetQServer is being finalized and has not been stopped. Please remember to stop the " + "server before letting it go out of scope");

         stop();

      }

      super.finalize();

   }

   public void stop() throws Exception

   {

      stopped = true;

      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("Generating thread dump because - " + reason);

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

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

      {

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

         out.println("Thread " + el.getKey() +

                     " name = " +

                     el.getKey().getName() +

                     " id = " +

                     el.getKey().getId() +

                     " group = " +

                     el.getKey().getThreadGroup());

         out.println();

         for (StackTraceElement traceEl : el.getValue())

         {

            out.println(traceEl);

         }

      }

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

      out.println("End Thread dump");

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

      log.warn(str.toString());

   }

   public void stop(boolean failoverOnServerShutdown) throws Exception

   {

      stop(failoverOnServerShutdown, false);

   }

  

   protected void stop(boolean failoverOnServerShutdown, boolean criticalIOError) throws Exception

   {

      synchronized (this)

      {

         if (!started)

         {

            return;

         }

         connectorsService.stop();

         // we stop the groupinghandler before we stop te cluster manager so binding mappings aren't removed in case of

         // failover

         if (groupingHandler != null)

         {

            managementService.removeNotificationListener(groupingHandler);

            groupingHandler = null;

         }

         if (clusterManager != null)

         {

            clusterManager.stop();

         }

      }

      remotingService.stop();

      // We close all the exception in an attempt to let any pending IO to finish

      // to avoid scenarios where the send or ACK got to disk but the response didn't get to the client

      // It may still be possible to have this scenario on a real failure (without the use of XA)

      // But at least we will do our best to avoid it on regular shutdowns

      for (ServerSession session : sessions.values())

      {

         try

         {

            storageManager.setContext(session.getSessionContext());

            session.close(true);

            if (!criticalIOError)

            {

               session.waitContextCompletion();

            }

         }

         catch (Exception e)

         {

            // If anything went wrong with closing sessions.. we should ignore it

            // such as transactions.. etc.

            log.warn(e.getMessage(), e);

         }

      }

     

      storageManager.clearContext();

      synchronized (this)

      {

         // Stop the deployers

         if (configuration.isFileDeploymentEnabled())

         {

            basicUserCredentialsDeployer.stop();

            addressSettingsDeployer.stop();

            if (queueDeployer != null)

            {

               queueDeployer.stop();

            }

            if (securityDeployer != null)

            {

               securityDeployer.stop();

            }

            deploymentManager.stop();

         }

         managementService.unregisterServer();

         managementService.stop();

         if (pagingManager != null)

         {

            pagingManager.stop();

         }

         if (!criticalIOError && storageManager != null)

         {

            storageManager.stop();

         }

         if (replicationManager != null)

         {

            replicationManager.stop();

            replicationManager = null;

         }

         if (replicationEndpoint != null)

         {

            replicationEndpoint.stop();

            replicationEndpoint = null;

         }

         if (securityManager != null)

         {

            securityManager.stop();

         }

         if (resourceManager != null)

         {

            resourceManager.stop();

         }

         if (postOffice != null)

         {

            postOffice.stop();

         }

         List<Runnable> tasks = scheduledPool.shutdownNow();

         for (Runnable task : tasks)

         {

            HornetQServerImpl.log.debug(this + "::Waiting for " + task);

         }

         if (memoryManager != null)

         {

            memoryManager.stop();

         }

         threadPool.shutdown();

         scheduledPool.shutdown();

         try

         {

            if (!threadPool.awaitTermination(10, TimeUnit.SECONDS))

            {

               HornetQServerImpl.log.warn("Timed out waiting for pool to terminate");

            }

         }

         catch (InterruptedException e)

         {

            // Ignore

         }

         threadPool = null;

         try

         {

            if (!scheduledPool.awaitTermination(10, TimeUnit.SECONDS))

            {

               HornetQServerImpl.log.warn("Timed out waiting for scheduled pool to terminate");

            }

         }

         catch (InterruptedException e)

         {

            // Ignore

         }

        

         securityStore.stop();

         threadPool = null;

         scheduledPool = null;

         pagingManager = null;

         securityStore = null;

         resourceManager = null;

         postOffice = null;

         securityStore = null;

         queueFactory = null;

         resourceManager = null;

         messagingServerControl = null;

         memoryManager = null;

         sessions.clear();

         started = false;

         initialised = false;

         // to display in the log message

         SimpleString tempNodeID = getNodeID();

         if (activation != null)

         {

            activation.close(failoverOnServerShutdown);

         }

         if (backupActivationThread != null)

         {

            backupActivationThread.join();

         }

         nodeManager.stop();

         nodeManager = null;

         addressSettingsRepository.clearListeners();

         addressSettingsRepository.clearCache();

         HornetQServerImpl.log.info("HornetQ Server version " + getVersion().getFullVersion() +

                                    " [" +

                                    tempNodeID +

                                    "] stopped");

         Logger.reset();

      }

   }

   // HornetQServer implementation

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

   public String describe()

   {

      StringWriter str = new StringWriter();

      PrintWriter out = new PrintWriter(str);

      out.println("Information about server " + this.identity);

      out.println("Cluster Connection:" + this.getClusterManager().describe());

      return str.toString();

   }

   public void setIdentity(String identity)

   {

      this.identity = identity;

   }

   public String getIdentity()

   {

      return identity;

   }

   public ScheduledExecutorService getScheduledPool()

   {

      return scheduledPool;

   }

   public ExecutorService getThreadPool()

   {

      return threadPool;

   }

   public Configuration getConfiguration()

   {

      return configuration;

   }

   public MBeanServer getMBeanServer()

   {

      return mbeanServer;

   }

   public PagingManager getPagingManager()

   {

      return pagingManager;

   }

   public RemotingService getRemotingService()

   {

      return remotingService;

   }

   public StorageManager getStorageManager()

   {

      return storageManager;

   }

   public HornetQSecurityManager getSecurityManager()

   {

      return securityManager;

   }

   public ManagementService getManagementService()

   {

      return managementService;

   }

   public HierarchicalRepository<Set<Role>> getSecurityRepository()

   {

      return securityRepository;

   }

   public NodeManager getNodeManager()

   {

      return nodeManager;

   }

   public HierarchicalRepository<AddressSettings> getAddressSettingsRepository()

   {

      return addressSettingsRepository;

   }

   public DeploymentManager getDeploymentManager()

   {

      return deploymentManager;

   }

   public ResourceManager getResourceManager()

   {

      return resourceManager;

   }

   public Version getVersion()

   {

      return version;

   }

   public boolean isStarted()

   {

      return started;

   }

  

   public boolean isStopped()

   {

      return stopped;

   }

   public ClusterManager getClusterManager()

   {

      return clusterManager;

   }

   public ServerSession createSession(final String name,

                                      final String username,

                                      final String password,

                                      final int minLargeMessageSize,

                                      final RemotingConnection connection,

                                      final boolean autoCommitSends,

                                      final boolean autoCommitAcks,

                                      final boolean preAcknowledge,

                                      final boolean xa,

                                      final String defaultAddress,

                                      final SessionCallback callback) throws Exception

   {

      if (securityStore != null)

      {

         securityStore.authenticate(username, password);

      }

      final ServerSessionImpl session = new ServerSessionImpl(name,

                                                              username,

                                                              password,

                                                              minLargeMessageSize,

                                                              autoCommitSends,

                                                              autoCommitAcks,

                                                              preAcknowledge,

                                                              configuration.isPersistDeliveryCountBeforeDelivery(),

                                                              xa,

                                                              connection,

                                                              storageManager,

                                                              postOffice,

                                                              resourceManager,

                                                              securityStore,

                                                              managementService,

                                                              this,

                                                              configuration.getManagementAddress(),

                                                              defaultAddress == null ? null

                                                                                    : new SimpleString(defaultAddress),

                                                              callback);

      sessions.put(name, session);

      return session;

   }

   public synchronized ReplicationEndpoint connectToReplicationEndpoint(final Channel channel) throws Exception

   {

      if (!configuration.isBackup())

      {

         throw new HornetQException(HornetQException.ILLEGAL_STATE, "Connected server is not a backup server");

      }

      if (replicationEndpoint.getChannel() != null)

      {

         throw new HornetQException(HornetQException.ILLEGAL_STATE,

                                    "Backup replication server is already connected to another server");

      }

      replicationEndpoint.setChannel(channel);

      return replicationEndpoint;

   }

   public void removeSession(final String name) throws Exception

   {

      sessions.remove(name);

   }

   public boolean lookupSession(String key, String value)

   {

      // getSessions is called here in a try to minimize locking the Server while this check is being done

      Set<ServerSession> allSessions = getSessions();

      for (ServerSession session : allSessions)

      {

         String metaValue = session.getMetaData(key);

         if (metaValue != null && metaValue.equals(value))

         {

            return true;

         }

      }

      return false;

   }

   public synchronized List<ServerSession> getSessions(final String connectionID)

   {

      Set<Entry<String, ServerSession>> sessionEntries = sessions.entrySet();

      List<ServerSession> matchingSessions = new ArrayList<ServerSession>();

      for (Entry<String, ServerSession> sessionEntry : sessionEntries)

      {

         ServerSession serverSession = sessionEntry.getValue();

         if (serverSession.getConnectionID().toString().equals(connectionID))

         {

            matchingSessions.add(serverSession);

         }

      }

      return matchingSessions;

   }

   public synchronized Set<ServerSession> getSessions()

   {

      return new HashSet<ServerSession>(sessions.values());

   }

   public boolean isInitialised()

   {

      synchronized (initialiseLock)

      {

         return initialised;

      }

   }

   public HornetQServerControlImpl getHornetQServerControl()

   {

      return messagingServerControl;

   }

   public int getConnectionCount()

   {

      return remotingService.getConnections().size();

   }

   public PostOffice getPostOffice()

   {

      return postOffice;

   }

   public QueueFactory getQueueFactory()

   {

      return queueFactory;

   }

   public SimpleString getNodeID()

   {

      return nodeManager == null ? null : nodeManager.getNodeId();

   }

   public Queue createQueue(final SimpleString address,

                            final SimpleString queueName,

                            final SimpleString filterString,

                            final boolean durable,

                            final boolean temporary) throws Exception

   {

      return createQueue(address, queueName, filterString, durable, temporary, false);

   }

   public Queue locateQueue(SimpleString queueName) throws Exception

   {

      Binding binding = postOffice.getBinding(queueName);

      if (binding == null)

      {

         return null;

      }

      Bindable queue = binding.getBindable();

      if (!(queue instanceof Queue))

      {

         throw new IllegalStateException("locateQueue should only be used to locate queues");

      }

      return (Queue)binding.getBindable();

   }

   public Queue deployQueue(final SimpleString address,

                            final SimpleString queueName,

                            final SimpleString filterString,

                            final boolean durable,

                            final boolean temporary) throws Exception

   {

      log.info("trying to deploy queue " + queueName);

      return createQueue(address, queueName, filterString, durable, temporary, true);

   }

   public void destroyQueue(final SimpleString queueName, final ServerSession session) throws Exception

   {

      addressSettingsRepository.clearCache();

      Binding binding = postOffice.getBinding(queueName);

      if (binding == null)

      {

         throw new HornetQException(HornetQException.QUEUE_DOES_NOT_EXIST, "No such queue " + queueName);

      }

      Queue queue = (Queue)binding.getBindable();

      if (queue.getPageSubscription() != null)

      {

         queue.getPageSubscription().close();

      }

      if (queue.getConsumerCount() != 0)

      {

         throw new HornetQException(HornetQException.ILLEGAL_STATE, "Cannot delete queue " + queue.getName() +

                                                                    " on binding " +

                                                                    queueName +

                                                                    " - it has consumers = " +

                                                                    binding.getClass().getName());

      }

      if (session != null)

      {

         if (queue.isDurable())

         {

            // make sure the user has privileges to delete this queue

            securityStore.check(binding.getAddress(), CheckType.DELETE_DURABLE_QUEUE, session);

         }

         else

         {

            securityStore.check(binding.getAddress(), CheckType.DELETE_NON_DURABLE_QUEUE, session);

         }

      }

      queue.deleteAllReferences();

      if (queue.isDurable())

      {

         storageManager.deleteQueueBinding(queue.getID());

      }

      postOffice.removeBinding(queueName);

   }

   public synchronized void registerActivateCallback(final ActivateCallback callback)

   {

      activateCallbacks.add(callback);

   }

   public synchronized void unregisterActivateCallback(final ActivateCallback callback)

   {

      activateCallbacks.remove(callback);

   }

   public ExecutorFactory getExecutorFactory()

   {

      return executorFactory;

   }

   public void setGroupingHandler(final GroupingHandler groupingHandler)

   {

      this.groupingHandler = groupingHandler;

   }

   public GroupingHandler getGroupingHandler()

   {

      return groupingHandler;

   }

   public ReplicationEndpoint getReplicationEndpoint()

   {

      return replicationEndpoint;

   }

   public ReplicationManager getReplicationManager()

   {

      return replicationManager;

   }

   public ConnectorsService getConnectorsService()

   {

      return connectorsService;

   }

   public synchronized boolean checkActivate() throws Exception

   {

      if (configuration.isBackup())

      {

         // Handle backup server activation

         if (!configuration.isSharedStore())

         {

            if (replicationEndpoint == null)

            {

               HornetQServerImpl.log.warn("There is no replication endpoint, can't activate this backup server");

               throw new HornetQException(HornetQException.INTERNAL_ERROR, "Can't activate the server");

            }

            replicationEndpoint.stop();

         }

         // Complete the startup procedure

         HornetQServerImpl.log.info("Activating backup server");

         configuration.setBackup(false);

         initialisePart2();

      }

      return true;

   }

   public void deployDivert(DivertConfiguration config) throws Exception

   {

      if (config.getName() == null)

      {

         HornetQServerImpl.log.warn("Must specify a name for each divert. This one will not be deployed.");

         return;

      }

      if (config.getAddress() == null)

      {

         HornetQServerImpl.log.warn("Must specify an address for each divert. This one will not be deployed.");

         return;

      }

      if (config.getForwardingAddress() == null)

      {

         HornetQServerImpl.log.warn("Must specify an forwarding address for each divert. This one will not be deployed.");

         return;

      }

      SimpleString sName = new SimpleString(config.getName());

      if (postOffice.getBinding(sName) != null)

      {

         HornetQServerImpl.log.warn("Binding already exists with name " + sName + ", divert will not be deployed");

         return;

      }

      SimpleString sAddress = new SimpleString(config.getAddress());

      Transformer transformer = instantiateTransformer(config.getTransformerClassName());

      Filter filter = FilterImpl.createFilter(config.getFilterString());

      Divert divert = new DivertImpl(new SimpleString(config.getForwardingAddress()),

                                     sName,

                                     new SimpleString(config.getRoutingName()),

                                     config.isExclusive(),

                                     filter,

                                     transformer,

                                     postOffice,

                                     storageManager);

      Binding binding = new DivertBinding(storageManager.generateUniqueID(), sAddress, divert);

      postOffice.addBinding(binding);

      managementService.registerDivert(divert, config);

   }

   public void destroyDivert(SimpleString name) throws Exception

   {

      Binding binding = postOffice.getBinding(name);

      if (binding == null)

      {

         throw new HornetQException(HornetQException.INTERNAL_ERROR, "No binding for divert " + name);

      }

      if (!(binding instanceof DivertBinding))

      {

         throw new HornetQException(HornetQException.INTERNAL_ERROR, "Binding " + name + " is not a divert");

      }

      postOffice.removeBinding(name);

   }

   public void deployBridge(BridgeConfiguration config) throws Exception

   {

      if (clusterManager != null)

      {

         clusterManager.deployBridge(config, true);

      }

   }

   public void destroyBridge(String name) throws Exception

   {

      if (clusterManager != null)

      {

         clusterManager.destroyBridge(name);

      }

   }

   public ServerSession getSessionByID(String sessionName)

   {

      return sessions.get(sessionName);

   }

   // PUBLIC -------

   public String toString()