* Copyright 2005-2014 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.

*/

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

* @author <a href="mailto:ovidiu@feodorov.com">Ovidiu Feodorov</a>

* @author <a href="mailto:clebert.suconic@jboss.org">Clebert Suconic</a>

* @author <a href="mailto:jmesnil@redhat.com">Jeff Mesnil</a>

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

*/

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

   private final ClientSessionFactoryInternal sessionFactory;

   private final String name;

   private final String username;

   private final String password;

   private final boolean xa;

   private final Executor executor;

   // to be sent to consumers as consumers will need a separate consumer for flow control

   private final Executor flowControlExecutor;

   private volatile CoreRemotingConnection remotingConnection;

   /**

    * All access to producers are guarded (i.e. synchronized) on itself.

    */

   private final Set<ClientProducerInternal> producers = new HashSet<ClientProducerInternal>();

   // Consumers must be an ordered map so if we fail we recreate them in the same order with the same ids

   private final Map<Long, ClientConsumerInternal> consumers = new LinkedHashMap<Long, ClientConsumerInternal>();

   private volatile boolean closed;

   private final boolean autoCommitAcks;

   private final boolean preAcknowledge;

   private final boolean autoCommitSends;

   private final boolean blockOnAcknowledge;

   private final boolean autoGroup;

   private final int ackBatchSize;

   private final int consumerWindowSize;

   private final int consumerMaxRate;

   private final int confirmationWindowSize;

   private final int producerMaxRate;

   private final boolean blockOnNonDurableSend;

   private final boolean blockOnDurableSend;

   private final int minLargeMessageSize;

   private final boolean compressLargeMessages;

   private volatile int initialMessagePacketSize;

   private final boolean cacheLargeMessageClient;

   private final Channel channel;

   private final int version;

   // For testing only

   private boolean forceNotSameRM;

   private final IDGenerator idGenerator = new SimpleIDGenerator(0);

   private final ClientProducerCreditManager producerCreditManager;

   private volatile boolean started;

   private SendAcknowledgementHandler sendAckHandler;

   private volatile boolean rollbackOnly;

   private volatile boolean workDone;

   private final String groupID;

   private volatile boolean inClose;

   private volatile boolean mayAttemptToFailover = true;

   private volatile SimpleString defaultAddress;

   private boolean xaRetry = false;

   /**

    * Current XID. this will be used in case of failover

    */

   private Xid currentXID;

   private final AtomicInteger concurrentCall = new AtomicInteger(0);

   private final ConfirmationWindowWarning confirmationWindowWarning;

   ClientSessionImpl(final ClientSessionFactoryInternal sessionFactory,

                     final String name,

                     final String username,

                     final String password,

                     final boolean xa,

                     final boolean autoCommitSends,

                     final boolean autoCommitAcks,

                     final boolean preAcknowledge,

                     final boolean blockOnAcknowledge,

                     final boolean autoGroup,

                     final int ackBatchSize,

                     final int consumerWindowSize,

                     final int consumerMaxRate,

                     final int confirmationWindowSize,

                     final int producerWindowSize,

                     final int producerMaxRate,

                     final boolean blockOnNonDurableSend,

                     final boolean blockOnDurableSend,

                     final boolean cacheLargeMessageClient,

                     final int minLargeMessageSize,

                     final boolean compressLargeMessages,

                     final int initialMessagePacketSize,

                     final String groupID,

                     final CoreRemotingConnection remotingConnection,

                     final int version,

                     final Channel channel,

                     final Executor executor,

                     final Executor flowControlExecutor) throws HornetQException

   {

      this.sessionFactory = sessionFactory;

      this.name = name;

      this.username = username;

      this.password = password;

      this.remotingConnection = remotingConnection;

      this.executor = executor;

      this.flowControlExecutor = flowControlExecutor;

      this.xa = xa;

      this.autoCommitAcks = autoCommitAcks;

      this.preAcknowledge = preAcknowledge;

      this.autoCommitSends = autoCommitSends;

      this.blockOnAcknowledge = blockOnAcknowledge;

      this.autoGroup = autoGroup;

      this.channel = channel;

      this.version = version;

      this.ackBatchSize = ackBatchSize;

      this.consumerWindowSize = consumerWindowSize;

      this.consumerMaxRate = consumerMaxRate;

      this.confirmationWindowSize = confirmationWindowSize;

      this.producerMaxRate = producerMaxRate;

      this.blockOnNonDurableSend = blockOnNonDurableSend;

      this.blockOnDurableSend = blockOnDurableSend;

      this.cacheLargeMessageClient = cacheLargeMessageClient;

      this.minLargeMessageSize = minLargeMessageSize;

      this.compressLargeMessages = compressLargeMessages;

      this.initialMessagePacketSize = initialMessagePacketSize;

      this.groupID = groupID;

      producerCreditManager = new ClientProducerCreditManagerImpl(this, producerWindowSize);

      if (confirmationWindowSize >= 0)

      {

         this.channel.setCommandConfirmationHandler(this);

      }

      confirmationWindowWarning = sessionFactory.getConfirmationWindowWarning();

   }

   // ClientSession implementation

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

   public Channel getChannel()

   {

      return channel;

   }

   public void createQueue(final SimpleString address, final SimpleString queueName) throws HornetQException

   {

      internalCreateQueue(address, queueName, null, false, false);

   }

   public void createQueue(final SimpleString address, final SimpleString queueName, final boolean durable) throws HornetQException

   {

      internalCreateQueue(address, queueName, null, durable, false);

   }

   public void createQueue(final String address, final String queueName, final boolean durable) throws HornetQException

   {

      createQueue(SimpleString.toSimpleString(address), SimpleString.toSimpleString(queueName), durable);

   }

   public void createSharedQueue(SimpleString address,

                                 SimpleString queueName,

                                 boolean durable) throws HornetQException

   {

      createSharedQueue(address, queueName, null, durable);

   }

   public void createSharedQueue(SimpleString address,

                                 SimpleString queueName,

                                 SimpleString filterString,

                                 boolean durable) throws HornetQException

   {

      checkClosed();

      CreateSharedQueueMessage request = new CreateSharedQueueMessage(address, queueName, filterString, durable, true);

      startCall();

      try

      {

         channel.sendBlocking(request, PacketImpl.NULL_RESPONSE);

      }

      finally

      {

         endCall();

      }

   }

   public void createQueue(final SimpleString address,

                           final SimpleString queueName,

                           final SimpleString filterString,

                           final boolean durable) throws HornetQException

   {

      internalCreateQueue(address, queueName, filterString, durable, false);

   }

   public void createQueue(final String address,

                           final String queueName,

                           final String filterString,

                           final boolean durable) throws HornetQException

   {

      createQueue(SimpleString.toSimpleString(address), SimpleString.toSimpleString(queueName), SimpleString.toSimpleString(filterString), durable);

   }

   public void createTemporaryQueue(final SimpleString address, final SimpleString queueName) throws HornetQException

   {

      internalCreateQueue(address, queueName, null, false, true);

   }

   public void createTemporaryQueue(final String address, final String queueName) throws HornetQException

   {

      internalCreateQueue(SimpleString.toSimpleString(address),

                          SimpleString.toSimpleString(queueName),

                          null,

                          false,

                          true);

   }

   public void createTemporaryQueue(final SimpleString address, final SimpleString queueName, final SimpleString filter) throws HornetQException

   {

      internalCreateQueue(address, queueName, filter, false, true);

   }

   public void createTemporaryQueue(final String address, final String queueName, final String filter) throws HornetQException

   {

      internalCreateQueue(SimpleString.toSimpleString(address),

                          SimpleString.toSimpleString(queueName),

                          SimpleString.toSimpleString(filter),

                          false,

                          true);

   }

   public void deleteQueue(final SimpleString queueName) throws HornetQException

   {

      checkClosed();

      startCall();

      try

      {

         channel.sendBlocking(new SessionDeleteQueueMessage(queueName), PacketImpl.NULL_RESPONSE);

      }

      finally

      {

         endCall();

      }

   }

   public void deleteQueue(final String queueName) throws HornetQException

   {

      deleteQueue(SimpleString.toSimpleString(queueName));

   }

   public QueueQuery queueQuery(final SimpleString queueName) throws HornetQException

   {

      checkClosed();

      SessionQueueQueryMessage request = new SessionQueueQueryMessage(queueName);

      startCall();

      try

      {

         SessionQueueQueryResponseMessage response = (SessionQueueQueryResponseMessage) channel.sendBlocking(request, PacketImpl.SESS_QUEUEQUERY_RESP);

         return new QueueQueryImpl(response.isDurable(),

                                   response.getConsumerCount(),

                                   response.getMessageCount(),

                                   response.getFilterString(),

                                   response.getAddress(),

                                   response.isExists());

      }

      finally

      {

         endCall();

      }

   }

   public BindingQuery bindingQuery(final SimpleString address) throws HornetQException

   {

      checkClosed();

      SessionBindingQueryMessage request = new SessionBindingQueryMessage(address);

      SessionBindingQueryResponseMessage response = (SessionBindingQueryResponseMessage) channel.sendBlocking(request, PacketImpl.SESS_BINDINGQUERY_RESP);

      return new BindingQueryImpl(response.isExists(), response.getQueueNames());

   }

   public void forceDelivery(final long consumerID, final long sequence) throws HornetQException

   {

      checkClosed();

      SessionForceConsumerDelivery request = new SessionForceConsumerDelivery(consumerID, sequence);

      channel.send(request);

   }

   public ClientConsumer createConsumer(final SimpleString queueName) throws HornetQException

   {

      return createConsumer(queueName, null, false);

   }

   public ClientConsumer createConsumer(final String queueName) throws HornetQException

   {

      return createConsumer(SimpleString.toSimpleString(queueName));

   }

   public ClientConsumer createConsumer(final SimpleString queueName, final SimpleString filterString) throws HornetQException

   {

      return createConsumer(queueName, filterString, consumerWindowSize, consumerMaxRate, false);

   }

   public void createQueue(final String address, final String queueName) throws HornetQException

   {

      createQueue(SimpleString.toSimpleString(address), SimpleString.toSimpleString(queueName));

   }

   public ClientConsumer createConsumer(final String queueName, final String filterString) throws HornetQException

   {

      return createConsumer(SimpleString.toSimpleString(queueName), SimpleString.toSimpleString(filterString));

   }

   public ClientConsumer createConsumer(final SimpleString queueName,

                                        final SimpleString filterString,

                                        final boolean browseOnly) throws HornetQException

   {

      return createConsumer(queueName, filterString, consumerWindowSize, consumerMaxRate, browseOnly);

   }

   public ClientConsumer createConsumer(final SimpleString queueName, final boolean browseOnly) throws HornetQException

   {

      return createConsumer(queueName, null, consumerWindowSize, consumerMaxRate, browseOnly);

   }

   public ClientConsumer createConsumer(final String queueName, final String filterString, final boolean browseOnly) throws HornetQException

   {

      return createConsumer(SimpleString.toSimpleString(queueName),

                            SimpleString.toSimpleString(filterString),

                            browseOnly);

   }

   public ClientConsumer createConsumer(final String queueName, final boolean browseOnly) throws HornetQException

   {

      return createConsumer(SimpleString.toSimpleString(queueName), null, browseOnly);

   }

   /**

    * Note, we DO NOT currently support direct consumers (i.e. consumers where delivery occurs on

    * the remoting thread).

    * <p/>

    * Direct consumers have issues with blocking and failover. E.g. if direct then inside

    * MessageHandler call a blocking method like rollback or acknowledge (blocking) This can block

    * until failover completes, which disallows the thread to be used to deliver any responses to

    * the client during that period, so failover won't occur. If we want direct consumers we need to

    * rethink how they work.

    */

   public ClientConsumer createConsumer(final SimpleString queueName,

                                        final SimpleString filterString,

                                        final int windowSize,

                                        final int maxRate,

                                        final boolean browseOnly) throws HornetQException

   {

      return internalCreateConsumer(queueName, filterString, windowSize, maxRate, browseOnly);

   }

   public ClientConsumer createConsumer(final String queueName,

                                        final String filterString,

                                        final int windowSize,

                                        final int maxRate,

                                        final boolean browseOnly) throws HornetQException

   {

      return createConsumer(SimpleString.toSimpleString(queueName), SimpleString.toSimpleString(filterString), windowSize, maxRate, browseOnly);

   }

   public ClientProducer createProducer() throws HornetQException

   {

      return createProducer((SimpleString) null);

   }

   public ClientProducer createProducer(final SimpleString address) throws HornetQException

   {

      return createProducer(address, producerMaxRate);

   }

   public ClientProducer createProducer(final String address) throws HornetQException

   {

      return createProducer(SimpleString.toSimpleString(address));

   }

   public ClientProducer createProducer(final SimpleString address, final int maxRate) throws HornetQException

   {

      return internalCreateProducer(address, maxRate);

   }

   public ClientProducer createProducer(final String address, final int rate) throws HornetQException

   {

      return createProducer(SimpleString.toSimpleString(address), rate);

   }

   public XAResource getXAResource()

   {

      return this;

   }

   private void rollbackOnFailover(boolean outcomeKnown) throws HornetQException

   {

      rollback(false);

      if (outcomeKnown)

      {

         throw HornetQClientMessageBundle.BUNDLE.txRolledBack();

      }

      throw HornetQClientMessageBundle.BUNDLE.txOutcomeUnknown();

   }

   public void commit() throws HornetQException

   {

      checkClosed();

      if (HornetQClientLogger.LOGGER.isTraceEnabled())

      {

         HornetQClientLogger.LOGGER.trace("Sending commit");

      }

      /*

      * we have failed over since any work was done so we should rollback

      * */

      if (rollbackOnly)

      {

         rollbackOnFailover(true);

      }

      flushAcks();

      /*

      * if we have failed over whilst flushing the acks then we should rollback and throw exception before attempting to

      * commit as committing might actually commit something but we we wouldn't know and rollback after the commit

      * */

      if (rollbackOnly)

      {

         rollbackOnFailover(true);

      }

      try

      {

         channel.sendBlocking(new PacketImpl(PacketImpl.SESS_COMMIT), PacketImpl.NULL_RESPONSE);

      }

      catch (HornetQException e)

      {

         if (e.getType() == HornetQExceptionType.UNBLOCKED || rollbackOnly)

         {

            // The call to commit was unlocked on failover, we therefore rollback the tx,

            // and throw a transaction rolled back exception instead

            //or

            //if we have been set to rollbackonly then we have probably failed over and don't know if the tx has committed

            rollbackOnFailover(false);

         }

         else

         {

            throw e;

         }

      }

      //oops, we have failed over during the commit and don't know what happened

      if (rollbackOnly)

      {

         rollbackOnFailover(false);

      }

      workDone = false;

   }

   public boolean isRollbackOnly()

   {

      return rollbackOnly;

   }

   public void rollback() throws HornetQException

   {

      rollback(false);

   }

   public void rollback(final boolean isLastMessageAsDelivered) throws HornetQException

   {

      if (HornetQClientLogger.LOGGER.isTraceEnabled())

      {

         HornetQClientLogger.LOGGER.trace("calling rollback(isLastMessageAsDelivered=" + isLastMessageAsDelivered + ")");

      }

      checkClosed();

      // We do a "JMS style" rollback where the session is stopped, and the buffer is cancelled back

      // first before rolling back

      // This ensures messages are received in the same order after rollback w.r.t. to messages in the buffer

      // For core we could just do a straight rollback, it really depends if we want JMS style semantics or not...

      boolean wasStarted = started;

      if (wasStarted)

      {

         stop();

      }

      // We need to make sure we don't get any inflight messages

      for (ClientConsumerInternal consumer : cloneConsumers())

      {

         consumer.clear(true);

      }

      // Acks must be flushed here *after connection is stopped and all onmessages finished executing

      flushAcks();

      channel.sendBlocking(new RollbackMessage(isLastMessageAsDelivered), PacketImpl.NULL_RESPONSE);

      if (wasStarted)

      {

         start();

      }

      rollbackOnly = false;

   }

   public ClientMessage createMessage(final byte type,

                                      final boolean durable,

                                      final long expiration,

                                      final long timestamp,

                                      final byte priority)

   {

      return new ClientMessageImpl(type, durable, expiration, timestamp, priority, initialMessagePacketSize);

   }

   public ClientMessage createMessage(final byte type, final boolean durable)

   {

      return this.createMessage(type, durable, 0, System.currentTimeMillis(), (byte) 4);

   }

   public ClientMessage createMessage(final boolean durable)

   {

      return this.createMessage((byte) 0, durable);

   }

   public boolean isClosed()

   {

      return closed;

   }

   public boolean isAutoCommitSends()

   {

      return autoCommitSends;

   }

   public boolean isAutoCommitAcks()

   {

      return autoCommitAcks;

   }

   public boolean isBlockOnAcknowledge()

   {

      return blockOnAcknowledge;

   }

   public boolean isXA()

   {

      return xa;

   }

   public void resetIfNeeded() throws HornetQException

   {

      if (rollbackOnly)

      {

         HornetQClientLogger.LOGGER.resettingSessionAfterFailure();

         rollback(false);

      }

   }

   public void start() throws HornetQException

   {

      checkClosed();

      if (!started)

      {

         for (ClientConsumerInternal clientConsumerInternal : cloneConsumers())

         {

            clientConsumerInternal.start();

         }

         channel.send(new PacketImpl(PacketImpl.SESS_START));

         started = true;

      }

   }

   public void stop() throws HornetQException

   {

      stop(true);

   }

   public void stop(final boolean waitForOnMessage) throws HornetQException

   {

      checkClosed();

      if (started)

      {

         for (ClientConsumerInternal clientConsumerInternal : cloneConsumers())

         {

            clientConsumerInternal.stop(waitForOnMessage);

         }

         channel.sendBlocking(new PacketImpl(PacketImpl.SESS_STOP), PacketImpl.NULL_RESPONSE);

         started = false;

      }

   }

   public void addFailureListener(final SessionFailureListener listener)

   {

      sessionFactory.addFailureListener(listener);

   }

   public boolean removeFailureListener(final SessionFailureListener listener)

   {

      return sessionFactory.removeFailureListener(listener);

   }

   public void addFailoverListener(FailoverEventListener listener)

   {

      sessionFactory.addFailoverListener(listener);

   }

   public boolean removeFailoverListener(FailoverEventListener listener)

   {

      return sessionFactory.removeFailoverListener(listener);

   }

   public int getVersion()

   {

      return version;

   }

   // ClientSessionInternal implementation

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

   public int getMinLargeMessageSize()

   {

      return minLargeMessageSize;

   }

   public boolean isCompressLargeMessages()

   {

      return compressLargeMessages;

   }

   /**

    * @return the cacheLargeMessageClient

    */

   public boolean isCacheLargeMessageClient()

   {

      return cacheLargeMessageClient;

   }

   public String getName()

   {

      return name;

   }

   /**

    * Acknowledges all messages received by the consumer so far.

    */

   public void acknowledge(final long consumerID, final long messageID) throws HornetQException

   {

      // if we're pre-acknowledging then we don't need to do anything

      if (preAcknowledge)

      {

         return;

      }

      checkClosed();

      if (HornetQClientLogger.LOGGER.isDebugEnabled())

      {

         HornetQClientLogger.LOGGER.debug("client ack messageID = " + messageID);

      }

      SessionAcknowledgeMessage message = new SessionAcknowledgeMessage(consumerID, messageID, blockOnAcknowledge);

      startCall();

      try

      {

         if (blockOnAcknowledge)

         {

            channel.sendBlocking(message, PacketImpl.NULL_RESPONSE);

         }

         else

         {

            channel.sendBatched(message);

         }

      }

      finally

      {

         endCall();

      }

   }

   public void individualAcknowledge(final long consumerID, final long messageID) throws HornetQException

   {

      // if we're pre-acknowledging then we don't need to do anything

      if (preAcknowledge)

      {

         return;

      }

      checkClosed();

      SessionIndividualAcknowledgeMessage message = new SessionIndividualAcknowledgeMessage(consumerID,

                                                                                            messageID,

                                                                                            blockOnAcknowledge);

      startCall();

      try

      {

         if (blockOnAcknowledge)

         {

            channel.sendBlocking(message, PacketImpl.NULL_RESPONSE);

         }

         else

         {

            channel.sendBatched(message);

         }

      }

      finally

      {

         endCall();

      }

   }

   public void expire(final long consumerID, final long messageID) throws HornetQException

   {

      checkClosed();

      // We don't send expiries for pre-ack since message will already have been acked on server

      if (!preAcknowledge)

      {

         SessionExpireMessage message = new SessionExpireMessage(consumerID, messageID);

         channel.send(message);

      }

   }

   public void addConsumer(final ClientConsumerInternal consumer)

   {

      synchronized (consumers)

      {

         consumers.put(consumer.getID(), consumer);

      }

   }

   public void addProducer(final ClientProducerInternal producer)

   {

      synchronized (producers)

      {

         producers.add(producer);

      }

   }

   public void removeConsumer(final ClientConsumerInternal consumer) throws HornetQException

   {

      synchronized (consumers)

      {

         consumers.remove(consumer.getID());

      }

   }

   public void removeProducer(final ClientProducerInternal producer)

   {

      synchronized (producers)

      {

         producers.remove(producer);

      }

   }

   public void handleReceiveMessage(final long consumerID, final SessionReceiveMessage message) throws Exception