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.state.ConnectionState;
032    import org.apache.activemq.transaction.Transaction;
033    
034    /**
035     * Used to hold context information needed to process requests sent to a broker.
036     * 
037     * 
038     */
039    public class ConnectionContext {
040    
041        private Connection connection;
042        private Connector connector;
043        private Broker broker;
044        private boolean inRecoveryMode;
045        private Transaction transaction;
046        private ConcurrentHashMap<TransactionId, Transaction> transactions;
047        private SecurityContext securityContext;
048        private ConnectionId connectionId;
049        private String clientId;
050        private String userName;
051        private boolean reconnect;
052        private WireFormatInfo wireFormatInfo;
053        private Object longTermStoreContext;
054        private boolean producerFlowControl = true;
055        private MessageAuthorizationPolicy messageAuthorizationPolicy;
056        private boolean networkConnection;
057        private boolean faultTolerant;
058        private final AtomicBoolean stopping = new AtomicBoolean();
059        private final MessageEvaluationContext messageEvaluationContext;
060        private boolean dontSendReponse;
061        private boolean clientMaster = true;
062        private ConnectionState connectionState;
063    
064        public ConnectionContext() {
065            this.messageEvaluationContext = new MessageEvaluationContext();
066        }
067        
068        public ConnectionContext(MessageEvaluationContext messageEvaluationContext) {
069            this.messageEvaluationContext=messageEvaluationContext;
070        }
071        
072        public ConnectionContext(ConnectionInfo info) {
073            this();
074            setClientId(info.getClientId());
075            setUserName(info.getUserName());
076            setConnectionId(info.getConnectionId());
077        }
078        
079        public ConnectionContext copy() {
080            ConnectionContext rc = new ConnectionContext(this.messageEvaluationContext);
081            rc.connection = this.connection;
082            rc.connector = this.connector;
083            rc.broker = this.broker;
084            rc.inRecoveryMode = this.inRecoveryMode;
085            rc.transaction = this.transaction;
086            rc.transactions = this.transactions;
087            rc.securityContext = this.securityContext;
088            rc.connectionId = this.connectionId;
089            rc.clientId = this.clientId;
090            rc.userName = this.userName;
091            rc.reconnect = this.reconnect;
092            rc.wireFormatInfo = this.wireFormatInfo;
093            rc.longTermStoreContext = this.longTermStoreContext;
094            rc.producerFlowControl = this.producerFlowControl;
095            rc.messageAuthorizationPolicy = this.messageAuthorizationPolicy;
096            rc.networkConnection = this.networkConnection;
097            rc.faultTolerant = this.faultTolerant;
098            rc.stopping.set(this.stopping.get());
099            rc.dontSendReponse = this.dontSendReponse;
100            rc.clientMaster = this.clientMaster;
101            return rc;
102        }
103    
104    
105        public SecurityContext getSecurityContext() {
106            return securityContext;
107        }
108    
109        public void setSecurityContext(SecurityContext subject) {
110            this.securityContext = subject;
111            if (subject != null) {
112                setUserName(subject.getUserName());
113            } else {
114                setUserName(null);
115            }
116        }
117    
118        /**
119         * @return the broker being used.
120         */
121        public Broker getBroker() {
122            return broker;
123        }
124    
125        /**
126         * @param broker being used
127         */
128        public void setBroker(Broker broker) {
129            this.broker = broker;
130        }
131    
132        /**
133         * @return the connection being used
134         */
135        public Connection getConnection() {
136            return connection;
137        }
138    
139        /**
140         * @param connection being used
141         */
142        public void setConnection(Connection connection) {
143            this.connection = connection;
144        }
145    
146        /**
147         * @return the transaction being used.
148         */
149        public Transaction getTransaction() {
150            return transaction;
151        }
152    
153        /**
154         * @param transaction being used.
155         */
156        public void setTransaction(Transaction transaction) {
157            this.transaction = transaction;
158        }
159    
160        /**
161         * @return the connector being used.
162         */
163        public Connector getConnector() {
164            return connector;
165        }
166    
167        /**
168         * @param connector being used.
169         */
170        public void setConnector(Connector connector) {
171            this.connector = connector;
172        }
173    
174        public MessageAuthorizationPolicy getMessageAuthorizationPolicy() {
175            return messageAuthorizationPolicy;
176        }
177    
178        /**
179         * Sets the policy used to decide if the current connection is authorized to
180         * consume a given message
181         */
182        public void setMessageAuthorizationPolicy(MessageAuthorizationPolicy messageAuthorizationPolicy) {
183            this.messageAuthorizationPolicy = messageAuthorizationPolicy;
184        }
185    
186        /**
187         * @return
188         */
189        public boolean isInRecoveryMode() {
190            return inRecoveryMode;
191        }
192    
193        public void setInRecoveryMode(boolean inRecoveryMode) {
194            this.inRecoveryMode = inRecoveryMode;
195        }
196    
197        public ConcurrentHashMap<TransactionId, Transaction> getTransactions() {
198            return transactions;
199        }
200    
201        public void setTransactions(ConcurrentHashMap<TransactionId, Transaction> transactions) {
202            this.transactions = transactions;
203        }
204    
205        public boolean isInTransaction() {
206            return transaction != null;
207        }
208    
209        public String getClientId() {
210            return clientId;
211        }
212    
213        public void setClientId(String clientId) {
214            this.clientId = clientId;
215        }
216    
217        public boolean isReconnect() {
218            return reconnect;
219        }
220    
221        public void setReconnect(boolean reconnect) {
222            this.reconnect = reconnect;
223        }
224    
225        public WireFormatInfo getWireFormatInfo() {
226            return wireFormatInfo;
227        }
228    
229        public void setWireFormatInfo(WireFormatInfo wireFormatInfo) {
230            this.wireFormatInfo = wireFormatInfo;
231        }
232    
233        public ConnectionId getConnectionId() {
234            return connectionId;
235        }
236    
237        public void setConnectionId(ConnectionId connectionId) {
238            this.connectionId = connectionId;
239        }
240    
241        public String getUserName() {
242            return userName;
243        }
244    
245        protected void setUserName(String userName) {
246            this.userName = userName;
247        }
248    
249        public MessageEvaluationContext getMessageEvaluationContext() {
250            return messageEvaluationContext;
251        }
252    
253        public Object getLongTermStoreContext() {
254            return longTermStoreContext;
255        }
256    
257        public void setLongTermStoreContext(Object longTermStoreContext) {
258            this.longTermStoreContext = longTermStoreContext;
259        }
260    
261        public boolean isProducerFlowControl() {
262            return producerFlowControl;
263        }
264    
265        public void setProducerFlowControl(boolean disableProducerFlowControl) {
266            this.producerFlowControl = disableProducerFlowControl;
267        }
268    
269        public boolean isAllowedToConsume(MessageReference n) throws IOException {
270            if (messageAuthorizationPolicy != null) {
271                return messageAuthorizationPolicy.isAllowedToConsume(this, n.getMessage());
272            }
273            return true;
274        }
275    
276        public synchronized boolean isNetworkConnection() {
277            return networkConnection;
278        }
279    
280        public synchronized void setNetworkConnection(boolean networkConnection) {
281            this.networkConnection = networkConnection;
282        }
283    
284        public AtomicBoolean getStopping() {
285            return stopping;
286        }
287    
288        public void setDontSendReponse(boolean b) {
289            this.dontSendReponse = b;
290        }
291    
292        public boolean isDontSendReponse() {
293            return dontSendReponse;
294        }
295    
296        /**
297         * @return the slave
298         */
299        public boolean isSlave() {
300            return (this.broker != null && this.broker.getBrokerService().isSlave()) || !this.clientMaster;
301        }
302    
303        /**
304         * @return the clientMaster
305         */
306        public boolean isClientMaster() {
307            return this.clientMaster;
308        }
309    
310        /**
311         * @param clientMaster the clientMaster to set
312         */
313        public void setClientMaster(boolean clientMaster) {
314            this.clientMaster = clientMaster;
315        }
316    
317        public boolean isFaultTolerant() {
318            return faultTolerant;
319        }
320    
321        public void setFaultTolerant(boolean faultTolerant) {
322            this.faultTolerant = faultTolerant;
323        }
324    
325        public void setConnectionState(ConnectionState connectionState) {
326            this.connectionState = connectionState;
327        }
328    
329        public ConnectionState getConnectionState() {
330            return this.connectionState;
331        }
332    }