001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.activemq.broker;
018    
019    import java.io.IOException;
020    import java.util.concurrent.ConcurrentHashMap;
021    import java.util.concurrent.atomic.AtomicBoolean;
022    
023    import org.apache.activemq.broker.region.MessageReference;
024    import org.apache.activemq.command.ConnectionId;
025    import org.apache.activemq.command.ConnectionInfo;
026    import org.apache.activemq.command.TransactionId;
027    import org.apache.activemq.command.WireFormatInfo;
028    import org.apache.activemq.filter.MessageEvaluationContext;
029    import org.apache.activemq.security.MessageAuthorizationPolicy;
030    import org.apache.activemq.security.SecurityContext;
031    import org.apache.activemq.transaction.Transaction;
032    
033    /**
034     * Used to hold context information needed to process requests sent to a broker.
035     * 
036     * 
037     */
038    public class ConnectionContext {
039    
040        private Connection connection;
041        private Connector connector;
042        private Broker broker;
043        private boolean inRecoveryMode;
044        private Transaction transaction;
045        private ConcurrentHashMap<TransactionId, Transaction> transactions;
046        private SecurityContext securityContext;
047        private ConnectionId connectionId;
048        private String clientId;
049        private String userName;
050        private boolean reconnect;
051        private WireFormatInfo wireFormatInfo;
052        private Object longTermStoreContext;
053        private boolean producerFlowControl = true;
054        private MessageAuthorizationPolicy messageAuthorizationPolicy;
055        private boolean networkConnection;
056        private boolean faultTolerant;
057        private final AtomicBoolean stopping = new AtomicBoolean();
058        private final MessageEvaluationContext messageEvaluationContext;
059        private boolean dontSendReponse;
060        private boolean clientMaster = true;
061    
062        public ConnectionContext() {
063            this.messageEvaluationContext = new MessageEvaluationContext();
064        }
065        
066        public ConnectionContext(MessageEvaluationContext messageEvaluationContext) {
067            this.messageEvaluationContext=messageEvaluationContext;
068        }
069        
070        public ConnectionContext(ConnectionInfo info) {
071            this();
072            setClientId(info.getClientId());
073            setUserName(info.getUserName());
074            setConnectionId(info.getConnectionId());
075        }
076        
077        public ConnectionContext copy() {
078            ConnectionContext rc = new ConnectionContext(this.messageEvaluationContext);
079            rc.connection = this.connection;
080            rc.connector = this.connector;
081            rc.broker = this.broker;
082            rc.inRecoveryMode = this.inRecoveryMode;
083            rc.transaction = this.transaction;
084            rc.transactions = this.transactions;
085            rc.securityContext = this.securityContext;
086            rc.connectionId = this.connectionId;
087            rc.clientId = this.clientId;
088            rc.userName = this.userName;
089            rc.reconnect = this.reconnect;
090            rc.wireFormatInfo = this.wireFormatInfo;
091            rc.longTermStoreContext = this.longTermStoreContext;
092            rc.producerFlowControl = this.producerFlowControl;
093            rc.messageAuthorizationPolicy = this.messageAuthorizationPolicy;
094            rc.networkConnection = this.networkConnection;
095            rc.faultTolerant = this.faultTolerant;
096            rc.stopping.set(this.stopping.get());
097            rc.dontSendReponse = this.dontSendReponse;
098            rc.clientMaster = this.clientMaster;
099            return rc;
100        }
101    
102    
103        public SecurityContext getSecurityContext() {
104            return securityContext;
105        }
106    
107        public void setSecurityContext(SecurityContext subject) {
108            this.securityContext = subject;
109            if (subject != null) {
110                setUserName(subject.getUserName());
111            } else {
112                setUserName(null);
113            }
114        }
115    
116        /**
117         * @return the broker being used.
118         */
119        public Broker getBroker() {
120            return broker;
121        }
122    
123        /**
124         * @param broker being used
125         */
126        public void setBroker(Broker broker) {
127            this.broker = broker;
128        }
129    
130        /**
131         * @return the connection being used
132         */
133        public Connection getConnection() {
134            return connection;
135        }
136    
137        /**
138         * @param connection being used
139         */
140        public void setConnection(Connection connection) {
141            this.connection = connection;
142        }
143    
144        /**
145         * @return the transaction being used.
146         */
147        public Transaction getTransaction() {
148            return transaction;
149        }
150    
151        /**
152         * @param transaction being used.
153         */
154        public void setTransaction(Transaction transaction) {
155            this.transaction = transaction;
156        }
157    
158        /**
159         * @return the connector being used.
160         */
161        public Connector getConnector() {
162            return connector;
163        }
164    
165        /**
166         * @param connector being used.
167         */
168        public void setConnector(Connector connector) {
169            this.connector = connector;
170        }
171    
172        public MessageAuthorizationPolicy getMessageAuthorizationPolicy() {
173            return messageAuthorizationPolicy;
174        }
175    
176        /**
177         * Sets the policy used to decide if the current connection is authorized to
178         * consume a given message
179         */
180        public void setMessageAuthorizationPolicy(MessageAuthorizationPolicy messageAuthorizationPolicy) {
181            this.messageAuthorizationPolicy = messageAuthorizationPolicy;
182        }
183    
184        /**
185         * @return
186         */
187        public boolean isInRecoveryMode() {
188            return inRecoveryMode;
189        }
190    
191        public void setInRecoveryMode(boolean inRecoveryMode) {
192            this.inRecoveryMode = inRecoveryMode;
193        }
194    
195        public ConcurrentHashMap<TransactionId, Transaction> getTransactions() {
196            return transactions;
197        }
198    
199        public void setTransactions(ConcurrentHashMap<TransactionId, Transaction> transactions) {
200            this.transactions = transactions;
201        }
202    
203        public boolean isInTransaction() {
204            return transaction != null;
205        }
206    
207        public String getClientId() {
208            return clientId;
209        }
210    
211        public void setClientId(String clientId) {
212            this.clientId = clientId;
213        }
214    
215        public boolean isReconnect() {
216            return reconnect;
217        }
218    
219        public void setReconnect(boolean reconnect) {
220            this.reconnect = reconnect;
221        }
222    
223        public WireFormatInfo getWireFormatInfo() {
224            return wireFormatInfo;
225        }
226    
227        public void setWireFormatInfo(WireFormatInfo wireFormatInfo) {
228            this.wireFormatInfo = wireFormatInfo;
229        }
230    
231        public ConnectionId getConnectionId() {
232            return connectionId;
233        }
234    
235        public void setConnectionId(ConnectionId connectionId) {
236            this.connectionId = connectionId;
237        }
238    
239        public String getUserName() {
240            return userName;
241        }
242    
243        protected void setUserName(String userName) {
244            this.userName = userName;
245        }
246    
247        public MessageEvaluationContext getMessageEvaluationContext() {
248            return messageEvaluationContext;
249        }
250    
251        public Object getLongTermStoreContext() {
252            return longTermStoreContext;
253        }
254    
255        public void setLongTermStoreContext(Object longTermStoreContext) {
256            this.longTermStoreContext = longTermStoreContext;
257        }
258    
259        public boolean isProducerFlowControl() {
260            return producerFlowControl;
261        }
262    
263        public void setProducerFlowControl(boolean disableProducerFlowControl) {
264            this.producerFlowControl = disableProducerFlowControl;
265        }
266    
267        public boolean isAllowedToConsume(MessageReference n) throws IOException {
268            if (messageAuthorizationPolicy != null) {
269                return messageAuthorizationPolicy.isAllowedToConsume(this, n.getMessage());
270            }
271            return true;
272        }
273    
274        public synchronized boolean isNetworkConnection() {
275            return networkConnection;
276        }
277    
278        public synchronized void setNetworkConnection(boolean networkConnection) {
279            this.networkConnection = networkConnection;
280        }
281    
282        public AtomicBoolean getStopping() {
283            return stopping;
284        }
285    
286        public void setDontSendReponse(boolean b) {
287            this.dontSendReponse = b;
288        }
289    
290        public boolean isDontSendReponse() {
291            return dontSendReponse;
292        }
293    
294        /**
295         * @return the slave
296         */
297        public boolean isSlave() {
298            return (this.broker != null && this.broker.getBrokerService().isSlave()) || !this.clientMaster;
299        }
300    
301        /**
302         * @return the clientMaster
303         */
304        public boolean isClientMaster() {
305            return this.clientMaster;
306        }
307    
308        /**
309         * @param clientMaster the clientMaster to set
310         */
311        public void setClientMaster(boolean clientMaster) {
312            this.clientMaster = clientMaster;
313        }
314    
315        public boolean isFaultTolerant() {
316            return faultTolerant;
317        }
318    
319        public void setFaultTolerant(boolean faultTolerant) {
320            this.faultTolerant = faultTolerant;
321        }
322    
323    }