*

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

*

*/

        implements AMQSessionModel<AMQChannel, AMQProtocolEngine>,

                   AsyncAutoCommitTransaction.FutureRecorder,

                   ServerChannelMethodProcessor

    public static final int DEFAULT_PREFETCH = 4096;

    private static final Logger _logger = Logger.getLogger(AMQChannel.class);

    //TODO use Broker property to configure message authorization requirements

    private boolean _messageAuthorizationRequired = Boolean.getBoolean(BrokerProperties.PROPERTY_MSG_AUTH);

    private final int _channelId;

    private final Pre0_10CreditManager _creditManager = new Pre0_10CreditManager(0l,0l);

    /**

     * The delivery tag is unique per channel. This is pre-incremented before putting into the deliver frame so that

     * value of this represents the <b>last</b> tag sent out

     */

    private long _deliveryTag = 0;

    /** A channel has a default queue (the last declared) that is used when no queue name is explicitly set */

    private AMQQueue _defaultQueue;

    /** This tag is unique per subscription to a queue. The server returns this in response to a basic.consume request. */

    private int _consumerTag;

    /**

     * The current message - which may be partial in the sense that not all frames have been received yet - which has

     * been received by this channel. As the frames are received the message gets updated and once all frames have been

     * received the message can then be routed.

     */

    private IncomingMessage _currentMessage;

    /** Maps from consumer tag to subscription instance. Allows us to unsubscribe from a queue. */

    private final Map<AMQShortString, ConsumerTarget_0_8> _tag2SubscriptionTargetMap = new HashMap<AMQShortString, ConsumerTarget_0_8>();

    private final MessageStore _messageStore;

    private final LinkedList<AsyncCommand> _unfinishedCommandsQueue = new LinkedList<AsyncCommand>();

    private UnacknowledgedMessageMap _unacknowledgedMessageMap = new UnacknowledgedMessageMapImpl(DEFAULT_PREFETCH);

    private final AtomicBoolean _suspended = new AtomicBoolean(false);

    private ServerTransaction _transaction;

    private final AtomicLong _txnStarts = new AtomicLong(0);

    private final AtomicLong _txnCommits = new AtomicLong(0);

    private final AtomicLong _txnRejects = new AtomicLong(0);

    private final AtomicLong _txnCount = new AtomicLong(0);

    private final AMQProtocolEngine _connection;

    private AtomicBoolean _closing = new AtomicBoolean(false);

    private final Set<Object> _blockingEntities = Collections.synchronizedSet(new HashSet<Object>());

    private final AtomicBoolean _blocking = new AtomicBoolean(false);

    private LogSubject _logSubject;

    private volatile boolean _rollingBack;

    private static final Runnable NULL_TASK = new Runnable() { public void run() {} };

    private List<MessageInstance> _resendList = new ArrayList<MessageInstance>();

    private static final

    AMQShortString IMMEDIATE_DELIVERY_REPLY_TEXT = new AMQShortString("Immediate delivery is not possible.");

    private long _createTime = System.currentTimeMillis();

    private final ClientDeliveryMethod _clientDeliveryMethod;

    private final TransactionTimeoutHelper _transactionTimeoutHelper;

    private final UUID _id = UUID.randomUUID();

    private final List<Action<? super AMQChannel>> _taskList =

            new CopyOnWriteArrayList<Action<? super AMQChannel>>();

    private final CapacityCheckAction _capacityCheckAction = new CapacityCheckAction();

    private final ImmediateAction _immediateAction = new ImmediateAction();

    private Subject _subject;

    private final CopyOnWriteArrayList<Consumer<?>> _consumers = new CopyOnWriteArrayList<Consumer<?>>();

    private final ConfigurationChangeListener _consumerClosedListener = new ConsumerClosedListener();

    private final CopyOnWriteArrayList<ConsumerListener> _consumerListeners = new CopyOnWriteArrayList<ConsumerListener>();

    private Session<?> _modelObject;

    private long _blockTime;

    private long _blockingTimeout;

    private boolean _confirmOnPublish;

    private long _confirmedMessageCounter;

    private volatile long _uncommittedMessageSize;

    private final List<StoredMessage<MessageMetaData>> _uncommittedMessages = new ArrayList<>();

    private long _maxUncommittedInMemorySize;

    public AMQChannel(AMQProtocolEngine connection, int channelId, final MessageStore messageStore)

    {

        _connection = connection;

        _channelId = channelId;

        _subject = new Subject(false, connection.getAuthorizedSubject().getPrincipals(),

                               connection.getAuthorizedSubject().getPublicCredentials(),

                               connection.getAuthorizedSubject().getPrivateCredentials());

        _subject.getPrincipals().add(new SessionPrincipal(this));

        _maxUncommittedInMemorySize = connection.getVirtualHost().getContextValue(Long.class, Connection.MAX_UNCOMMITTED_IN_MEMORY_SIZE);

        _logSubject = new ChannelLogSubject(this);

        _messageStore = messageStore;

        _blockingTimeout = connection.getBroker().getContextValue(Long.class,

                                                                  Broker.CHANNEL_FLOW_CONTROL_ENFORCEMENT_TIMEOUT);

        // by default the session is non-transactional

        _transaction = new AsyncAutoCommitTransaction(_messageStore, this);

        _clientDeliveryMethod = connection.createDeliveryMethod(_channelId);

        _transactionTimeoutHelper = new TransactionTimeoutHelper(_logSubject, new CloseAction()