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