* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements.  See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF 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.

*/

    private static final Logger LOG = LoggerFactory.getLogger(TransportConnection.class);

    private static final Logger TRANSPORTLOG = LoggerFactory.getLogger(TransportConnection.class.getName() + ".Transport");

    private static final Logger SERVICELOG = LoggerFactory.getLogger(TransportConnection.class.getName() + ".Service");

    // Keeps track of the broker and connector that created this connection.

    protected final Broker broker;

    protected final TransportConnector connector;

    // Keeps track of the state of the connections.

    // protected final ConcurrentHashMap localConnectionStates=new

    // ConcurrentHashMap();

    protected final Map<ConnectionId, ConnectionState> brokerConnectionStates;

    // The broker and wireformat info that was exchanged.

    protected BrokerInfo brokerInfo;

    protected final List<Command> dispatchQueue = new LinkedList<Command>();

    protected TaskRunner taskRunner;

    protected final AtomicReference<IOException> transportException = new AtomicReference<IOException>();

    protected AtomicBoolean dispatchStopped = new AtomicBoolean(false);

    private final Transport transport;

    private MessageAuthorizationPolicy messageAuthorizationPolicy;

    private WireFormatInfo wireFormatInfo;

    // Used to do async dispatch.. this should perhaps be pushed down into the

    // transport layer..

    private boolean inServiceException;

    private final ConnectionStatistics statistics = new ConnectionStatistics();

    private boolean manageable;

    private boolean slow;

    private boolean markedCandidate;

    private boolean blockedCandidate;

    private boolean blocked;

    private boolean connected;

    private boolean active;

    private boolean starting;

    private boolean pendingStop;

    private long timeStamp;

    private final AtomicBoolean stopping = new AtomicBoolean(false);

    private final CountDownLatch stopped = new CountDownLatch(1);

    private final AtomicBoolean asyncException = new AtomicBoolean(false);

    private final Map<ProducerId, ProducerBrokerExchange> producerExchanges = new HashMap<ProducerId, ProducerBrokerExchange>();

    private final Map<ConsumerId, ConsumerBrokerExchange> consumerExchanges = new HashMap<ConsumerId, ConsumerBrokerExchange>();

    private final CountDownLatch dispatchStoppedLatch = new CountDownLatch(1);

    private ConnectionContext context;

    private boolean networkConnection;

    private boolean faultTolerantConnection;

    private final AtomicInteger protocolVersion = new AtomicInteger(CommandTypes.PROTOCOL_VERSION);

    private DemandForwardingBridge duplexBridge;

    private final TaskRunnerFactory taskRunnerFactory;

    private final TaskRunnerFactory stopTaskRunnerFactory;

    private TransportConnectionStateRegister connectionStateRegister = new SingleTransportConnectionStateRegister();

    private final ReentrantReadWriteLock serviceLock = new ReentrantReadWriteLock();

    private String duplexNetworkConnectorId;

    private Throwable stopError = null;

    /**

     * @param taskRunnerFactory - can be null if you want direct dispatch to the transport

     *                          else commands are sent async.

     * @param stopTaskRunnerFactory - can <b>not</b> be null, used for stopping this connection.

     */

    public TransportConnection(TransportConnector connector, final Transport transport, Broker broker,

                               TaskRunnerFactory taskRunnerFactory, TaskRunnerFactory stopTaskRunnerFactory) {

        this.connector = connector;

        this.broker = broker;

        RegionBroker rb = (RegionBroker) broker.getAdaptor(RegionBroker.class);

        brokerConnectionStates = rb.getConnectionStates();

        if (connector != null) {

            this.statistics.setParent(connector.getStatistics());

            this.messageAuthorizationPolicy = connector.getMessageAuthorizationPolicy();

        }

        this.taskRunnerFactory = taskRunnerFactory;

        this.stopTaskRunnerFactory = stopTaskRunnerFactory;

        this.transport = transport;

        this.transport.setTransportListener(new DefaultTransportListener() {

            @Override

            public void onCommand(Object o) {

                serviceLock.readLock().lock();

                try {

                    if (!(o instanceof Command)) {

                        throw new RuntimeException("Protocol violation - Command corrupted: " + o.toString());

                    }

                    Command command = (Command) o;

                    Response response = service(command);

                    if (response != null) {

                        dispatchSync(response);

                    }

                } finally {

                    serviceLock.readLock().unlock();

                }

            }

            @Override

            public void onException(IOException exception) {

                serviceLock.readLock().lock();

                try {

                    serviceTransportException(exception);

                } finally {

                    serviceLock.readLock().unlock();

                }

            }

        });

        connected = true;

    }

    /**

     * Returns the number of messages to be dispatched to this connection

     *

     * @return size of dispatch queue

     */

    @Override

    public int getDispatchQueueSize() {

        synchronized (dispatchQueue) {

            return dispatchQueue.size();

        }

    }

    public void serviceTransportException(IOException e) {

        BrokerService bService = connector.getBrokerService();

        if (bService.isShutdownOnSlaveFailure()) {

            if (brokerInfo != null) {

                if (brokerInfo.isSlaveBroker()) {

                    LOG.error("Slave has exception: " + e.getMessage() + " shutting down master now.", e);

                    try {

                        doStop();

                        bService.stop();

                    } catch (Exception ex) {

                        LOG.warn("Failed to stop the master", ex);

                    }

                }

            }

        }

        if (!stopping.get()) {

            transportException.set(e);

            if (TRANSPORTLOG.isDebugEnabled()) {

                TRANSPORTLOG.debug(this + " failed: " + e, e);

            } else if (TRANSPORTLOG.isWarnEnabled() && !expected(e)) {

                TRANSPORTLOG.warn(this + " failed: " + e);

            }

            stopAsync();

        }

    }

    private boolean expected(IOException e) {

        return isStomp() && ((e instanceof SocketException && e.getMessage().indexOf("reset") != -1) || e instanceof EOFException);

    }

    private boolean isStomp() {

        URI uri = connector.getUri();

        return uri != null && uri.getScheme() != null && uri.getScheme().indexOf("stomp") != -1;

    }

    /**

     * Calls the serviceException method in an async thread. Since handling a

     * service exception closes a socket, we should not tie up broker threads

     * since client sockets may hang or cause deadlocks.

     */

    @Override

    public void serviceExceptionAsync(final IOException e) {

        if (asyncException.compareAndSet(false, true)) {

            new Thread("Async Exception Handler") {

                @Override

                public void run() {

                    serviceException(e);

                }

            }.start();

        }

    }

    /**

     * Closes a clients connection due to a detected error. Errors are ignored

     * if: the client is closing or broker is closing. Otherwise, the connection

     * error transmitted to the client before stopping it's transport.

     */

    @Override

    public void serviceException(Throwable e) {

        // are we a transport exception such as not being able to dispatch

        // synchronously to a transport

        if (e instanceof IOException) {

            serviceTransportException((IOException) e);

        } else if (e.getClass() == BrokerStoppedException.class) {

            // Handle the case where the broker is stopped

            // But the client is still connected.

            if (!stopping.get()) {

                if (SERVICELOG.isDebugEnabled()) {

                    SERVICELOG.debug("Broker has been stopped.  Notifying client and closing his connection.");

                }

                ConnectionError ce = new ConnectionError();

                ce.setException(e);

                dispatchSync(ce);

                // Record the error that caused the transport to stop

                this.stopError = e;

                // Wait a little bit to try to get the output buffer to flush

                // the exception notification to the client.

                try {

                    Thread.sleep(500);

                } catch (InterruptedException ie) {

                    Thread.currentThread().interrupt();

                }

                // Worst case is we just kill the connection before the

                // notification gets to him.

                stopAsync();

            }

        } else if (!stopping.get() && !inServiceException) {

            inServiceException = true;

            try {

                SERVICELOG.warn("Async error occurred: " + e, e);

                ConnectionError ce = new ConnectionError();

                ce.setException(e);

                if (pendingStop) {

                    dispatchSync(ce);

                } else {

                    dispatchAsync(ce);

                }

            } finally {

                inServiceException = false;

            }

        }

    }

    @Override

    public Response service(Command command) {

        MDC.put("activemq.connector", connector.getUri().toString());

        Response response = null;

        boolean responseRequired = command.isResponseRequired();

        int commandId = command.getCommandId();

        try {

            if (!pendingStop) {

                response = command.visit(this);

            } else {

                response = new ExceptionResponse(this.stopError);

            }

        } catch (Throwable e) {

            if (SERVICELOG.isDebugEnabled() && e.getClass() != BrokerStoppedException.class) {

                SERVICELOG.debug("Error occured while processing " + (responseRequired ? "sync" : "async")

                        + " command: " + command + ", exception: " + e, e);

            }

            if (responseRequired) {

                response = new ExceptionResponse(e);

            } else {

                serviceException(e);

            }

        }

        if (responseRequired) {

            if (response == null) {

                response = new Response();

            }

            response.setCorrelationId(commandId);

        }

        // The context may have been flagged so that the response is not

        // sent.

        if (context != null) {

            if (context.isDontSendReponse()) {

                context.setDontSendReponse(false);

                response = null;

            }

            context = null;

        }

        MDC.remove("activemq.connector");

        return response;

    }

    @Override

    public Response processKeepAlive(KeepAliveInfo info) throws Exception {

        return null;

    }

    @Override

    public Response processRemoveSubscription(RemoveSubscriptionInfo info) throws Exception {

        broker.removeSubscription(lookupConnectionState(info.getConnectionId()).getContext(), info);

        return null;

    }

    @Override

    public Response processWireFormat(WireFormatInfo info) throws Exception {

        wireFormatInfo = info;

        protocolVersion.set(info.getVersion());

        return null;

    }

    @Override

    public Response processShutdown(ShutdownInfo info) throws Exception {

        stopAsync();

        return null;

    }

    @Override

    public Response processFlush(FlushCommand command) throws Exception {

        return null;

    }

    @Override

    public Response processBeginTransaction(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = null;

        if (cs != null) {

            context = cs.getContext();

        }

        if (cs == null) {

            throw new NullPointerException("Context is null");

        }

        // Avoid replaying dup commands

        if (cs.getTransactionState(info.getTransactionId()) == null) {

            cs.addTransactionState(info.getTransactionId());

            broker.beginTransaction(context, info.getTransactionId());

        }

        return null;

    }

    @Override

    public Response processEndTransaction(TransactionInfo info) throws Exception {

        // No need to do anything. This packet is just sent by the client

        // make sure he is synced with the server as commit command could

        // come from a different connection.

        return null;

    }

    @Override

    public Response processPrepareTransaction(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = null;

        if (cs != null) {

            context = cs.getContext();

        }

        if (cs == null) {

            throw new NullPointerException("Context is null");

        }

        TransactionState transactionState = cs.getTransactionState(info.getTransactionId());

        if (transactionState == null) {

            throw new IllegalStateException("Cannot prepare a transaction that had not been started or previously returned XA_RDONLY: "

                    + info.getTransactionId());

        }

        // Avoid dups.

        if (!transactionState.isPrepared()) {

            transactionState.setPrepared(true);

            int result = broker.prepareTransaction(context, info.getTransactionId());

            transactionState.setPreparedResult(result);

            if (result == XAResource.XA_RDONLY) {

                // we are done, no further rollback or commit from TM

                cs.removeTransactionState(info.getTransactionId());

            }

            IntegerResponse response = new IntegerResponse(result);

            return response;

        } else {

            IntegerResponse response = new IntegerResponse(transactionState.getPreparedResult());

            return response;

        }

    }

    @Override

    public Response processCommitTransactionOnePhase(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = cs.getContext();

        cs.removeTransactionState(info.getTransactionId());

        broker.commitTransaction(context, info.getTransactionId(), true);

        return null;

    }

    @Override

    public Response processCommitTransactionTwoPhase(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = cs.getContext();

        cs.removeTransactionState(info.getTransactionId());

        broker.commitTransaction(context, info.getTransactionId(), false);

        return null;

    }

    @Override

    public Response processRollbackTransaction(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = cs.getContext();

        cs.removeTransactionState(info.getTransactionId());

        broker.rollbackTransaction(context, info.getTransactionId());

        return null;

    }

    @Override

    public Response processForgetTransaction(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = cs.getContext();

        broker.forgetTransaction(context, info.getTransactionId());

        return null;

    }

    @Override

    public Response processRecoverTransactions(TransactionInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        context = cs.getContext();

        TransactionId[] preparedTransactions = broker.getPreparedTransactions(context);

        return new DataArrayResponse(preparedTransactions);

    }

    @Override

    public Response processMessage(Message messageSend) throws Exception {

        ProducerId producerId = messageSend.getProducerId();

        ProducerBrokerExchange producerExchange = getProducerBrokerExchange(producerId);

        if (producerExchange.canDispatch(messageSend)) {

            broker.send(producerExchange, messageSend);

        }

        return null;

    }

    @Override

    public Response processMessageAck(MessageAck ack) throws Exception {

        ConsumerBrokerExchange consumerExchange = getConsumerBrokerExchange(ack.getConsumerId());

        if (consumerExchange != null) {

            broker.acknowledge(consumerExchange, ack);

        }

        return null;

    }

    @Override

    public Response processMessagePull(MessagePull pull) throws Exception {

        return broker.messagePull(lookupConnectionState(pull.getConsumerId()).getContext(), pull);

    }

    @Override

    public Response processMessageDispatchNotification(MessageDispatchNotification notification) throws Exception {

        broker.processDispatchNotification(notification);

        return null;

    }

    @Override

    public Response processAddDestination(DestinationInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        broker.addDestinationInfo(cs.getContext(), info);

        if (info.getDestination().isTemporary()) {

            cs.addTempDestination(info);

        }

        return null;

    }

    @Override

    public Response processRemoveDestination(DestinationInfo info) throws Exception {

        TransportConnectionState cs = lookupConnectionState(info.getConnectionId());

        broker.removeDestinationInfo(cs.getContext(), info);

        if (info.getDestination().isTemporary()) {

            cs.removeTempDestination(info.getDestination());

        }

        return null;

    }

    @Override

    public Response processAddProducer(ProducerInfo info) throws Exception {

        SessionId sessionId = info.getProducerId().getParentId();

        ConnectionId connectionId = sessionId.getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        if (cs == null) {

            throw new IllegalStateException("Cannot add a producer to a connection that had not been registered: "

                    + connectionId);

        }

        SessionState ss = cs.getSessionState(sessionId);

        if (ss == null) {

            throw new IllegalStateException("Cannot add a producer to a session that had not been registered: "

                    + sessionId);

        }

        // Avoid replaying dup commands

        if (!ss.getProducerIds().contains(info.getProducerId())) {

            ActiveMQDestination destination = info.getDestination();

            if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination)) {

                if (getProducerCount(connectionId) >= connector.getMaximumProducersAllowedPerConnection()){

                    throw new IllegalStateException("Can't add producer on connection " + connectionId + ": at maximum limit: " + connector.getMaximumProducersAllowedPerConnection());

                }

            }

            broker.addProducer(cs.getContext(), info);

            try {

                ss.addProducer(info);

            } catch (IllegalStateException e) {

                broker.removeProducer(cs.getContext(), info);

            }

        }

        return null;

    }

    @Override

    public Response processRemoveProducer(ProducerId id) throws Exception {

        SessionId sessionId = id.getParentId();

        ConnectionId connectionId = sessionId.getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        SessionState ss = cs.getSessionState(sessionId);

        if (ss == null) {

            throw new IllegalStateException("Cannot remove a producer from a session that had not been registered: "

                    + sessionId);

        }

        ProducerState ps = ss.removeProducer(id);

        if (ps == null) {

            throw new IllegalStateException("Cannot remove a producer that had not been registered: " + id);

        }

        removeProducerBrokerExchange(id);

        broker.removeProducer(cs.getContext(), ps.getInfo());

        return null;

    }

    @Override

    public Response processAddConsumer(ConsumerInfo info) throws Exception {

        SessionId sessionId = info.getConsumerId().getParentId();

        ConnectionId connectionId = sessionId.getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        if (cs == null) {

            throw new IllegalStateException("Cannot add a consumer to a connection that had not been registered: "

                    + connectionId);

        }

        SessionState ss = cs.getSessionState(sessionId);

        if (ss == null) {

            throw new IllegalStateException(broker.getBrokerName()

                    + " Cannot add a consumer to a session that had not been registered: " + sessionId);

        }

        // Avoid replaying dup commands

        if (!ss.getConsumerIds().contains(info.getConsumerId())) {

            ActiveMQDestination destination = info.getDestination();

            if (destination != null && !AdvisorySupport.isAdvisoryTopic(destination)) {

                if (getConsumerCount(connectionId) >= connector.getMaximumConsumersAllowedPerConnection()){

                    throw new IllegalStateException("Can't add consumer on connection " + connectionId + ": at maximum limit: " + connector.getMaximumConsumersAllowedPerConnection());

                }

            }

            broker.addConsumer(cs.getContext(), info);

            try {

                ss.addConsumer(info);

                addConsumerBrokerExchange(info.getConsumerId());

            } catch (IllegalStateException e) {

                broker.removeConsumer(cs.getContext(), info);

            }

        }

        return null;

    }

    @Override

    public Response processRemoveConsumer(ConsumerId id, long lastDeliveredSequenceId) throws Exception {

        SessionId sessionId = id.getParentId();

        ConnectionId connectionId = sessionId.getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        if (cs == null) {

            throw new IllegalStateException("Cannot remove a consumer from a connection that had not been registered: "

                    + connectionId);

        }

        SessionState ss = cs.getSessionState(sessionId);

        if (ss == null) {

            throw new IllegalStateException("Cannot remove a consumer from a session that had not been registered: "

                    + sessionId);

        }

        ConsumerState consumerState = ss.removeConsumer(id);

        if (consumerState == null) {

            throw new IllegalStateException("Cannot remove a consumer that had not been registered: " + id);

        }

        ConsumerInfo info = consumerState.getInfo();

        info.setLastDeliveredSequenceId(lastDeliveredSequenceId);

        broker.removeConsumer(cs.getContext(), consumerState.getInfo());

        removeConsumerBrokerExchange(id);

        return null;

    }

    @Override

    public Response processAddSession(SessionInfo info) throws Exception {

        ConnectionId connectionId = info.getSessionId().getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        // Avoid replaying dup commands

        if (cs != null && !cs.getSessionIds().contains(info.getSessionId())) {

            broker.addSession(cs.getContext(), info);

            try {

                cs.addSession(info);

            } catch (IllegalStateException e) {

                e.printStackTrace();

                broker.removeSession(cs.getContext(), info);

            }

        }

        return null;

    }

    @Override

    public Response processRemoveSession(SessionId id, long lastDeliveredSequenceId) throws Exception {

        ConnectionId connectionId = id.getParentId();

        TransportConnectionState cs = lookupConnectionState(connectionId);

        if (cs == null) {

            throw new IllegalStateException("Cannot remove session from connection that had not been registered: " + connectionId);

        }

        SessionState session = cs.getSessionState(id);

        if (session == null) {

            throw new IllegalStateException("Cannot remove session that had not been registered: " + id);

        }

        // Don't let new consumers or producers get added while we are closing

        // this down.

        session.shutdown();

        // Cascade the connection stop to the consumers and producers.

        for (ConsumerId consumerId : session.getConsumerIds()) {

            try {

                processRemoveConsumer(consumerId, lastDeliveredSequenceId);

            } catch (Throwable e) {

                LOG.warn("Failed to remove consumer: " + consumerId + ". Reason: " + e, e);

            }

        }

        for (ProducerId producerId : session.getProducerIds()) {

            try {

                processRemoveProducer(producerId);

            } catch (Throwable e) {

                LOG.warn("Failed to remove producer: " + producerId + ". Reason: " + e, e);

            }

        }

        cs.removeSession(id);

        broker.removeSession(cs.getContext(), session.getInfo());

        return null;

    }

    @Override

    public Response processAddConnection(ConnectionInfo info) throws Exception {

        // Older clients should have been defaulting this field to true.. but

        // they were not.

        if (wireFormatInfo != null && wireFormatInfo.getVersion() <= 2) {

            info.setClientMaster(true);

        }

        TransportConnectionState state;

        // Make sure 2 concurrent connections by the same ID only generate 1

        // TransportConnectionState object.

        synchronized (brokerConnectionStates) {

            state = (TransportConnectionState) brokerConnectionStates.get(info.getConnectionId());

            if (state == null) {

                state = new TransportConnectionState(info, this);

                brokerConnectionStates.put(info.getConnectionId(), state);

            }

            state.incrementReference();

        }

        // If there are 2 concurrent connections for the same connection id,

        // then last one in wins, we need to sync here

        // to figure out the winner.

        synchronized (state.getConnectionMutex()) {

            if (state.getConnection() != this) {

                LOG.debug("Killing previous stale connection: " + state.getConnection().getRemoteAddress());

                state.getConnection().stop();

                LOG.debug("Connection " + getRemoteAddress() + " taking over previous connection: "

                        + state.getConnection().getRemoteAddress());

                state.setConnection(this);

                state.reset(info);

            }

        }

        registerConnectionState(info.getConnectionId(), state);

        LOG.debug("Setting up new connection id: " + info.getConnectionId() + ", address: " + getRemoteAddress() + ", info: " + info);

        this.faultTolerantConnection = info.isFaultTolerant();

        // Setup the context.

        String clientId = info.getClientId();

        context = new ConnectionContext();

        context.setBroker(broker);

        context.setClientId(clientId);

        context.setClientMaster(info.isClientMaster());

        context.setConnection(this);

        context.setConnectionId(info.getConnectionId());

        context.setConnector(connector);

        context.setMessageAuthorizationPolicy(getMessageAuthorizationPolicy());

        context.setNetworkConnection(networkConnection);

        context.setFaultTolerant(faultTolerantConnection);

        context.setTransactions(new ConcurrentHashMap<TransactionId, Transaction>());

        context.setUserName(info.getUserName());

        context.setWireFormatInfo(wireFormatInfo);

        context.setReconnect(info.isFailoverReconnect());

        this.manageable = info.isManageable();

        context.setConnectionState(state);

        state.setContext(context);

        state.setConnection(this);

        if (info.getClientIp() == null) {

            info.setClientIp(getRemoteAddress());

        }

        try {

            broker.addConnection(context, info);

        } catch (Exception e) {

            synchronized (brokerConnectionStates) {

                brokerConnectionStates.remove(info.getConnectionId());

            }

            unregisterConnectionState(info.getConnectionId());

            LOG.warn("Failed to add Connection " + info.getConnectionId() + ", reason: " + e.toString());

            if (LOG.isDebugEnabled()) {

                LOG.debug("Exception detail:", e);

            }

            if (e instanceof SecurityException) {

                // close this down - in case the peer of this transport doesn't play nice

                delayedStop(2000, "Failed with SecurityException: " + e.getLocalizedMessage(), e);

            }

            throw e;

        }

        if (info.isManageable()) {

            // send ConnectionCommand

            ConnectionControl command = this.connector.getConnectionControl();

            command.setFaultTolerant(broker.isFaultTolerantConfiguration());

            if (info.isFailoverReconnect()) {

                command.setRebalanceConnection(false);

            }

            dispatchAsync(command);

        }

        return null;

    }

    @Override

    public synchronized Response processRemoveConnection(ConnectionId id, long lastDeliveredSequenceId)

            throws InterruptedException {

        LOG.debug("remove connection id: " + id);

        TransportConnectionState cs = lookupConnectionState(id);

        if (cs != null) {

            // Don't allow things to be added to the connection state while we

            // are shutting down.

            cs.shutdown();

            // Cascade the connection stop to the sessions.

            for (SessionId sessionId : cs.getSessionIds()) {

                try {

                    processRemoveSession(sessionId, lastDeliveredSequenceId);

                } catch (Throwable e) {

                    SERVICELOG.warn("Failed to remove session " + sessionId, e);

                }

            }

            // Cascade the connection stop to temp destinations.

            for (Iterator<DestinationInfo> iter = cs.getTempDestinations().iterator(); iter.hasNext(); ) {

                DestinationInfo di = iter.next();

                try {

                    broker.removeDestination(cs.getContext(), di.getDestination(), 0);

                } catch (Throwable e) {

                    SERVICELOG.warn("Failed to remove tmp destination " + di.getDestination(), e);

                }

                iter.remove();

            }

            try {

                broker.removeConnection(cs.getContext(), cs.getInfo(), null);

            } catch (Throwable e) {

                SERVICELOG.warn("Failed to remove connection " + cs.getInfo() + ", reason: " + e.toString());

                if (LOG.isDebugEnabled()) {

                    SERVICELOG.debug("Exception detail:", e);

                }

            }

            TransportConnectionState state = unregisterConnectionState(id);

            if (state != null) {

                synchronized (brokerConnectionStates) {

                    // If we are the last reference, we should remove the state

                    // from the broker.

                    if (state.decrementReference() == 0) {

                        brokerConnectionStates.remove(id);

                    }

                }

            }

        }

        return null;

    }

    @Override

    public Response processProducerAck(ProducerAck ack) throws Exception {

        // A broker should not get ProducerAck messages.

        return null;

    }

    @Override

    public Connector getConnector() {

        return connector;

    }

    @Override

    public void dispatchSync(Command message) {

        try {

            processDispatch(message);

        } catch (IOException e) {

            serviceExceptionAsync(e);

        }

    }

    @Override

    public void dispatchAsync(Command message) {

        if (!stopping.get()) {

            if (taskRunner == null) {

                dispatchSync(message);

            } else {

                synchronized (dispatchQueue) {

                    dispatchQueue.add(message);

                }

                try {

                    taskRunner.wakeup();

                } catch (InterruptedException e) {

                    Thread.currentThread().interrupt();

                }

            }

        } else {

            if (message.isMessageDispatch()) {

                MessageDispatch md = (MessageDispatch) message;

                TransmitCallback sub = md.getTransmitCallback();

                broker.postProcessDispatch(md);

                if (sub != null) {

                    sub.onFailure();

                }

            }

        }

    }

    protected void processDispatch(Command command) throws IOException {

        MessageDispatch messageDispatch = (MessageDispatch) (command.isMessageDispatch() ? command : null);

        try {

            if (!stopping.get()) {

                if (messageDispatch != null) {

                    broker.preProcessDispatch(messageDispatch);

                }

                dispatch(command);

            }

        } catch (IOException e) {

            if (messageDispatch != null) {

                TransmitCallback sub = messageDispatch.getTransmitCallback();

                broker.postProcessDispatch(messageDispatch);

                if (sub != null) {

                    sub.onFailure();

                }

                messageDispatch = null;

                throw e;

            }

        } finally {

            if (messageDispatch != null) {

                TransmitCallback sub = messageDispatch.getTransmitCallback();

                broker.postProcessDispatch(messageDispatch);

                if (sub != null) {

                    sub.onSuccess();

                }

            }

        }

    }

    @Override

    public boolean iterate() {

        try {

            if (pendingStop || stopping.get()) {

                if (dispatchStopped.compareAndSet(false, true)) {

                    if (transportException.get() == null) {

                        try {

                            dispatch(new ShutdownInfo());

                        } catch (Throwable ignore) {

                        }

                    }

                    dispatchStoppedLatch.countDown();

                }

                return false;

            }

            if (!dispatchStopped.get()) {

                Command command = null;

                synchronized (dispatchQueue) {

                    if (dispatchQueue.isEmpty()) {

                        return false;

                    }

                    command = dispatchQueue.remove(0);

                }

                processDispatch(command);

                return true;

            }

            return false;

        } catch (IOException e) {

            if (dispatchStopped.compareAndSet(false, true)) {

                dispatchStoppedLatch.countDown();

            }

            serviceExceptionAsync(e);

            return false;

        }

    }

    /**

     * Returns the statistics for this connection

     */

    @Override

    public ConnectionStatistics getStatistics() {

        return statistics;

    }

    public MessageAuthorizationPolicy getMessageAuthorizationPolicy() {

        return messageAuthorizationPolicy;

    }

    public void setMessageAuthorizationPolicy(MessageAuthorizationPolicy messageAuthorizationPolicy) {

        this.messageAuthorizationPolicy = messageAuthorizationPolicy;

    }

    @Override

    public boolean isManageable() {

        return manageable;

    }

    @Override

    public void start() throws Exception {

        try {

            synchronized (this) {

                starting = true;

                if (taskRunnerFactory != null) {

                    taskRunner = taskRunnerFactory.createTaskRunner(this, "ActiveMQ Connection Dispatcher: "

                            + getRemoteAddress());

                } else {

                    taskRunner = null;

                }

                transport.start();

                active = true;

                BrokerInfo info = connector.getBrokerInfo().copy();

                if (connector.isUpdateClusterClients()) {

                    info.setPeerBrokerInfos(this.broker.getPeerBrokerInfos());

                } else {

                    info.setPeerBrokerInfos(null);

                }

                dispatchAsync(info);

                connector.onStarted(this);

            }

        } catch (Exception e) {

            // Force clean up on an error starting up.

            pendingStop = true;

            throw e;

        } finally {

            // stop() can be called from within the above block,

            // but we want to be sure start() completes before

            // stop() runs, so queue the stop until right now:

            setStarting(false);

            if (isPendingStop()) {

                LOG.debug("Calling the delayed stop() after start() " + this);

                stop();

            }

        }

    }

    @Override

    public void stop() throws Exception {

        // do not stop task the task runner factories (taskRunnerFactory, stopTaskRunnerFactory)

        // as their lifecycle is handled elsewhere

        stopAsync();

        while (!stopped.await(5, TimeUnit.SECONDS)) {

            LOG.info("The connection to '" + transport.getRemoteAddress() + "' is taking a long time to shutdown.");

        }

    }

    public void delayedStop(final int waitTime, final String reason, Throwable cause) {

        if (waitTime > 0) {

            synchronized (this) {

                pendingStop = true;

                stopError = cause;

            }

            try {

                stopTaskRunnerFactory.execute(new Runnable() {

                    @Override

                    public void run() {

                        try {

                            Thread.sleep(waitTime);

                            stopAsync();

                            LOG.info("Stopping " + transport.getRemoteAddress() + " because " + reason);

                        } catch (InterruptedException e) {

                        }

                    }

                });

            } catch (Throwable t) {

                LOG.warn("Cannot create stopAsync. This exception will be ignored.", t);

            }

        }

    }

    public void stopAsync() {

        // If we're in the middle of starting then go no further... for now.

        synchronized (this) {

            pendingStop = true;

            if (starting) {

                LOG.debug("stopAsync() called in the middle of start(). Delaying till start completes..");

                return;

            }

        }

        if (stopping.compareAndSet(false, true)) {

            // Let all the connection contexts know we are shutting down

            // so that in progress operations can notice and unblock.

            List<TransportConnectionState> connectionStates = listConnectionStates();

            for (TransportConnectionState cs : connectionStates) {

                ConnectionContext connectionContext = cs.getContext();

                if (connectionContext != null) {

                    connectionContext.getStopping().set(true);

                }

            }

            try {

                stopTaskRunnerFactory.execute(new Runnable() {

                    @Override

                    public void run() {

                        serviceLock.writeLock().lock();

                        try {

                            doStop();

                        } catch (Throwable e) {

                            LOG.debug("Error occurred while shutting down a connection " + this, e);

                        } finally {

                            stopped.countDown();

                            serviceLock.writeLock().unlock();

                        }

                    }

                });

            } catch (Throwable t) {

                LOG.warn("Cannot create async transport stopper thread. This exception is ignored. Not waiting for stop to complete", t);

                stopped.countDown();

            }

        }

    }

    @Override

    public String toString() {

        return "Transport Connection to: " + transport.getRemoteAddress();

    }

    protected void doStop() throws Exception {

        LOG.debug("Stopping connection: {}", transport.getRemoteAddress());

        connector.onStopped(this);

        try {

            synchronized (this) {

                if (duplexBridge != null) {

                    duplexBridge.stop();

                }

            }

        } catch (Exception ignore) {

            LOG.trace("Exception caught stopping. This exception is ignored.", ignore);

        }

        try {

            transport.stop();

            LOG.debug("Stopped transport: " + transport.getRemoteAddress());

        } catch (Exception e) {

            LOG.debug("Could not stop transport to " + transport.getRemoteAddress() + ". This exception is ignored.", e);

        }

        if (taskRunner != null) {

            taskRunner.shutdown(1);

            taskRunner = null;

        }

        active = false;

        // Run the MessageDispatch callbacks so that message references get

        // cleaned up.

        synchronized (dispatchQueue) {

            for (Iterator<Command> iter = dispatchQueue.iterator(); iter.hasNext(); ) {

                Command command = iter.next();

                if (command.isMessageDispatch()) {

                    MessageDispatch md = (MessageDispatch) command;

                    TransmitCallback sub = md.getTransmitCallback();

                    broker.postProcessDispatch(md);

                    if (sub != null) {

                        sub.onFailure();

                    }

                }

            }

            dispatchQueue.clear();

        }

        //

        // Remove all logical connection associated with this connection

        // from the broker.

        if (!broker.isStopped()) {

            List<TransportConnectionState> connectionStates = listConnectionStates();

            connectionStates = listConnectionStates();

            for (TransportConnectionState cs : connectionStates) {

                cs.getContext().getStopping().set(true);

                try {

                    LOG.debug("Cleaning up connection resources: {}", getRemoteAddress());

                    processRemoveConnection(cs.getInfo().getConnectionId(), 0l);

                } catch (Throwable ignore) {

                    ignore.printStackTrace();

                }

            }

        }

        LOG.debug("Connection Stopped: {}", getRemoteAddress());

    }

    /**

     * @return Returns the blockedCandidate.

     */

    public boolean isBlockedCandidate() {

        return blockedCandidate;

    }

    /**

     * @param blockedCandidate The blockedCandidate to set.

     */

    public void setBlockedCandidate(boolean blockedCandidate) {

        this.blockedCandidate = blockedCandidate;

    }

    /**

     * @return Returns the markedCandidate.