public JmsServerSessionPool(JmsActivation activation) 
{
   
      this.activation = activation;
}

Create a new session pool

Parameters:

activation - the jms activation

 public JmsActivation getActivation() 
{
      return activation;
}

 public ServerSession getServerSession() throws JMSException 
{
      boolean trace = log.isTraceEnabled();
      if (trace)
         log.trace("getServerSession");
      ServerSession result = null;
      try
      {
         synchronized (serverSessions)
         {
            while (true)
            {
               int sessionsSize = serverSessions.size();
               if (stopped)
                  throw new Exception("Cannot get a server session after the pool is stopped");
               else if (sessionsSize  > 0)
               {
                  result = (ServerSession) serverSessions.remove(sessionsSize-1);
                  break;
               }
               else
               {
                  try
                  {
                     serverSessions.wait();
                  }
                  catch (InterruptedException ignored)
                  {
                  }
               }
            }
         }
      }
      catch (Throwable t)
      {
         throw new JMSException("Unable to get a server session " + t);
      }
      if (trace)
         log.trace("Returning server session " + result);
      return result;
}

 protected  void returnServerSession(JmsServerSession session) 
{
      synchronized (serverSessions)
      {
         if (stopped)
         {
            session.teardown();
            --sessionCount;
         }
         else
            serverSessions.add(session);
         serverSessions.notifyAll();
      }
}

Return the server session

 protected  void setupConsumer() throws Exception 
{
      Connection connection = activation.getConnection();
      JmsActivationSpec spec = activation.getActivationSpec();
      String selector = spec.getMessageSelector();
      int maxMessages = spec.getMaxMessagesInt();
      if (spec.isTopic())
      {
         Topic topic = (Topic) activation.getDestination();
         String subscriptionName = spec.getSubscriptionName();
         if (spec.isDurable())
            consumer = connection.createDurableConnectionConsumer(topic, subscriptionName, selector, this, maxMessages);
         else
            consumer = connection.createConnectionConsumer(topic, selector, this, maxMessages);
      }
      else
      {
         Queue queue = (Queue) activation.getDestination();
         consumer = connection.createConnectionConsumer(queue, selector, this, maxMessages);
      }
      log.debug("Created consumer " + consumer);
}

Setup the connection consumer

 protected  void setupSessions() throws Exception 
{
      JmsActivationSpec spec = activation.getActivationSpec();
      ArrayList clonedSessions = null;
      // Create the sessions
      synchronized (serverSessions)
      {
         for (int i = 0; i <  spec.getMaxSessionInt(); ++i)
         {
            JmsServerSession session = new JmsServerSession(this);
            serverSessions.add(session);
         }
         sessionCount = serverSessions.size();
         clonedSessions = (ArrayList) serverSessions.clone();
      }
      // Start the sessions
      for (int i = 0; i <  clonedSessions.size(); ++ i)
      {
         JmsServerSession session = (JmsServerSession) clonedSessions.get(i);
         session.setup();
      }
}

Setup the sessions

 public  void start() throws Exception 
{
      setupSessions();
      setupConsumer();
}

Start the server session pool

 public  void stop() 
{
      teardownConsumer();
      teardownSessions();
}

Stop the server session pool

 protected  void teardownConsumer() 
{
      try
      {
         if (consumer != null)
         {
            log.debug("Closing the " + consumer);
            consumer.close();
         }
      }
      catch (Throwable t)
      {
         log.debug("Error closing the consumer " + consumer, t);
      }
}

Stop the connection consumer

 protected  void teardownSessions() 
{
      synchronized (serverSessions)
      {
         // Disallow any new sessions
         stopped = true;
         serverSessions.notifyAll();
         // Stop inactive sessions
         for (int i = 0; i <  serverSessions.size(); ++i)
         {
            JmsServerSession session = (JmsServerSession) serverSessions.get(i);
            session.teardown();
            --sessionCount;
         }
         serverSessions.clear();
         if (activation.getActivationSpec().isForceClearOnShutdown())
         {        
            int attempts = 0;
            int forceClearAttempts = activation.getActivationSpec().getForceClearAttempts();
            long forceClearInterval = activation.getActivationSpec().getForceClearOnShutdownInterval();
            log.trace(this + " force clear behavior in effect. Waiting for " + forceClearInterval + " milliseconds for " + forceClearAttempts + " attempts.");
            while((sessionCount  > 0) && (attempts <  forceClearAttempts))
            {
               try
               {
                  int currentSessions = sessionCount;
                  serverSessions.wait(forceClearInterval);
                  // Number of session didn't change
                  if (sessionCount == currentSessions)
                  {
                     ++attempts;
                     log.trace(this + " clear attempt failed " + attempts); 
                  }
               }
               catch(InterruptedException ignore)
               {
               }
            }
         }
         else
         {
            // Wait for inuse sessions
            while (sessionCount  > 0)
            {
               try
               {
                  serverSessions.wait();
               }
               catch (InterruptedException ignore)
               {
               }
            }
         }
      }
}

Stop the sessions