/*
* Copyright (c) 2005-2014, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. 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.
*/
package org.apache.axis2.transport.rabbitmq.rpc;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.ShutdownSignalException;
import org.apache.axiom.om.OMOutputFormat;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.transport.MessageFormatter;
import org.apache.axis2.transport.base.BaseUtils;
import org.apache.axis2.transport.rabbitmq.RabbitMQConnectionFactory;
import org.apache.axis2.transport.rabbitmq.RabbitMQMessage;
import org.apache.axis2.transport.rabbitmq.utils.AxisRabbitMQException;
import org.apache.axis2.transport.rabbitmq.utils.RabbitMQConstants;
import org.apache.axis2.transport.rabbitmq.utils.RabbitMQUtils;
import org.apache.axis2.util.MessageProcessorSelector;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.Hashtable;
import java.util.Map;
import java.util.UUID;
/**
* Class that performs the actual sending of a RabbitMQ AMQP message,
*/
public class RabbitMQRPCMessageSender {
private static final Log log = LogFactory.getLog(RabbitMQRPCMessageSender.class);
private DualChannel dualChannel = null;
private String targetEPR = null;
private Hashtable<String, String> epProperties;
private RabbitMQConnectionFactory connectionFactory;
/**
* Create a RabbitMQSender using a ConnectionFactory and target EPR
*
* @param connectionFactory the RabbitMQ connection factory
* @param targetEPR the targetAddress
* @param epProperties
*/
//TODO : cache connection factories with targetEPR string. should include queue autodeclare properties etc..
public RabbitMQRPCMessageSender(RabbitMQConnectionFactory connectionFactory, String targetEPR, Hashtable<String, String> epProperties) {
this.targetEPR = targetEPR;
this.connectionFactory = connectionFactory;
try {
dualChannel = connectionFactory.getRPCChannel();
} catch (InterruptedException e) {
handleException("Error while getting RPC channel", e);
}
if (!this.targetEPR.startsWith(RabbitMQConstants.RABBITMQ_PREFIX)) {
handleException("Invalid prefix for a AMQP EPR : " + targetEPR);
} else {
this.epProperties = epProperties;
}
}
public RabbitMQMessage send(RabbitMQMessage message, MessageContext msgContext) throws
AxisRabbitMQException, IOException {
publish(message, msgContext);
RabbitMQMessage responseMessage = processResponse(message.getCorrelationId());
//release the dual channel to the pool
try {
connectionFactory.pushRPCChannel(dualChannel);
} catch (InterruptedException e) {
handleException(e.getMessage());
}
return responseMessage;
}
/**
* Perform the creation of exchange/queue and the Outputstream
*
* @param message the RabbitMQ AMQP message
* @param msgContext the Axis2 MessageContext
*/
private void publish(RabbitMQMessage message, MessageContext msgContext) throws
AxisRabbitMQException, IOException {
String exchangeName = null;
AMQP.BasicProperties basicProperties = null;
byte[] messageBody = null;
if (dualChannel.isOpen()) {
String queueName = epProperties.get(RabbitMQConstants.QUEUE_NAME);
String routeKey = epProperties
.get(RabbitMQConstants.QUEUE_ROUTING_KEY);
exchangeName = epProperties.get(RabbitMQConstants.EXCHANGE_NAME);
String exchangeType = epProperties
.get(RabbitMQConstants.EXCHANGE_TYPE);
String correlationID = epProperties.get(RabbitMQConstants.CORRELATION_ID);
String replyTo = dualChannel.getReplyToQueue();
String queueAutoDeclareStr = epProperties.get(RabbitMQConstants.QUEUE_AUTODECLARE);
String exchangeAutoDeclareStr = epProperties.get(RabbitMQConstants.EXCHANGE_AUTODECLARE);
boolean queueAutoDeclare = true;
boolean exchangeAutoDeclare = true;
if (!StringUtils.isEmpty(queueAutoDeclareStr)) {
queueAutoDeclare = Boolean.parseBoolean(queueAutoDeclareStr);
}
if (!StringUtils.isEmpty(exchangeAutoDeclareStr)) {
exchangeAutoDeclare = Boolean.parseBoolean(exchangeAutoDeclareStr);
}
message.setReplyTo(replyTo);
if ((!StringUtils.isEmpty(replyTo)) && (StringUtils.isEmpty(correlationID))) {
//if reply-to is enabled a correlationID must be available. If not specified, use messageID
correlationID = message.getMessageId();
}
if (!StringUtils.isEmpty(correlationID)) {
message.setCorrelationId(correlationID);
}
if (queueName == null || queueName.equals("")) {
log.info("No queue name is specified");
}
if (routeKey == null && !"x-consistent-hash".equals(exchangeType)) {
if (queueName == null || queueName.equals("")) {
log.info("Routing key is not specified");
} else {
log.info(
"Routing key is not specified. Using queue name as the routing key.");
routeKey = queueName;
}
}
//Declaring the queue
if (queueAutoDeclare && queueName != null && !queueName.equals("")) {
//get channel with dualChannel.getChannel() since it will create a new channel if channel is closed
RabbitMQUtils.declareQueue(dualChannel, queueName, epProperties);
}
//Declaring the exchange
if (exchangeAutoDeclare && exchangeName != null && !exchangeName.equals("")) {
RabbitMQUtils.declareExchange(dualChannel, exchangeName, epProperties);
if (queueName != null && !"x-consistent-hash".equals(exchangeType)) {
// Create bind between the queue and exchange with the routeKey
try {
dualChannel.getChannel().queueBind(queueName, exchangeName, routeKey);
} catch (IOException e) {
handleException(
"Error occurred while creating the bind between the queue: "
+ queueName + " & exchange: " + exchangeName + " with route-key " + routeKey, e);
}
}
}
//build basic properties from message
AMQP.BasicProperties.Builder builder = buildBasicProperties(message);
String deliveryModeString = epProperties
.get(RabbitMQConstants.QUEUE_DELIVERY_MODE);
int deliveryMode = RabbitMQConstants.DEFAULT_DELIVERY_MODE;
if (deliveryModeString != null) {
deliveryMode = Integer.parseInt(deliveryModeString);
}
//TODO : override properties from message with ones from transport properties
//set builder properties from transport properties (overrides current properties)
builder.deliveryMode(deliveryMode);
builder.replyTo(replyTo);
basicProperties = builder.build();
OMOutputFormat format = BaseUtils.getOMOutputFormat(msgContext);
MessageFormatter messageFormatter = null;
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
messageFormatter = MessageProcessorSelector.getMessageFormatter(msgContext);
} catch (AxisFault axisFault) {
throw new AxisRabbitMQException(
"Unable to get the message formatter to use",
axisFault);
}
//server plugging should be enabled before using x-consistent hashing
//for x-consistent-hashing only exchangeName, exchangeType and routingKey should be
// given. Queue/exchange creation, bindings should be done at the broker
try {
// generate random value as routeKey if the exchangeType is
// x-consistent-hash type
if (exchangeType != null
&& exchangeType.equals("x-consistent-hash")) {
routeKey = UUID.randomUUID().toString();
}
} catch (UnsupportedCharsetException ex) {
handleException(
"Unsupported encoding "
+ format.getCharSetEncoding(), ex);
}
try {
messageFormatter.writeTo(msgContext, format, out, false);
messageBody = out.toByteArray();
} catch (IOException e) {
handleException("IO Error while creating BytesMessage", e);
} finally {
if (out != null) {
out.close();
}
}
try {
if (exchangeName != null && exchangeName != "") {
if (log.isDebugEnabled()) {
log.debug("Publishing message to exchange " + exchangeName + " with route key " + routeKey);
}
dualChannel.getChannel().basicPublish(exchangeName, routeKey, basicProperties,
messageBody);
} else {
if (log.isDebugEnabled()) {
log.debug("Publishing message with route key " + routeKey);
}
dualChannel.getChannel().basicPublish("", routeKey, basicProperties,
messageBody);
}
} catch (IOException e) {
handleException("Error while publishing the message", e);
}
} else {
handleException("Channel cannot be created");
}
}
private RabbitMQMessage processResponse(String correlationID) throws IOException {
QueueingConsumer consumer = dualChannel.getConsumer();
QueueingConsumer.Delivery delivery = null;
RabbitMQMessage message = new RabbitMQMessage();
String replyToQueue = dualChannel.getReplyToQueue();
String queueAutoDeclareStr = epProperties.get(RabbitMQConstants.QUEUE_AUTODECLARE);
boolean queueAutoDeclare = true;
if (!StringUtils.isEmpty(queueAutoDeclareStr)) {
queueAutoDeclare = Boolean.parseBoolean(queueAutoDeclareStr);
}
if (queueAutoDeclare && !RabbitMQUtils.isQueueAvailable(dualChannel.getChannel(), replyToQueue)) {
log.info("Reply-to queue : " + replyToQueue + " not available, hence creating a new one");
RabbitMQUtils.declareQueue(dualChannel, replyToQueue, epProperties);
}
int timeout = RabbitMQConstants.DEFAULT_REPLY_TO_TIMEOUT;
String timeoutStr = epProperties.get(RabbitMQConstants.REPLY_TO_TIMEOUT);
if (!StringUtils.isEmpty(timeoutStr)) {
try {
timeout = Integer.parseInt(timeoutStr);
} catch (NumberFormatException e) {
log.warn("Number format error in reading replyto timeout value. Proceeding with default value (30000ms)", e);
}
}
try {
if (log.isDebugEnabled()) {
log.debug("Waiting for delivery from reply to queue " + replyToQueue + " corr id : " + correlationID);
}
delivery = consumer.nextDelivery(timeout);
if (delivery != null) {
if (!StringUtils.isEmpty(delivery.getProperties().getCorrelationId())) {
if (delivery.getProperties().getCorrelationId().equals(correlationID)) {
if(log.isDebugEnabled()) {
log.debug("Found matching response with correlation ID : " + correlationID + ".");
}
} else {
log.error("Response not queued in " + replyToQueue + " for correlation ID : " + correlationID);
return null;
}
}
} else {
log.error("Response not queued in " + replyToQueue);
}
} catch (ShutdownSignalException e) {
log.error("Error receiving message from RabbitMQ broker " + e.getLocalizedMessage());
} catch (InterruptedException e) {
log.error("Error receiving message from RabbitMQ broker " + e.getLocalizedMessage());
} catch (ConsumerCancelledException e) {
log.error("Error receiving message from RabbitMQ broker" + e.getLocalizedMessage());
}
if (delivery != null) {
log.debug("Processing response from reply-to queue");
AMQP.BasicProperties properties = delivery.getProperties();
Map<String, Object> headers = properties.getHeaders();
message.setBody(delivery.getBody());
message.setDeliveryTag(delivery.getEnvelope().getDeliveryTag());
message.setReplyTo(properties.getReplyTo());
message.setMessageId(properties.getMessageId());
//get content type from message
String contentType = properties.getContentType();
if (contentType == null) {
//if not get content type from transport parameter
contentType = epProperties.get(RabbitMQConstants.REPLY_TO_CONTENT_TYPE);
if (contentType == null) {
//if none is given, set to default content type
log.warn("Setting default content type " + RabbitMQConstants.DEFAULT_CONTENT_TYPE);
contentType = RabbitMQConstants.DEFAULT_CONTENT_TYPE;
}
}
message.setContentType(contentType);
message.setContentEncoding(properties.getContentEncoding());
message.setCorrelationId(properties.getCorrelationId());
if (headers != null) {
message.setHeaders(headers);
if (headers.get(RabbitMQConstants.SOAP_ACTION) != null) {
message.setSoapAction(headers.get(
RabbitMQConstants.SOAP_ACTION).toString());
}
}
}
return message;
}
/**
* Build and populate the AMQP.BasicProperties using the RabbitMQMessage
*
* @param message the RabbitMQMessage to be used to get the properties
* @return AMQP.BasicProperties object
*/
private AMQP.BasicProperties.Builder buildBasicProperties(RabbitMQMessage message) {
AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties().builder();
builder.messageId(message.getMessageId());
builder.contentType(message.getContentType());
builder.replyTo(message.getReplyTo());
builder.correlationId(message.getCorrelationId());
builder.contentEncoding(message.getContentEncoding());
Map<String, Object> headers = message.getHeaders();
headers.put(RabbitMQConstants.SOAP_ACTION, message.getSoapAction());
builder.headers(headers);
return builder;
}
private void handleException(String s) {
log.error(s);
throw new AxisRabbitMQException(s);
}
private void handleException(String message, Exception e) {
log.error(message, e);
throw new AxisRabbitMQException(message, e);
}
}