/**
* Copyright (c) 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.synapse.message.store.impl.jdbc;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.MessageContext;
import org.apache.synapse.SynapseException;
import org.apache.synapse.config.SynapseConfiguration;
import org.apache.synapse.core.SynapseEnvironment;
import org.apache.synapse.core.axis2.Axis2MessageContext;
import org.apache.synapse.core.axis2.Axis2SynapseEnvironment;
import org.apache.synapse.message.MessageConsumer;
import org.apache.synapse.message.MessageProducer;
import org.apache.synapse.message.store.AbstractMessageStore;
import org.apache.synapse.message.store.impl.commons.MessageConverter;
import org.apache.synapse.message.store.impl.commons.StorableMessage;
import org.apache.synapse.message.store.impl.jdbc.util.JDBCConfiguration;
import org.apache.synapse.message.store.impl.jdbc.util.Statement;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
/**
* JDBC Store class
*/
public class JDBCMessageStore extends AbstractMessageStore {
/**
* Message Utility class used to provide utilities to do processing
*/
private JDBCConfiguration jdbcConfiguration;
/**
* Logger for the class
*/
private static final Log logger = LogFactory.getLog(JDBCMessageStore.class.getName());
/**
* Locks for clearing the store
*/
private final ReentrantLock removeLock = new ReentrantLock();
private final ReentrantLock cleanUpOfferLock = new ReentrantLock();
private final AtomicBoolean cleaningFlag = new AtomicBoolean(false);
/**
* Initializes the JDBC Message Store
*
* @param synapseEnvironment SynapseEnvironment for the store
*/
@Override
public void init(SynapseEnvironment synapseEnvironment) {
if (logger.isDebugEnabled()) {
logger.debug("Initializing JDBC Message Store");
}
super.init(synapseEnvironment);
if (logger.isDebugEnabled()) {
logger.debug("Initializing Datasource and Properties");
}
jdbcConfiguration = new JDBCConfiguration();
jdbcConfiguration.buildDataSource(parameters);
// JDBCMessageConverter.setSynapseEnvironment(synapseEnvironment);
}
/**
* @see org.apache.synapse.message.store.MessageStore#getProducer()
*/
@Override
public MessageProducer getProducer() {
JDBCProducer producer = new JDBCProducer(this);
producer.setId(nextProducerId());
if (logger.isDebugEnabled()) {
logger.debug(getNameString() + " created a new JDBC Message Producer.");
}
return producer;
}
/**
* @see org.apache.synapse.message.store.MessageStore#getConsumer()
*/
@Override
public MessageConsumer getConsumer() {
JDBCConsumer consumer = new JDBCConsumer(this);
consumer.setId(nextConsumerId());
if (logger.isDebugEnabled()) {
logger.debug(getNameString() + " created a new JDBC Message Consumer.");
}
return consumer;
}
/**
* Set JDBC store parameters
*
* @param parameters - List of parameters to set
*/
@Override
public void setParameters(Map<String, Object> parameters) {
super.setParameters(parameters);
// Rebuild utils after setting new parameters
if (jdbcConfiguration != null) {
jdbcConfiguration.buildDataSource(parameters);
}
}
/**
* Process a given Statement object
*
* @param stmt - Statement to process
* @return - Results as a List of MessageContexts
*/
private MessageContext processResultingStatement(Statement stmt) throws SynapseException {
MessageContext resultMsg = null;
// Execute the prepared statement, and return list of messages as an ArrayList
Connection con = null;
ResultSet rs = null;
PreparedStatement ps = null;
try {
con = jdbcConfiguration.getConnection();
ps = con.prepareStatement(stmt.getRawStatement());
int index = 1;
for (Object param : stmt.getParameters()) {
if (param instanceof String) {
ps.setString(index, (String) param);
} else if (param instanceof Integer) {
ps.setInt(index, (Integer) param);
}
index++;
}
rs = ps.executeQuery();
while (rs.next()) {
byte[] msgObj;
try {
msgObj = rs.getBytes("message");
} catch (SQLException e) {
throw new SynapseException("Error executing statement : " + stmt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), e);
}
if (msgObj != null) {
ObjectInputStream ios = null;
try {
// Convert back to MessageContext and add to list
ios = new ObjectInputStream(new ByteArrayInputStream(msgObj));
Object msg = ios.readObject();
if (msg instanceof StorableMessage) {
StorableMessage jdbcMsg = (StorableMessage) msg;
org.apache.axis2.context.MessageContext axis2Mc = this.newAxis2Mc();
MessageContext synapseMc = this.newSynapseMc(axis2Mc);
resultMsg = MessageConverter.toMessageContext(jdbcMsg, axis2Mc, synapseMc);
}
} catch (Exception e) {
throw new SynapseException("Error reading object input stream", e);
} finally {
try {
ios.close();
} catch (IOException e) {
logger.error("Error while closing object input stream", e);
}
}
} else {
throw new SynapseException("Retrieved Object is null");
}
}
} catch (SQLException e) {
throw new SynapseException("Processing Statement failed : " + stmt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), e);
} finally {
close(con, ps, rs);
}
return resultMsg;
}
private org.apache.axis2.context.MessageContext newAxis2Mc() {
return ((Axis2SynapseEnvironment) synapseEnvironment)
.getAxis2ConfigurationContext().createMessageContext();
}
private org.apache.synapse.MessageContext newSynapseMc(
org.apache.axis2.context.MessageContext msgCtx) {
SynapseConfiguration configuration = synapseEnvironment.getSynapseConfiguration();
return new Axis2MessageContext(msgCtx, configuration, synapseEnvironment);
}
/**
* Process statements that do not give a ResultSet
*
* @param stmnt - Statement to process
* @return - Success or Failure of the process
*/
private boolean processNonResultingStatement(Statement stmnt) throws SynapseException {
Connection con = null;
boolean result = false;
PreparedStatement ps = null;
try {
con = jdbcConfiguration.getConnection();
ps = con.prepareStatement(stmnt.getRawStatement());
int index = 1;
for (Object param : stmnt.getParameters()) {
if (param instanceof String) {
ps.setString(index, (String) param);
} else if (param instanceof StorableMessage) {
//Serialize the object into byteArray and update the statement
ps.setBytes(index, serialize(param));
}
index++;
}
ps.execute();
result = true;
} catch (SQLException e) {
throw new SynapseException("Processing Statement failed : " + stmnt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), e);
} catch(IOException ex) {
throw new SynapseException("Processing Statement failed : " + stmnt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), ex);
}
finally {
if (ps != null) {
try {
ps.close();
} catch (SQLException e) {
logger.error("Error while closing prepared statement", e);
}
}
if (con != null) {
try {
con.close();
} catch (SQLException e) {
logger.error("Error while closing connection", e);
}
}
}
return result;
}
public byte[] serialize(Object obj) throws IOException {
ByteArrayOutputStream b = new ByteArrayOutputStream();
ObjectOutputStream o = new ObjectOutputStream(b);
o.writeObject(obj);
return b.toByteArray();
}
/**
* Destroy Resources allocated
*/
@Override
public void destroy() {
super.destroy();
jdbcConfiguration = null;
}
/**
* Add a message to the end of the table. If fetching success return true else false
*
* @param messageContext message to insert
* @return - success/failure of fetching
*/
public boolean store(MessageContext messageContext) throws SynapseException {
if (messageContext == null) {
logger.error("Message is null, can't store into database");
return false;
}
boolean cleaningState = false;
try {
if (cleaningFlag.get()) {
try {
cleanUpOfferLock.lock();
cleaningState = true;
} catch (Exception e) {
logger.error("Message Cleanup lock released unexpectedly", e);
}
}
StorableMessage persistentMessage =
MessageConverter.toStorableMessage(messageContext);
String msgId = persistentMessage.getAxis2message().getMessageID();
Statement stmt =
new Statement("INSERT INTO " + jdbcConfiguration.getTableName() + " (msg_id,message) VALUES (?,?)");
stmt.addParameter(msgId);
stmt.addParameter(persistentMessage);
return processNonResultingStatement(stmt);
} catch (Exception e) {
throw new SynapseException("Error while creating StorableMessage", e);
} finally {
if (cleaningState) {
cleanUpOfferLock.unlock();
}
}
}
/**
* Select and return the first element in current table
*
* @return - Select and return the first element from the table
*/
public MessageContext peek() throws SynapseException {
Statement stmt =
new Statement("SELECT message FROM " + jdbcConfiguration.getTableName() +
" WHERE indexId=(SELECT min(indexId) from " + jdbcConfiguration.getTableName() + ")");
MessageContext msg = null;
try {
msg = processResultingStatement(stmt);
} catch (SynapseException se) {
throw new SynapseException("Error while peek the message", se);
}
return msg;
}
/**
* Removes the first element from table
*
* @return MessageContext - first message context
* @throws java.util.NoSuchElementException
*/
@Override
public MessageContext remove() throws NoSuchElementException {
MessageContext messageContext = peek();
messageContext = remove(messageContext.getMessageID());
if (messageContext != null) {
return messageContext;
} else {
throw new NoSuchElementException("First element not found and remove failed !");
}
}
/**
* Remove the message with given msg_id
*
* @param msgId - message ID
* @return - removed message context
*/
@Override
public MessageContext remove(String msgId) throws SynapseException {
MessageContext result = null;
boolean cleaningState = false;
try {
if (cleaningFlag.get()) {
try {
removeLock.lock();
cleaningState = true;
} catch (Exception ie) {
logger.error("Message Cleanup lock released unexpectedly", ie);
}
}
result = get(msgId);
Statement stmt = new Statement("DELETE FROM " + jdbcConfiguration.getTableName() + " WHERE msg_id=?");
stmt.addParameter(msgId);
processNonResultingStatement(stmt);
} catch (Exception e) {
throw new SynapseException("Removing message with id = " + msgId + " failed !", e);
} finally {
if (cleaningState) {
removeLock.unlock();
}
}
return result;
}
/**
* Delete all entries from table
*/
@Override
public void clear() {
try {
logger.warn(getNameString() + "deleting all entries");
removeLock.lock();
cleanUpOfferLock.lock();
cleaningFlag.set(true);
Statement stmt = new Statement("DELETE FROM " + jdbcConfiguration.getTableName());
processNonResultingStatement(stmt);
} catch (Exception e) {
logger.error("Clearing store failed !", e);
} finally {
cleaningFlag.set(false);
removeLock.unlock();
cleanUpOfferLock.unlock();
}
}
/**
* Get the message at given position
* Only can be done with MYSQL, and no use-case in current implementation
*
* @param position - position of the message , starting value is 0
* @return Message Context of position th row or if failed return null
*/
@Override
public MessageContext get(int position) {
if (position < 0) {
throw new IllegalArgumentException("Index:" + position + " out of table bound");
}
// Gets the minimum value of the sub-table which contains indexId values greater than given position ('position' has minimum of 0 while indexId has minimum of 1)
Statement stmt = new Statement("SELECT message FROM " + jdbcConfiguration.getTableName() + " ORDER BY indexId ASC LIMIT ?,1 ");
stmt.addParameter(position);
return processResultingStatement(stmt);
}
/**
* Get all messages in the table
*
* @return - List containing all message contexts in the store
*/
@Override
public List<MessageContext> getAll() {
if (logger.isDebugEnabled()) {
logger.debug(getNameString() + " retrieving all messages from the store.");
}
Statement stmt = new Statement("SELECT message FROM " + jdbcConfiguration.getTableName());
MessageContext result = processResultingStatement(stmt);
if (result != null) {
List<MessageContext> msgs = new ArrayList<MessageContext>();
msgs.add(result);
return msgs;
} else {
return null;
}
}
/**
* Return the first element with given msg_id
*
* @param msgId - Message ID
* @return - returns the first result found else null
*/
@Override
public MessageContext get(String msgId) {
Statement stmt = new Statement("SELECT indexId,message FROM " + jdbcConfiguration.getTableName() + " WHERE msg_id=?");
stmt.addParameter(msgId);
return processResultingStatement(stmt);
}
/**
* Return number of messages in the store
*
* @return size - Number of messages
*/
@Override
public int size() {
Connection con = null;
ResultSet rs = null;
PreparedStatement ps = null;
int size = 0;
Statement stmt = new Statement("SELECT COUNT(*) FROM " + jdbcConfiguration.getTableName());
try {
con = jdbcConfiguration.getConnection();
ps = con.prepareStatement(stmt.getRawStatement());
con = ps.getConnection();
rs = ps.executeQuery();
while (rs.next()) {
try {
size = rs.getInt(1);
} catch (Exception e) {
logger.error("Error executing statement : " + stmt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), e);
break;
}
}
} catch (SQLException e) {
logger.error("Error executing statement : " + stmt.getRawStatement() +
" against DataSource : " + jdbcConfiguration.getDSName(), e);
} finally {
close(con, ps, rs);
}
return size;
}
/**
* Get the store's name
*
* @return - name of the store
*/
private String getNameString() {
return "Store [" + getName() + "]";
}
/**
* Close all ResultSet related things
*
* @param con - Connection to close
* @param ps - PreparedStatement to close
* @param rs - ResultSet to close
*/
private void close(Connection con, PreparedStatement ps, ResultSet rs) {
if (ps != null) {
try {
ps.close();
} catch (SQLException e) {
logger.error("Error while closing prepared statement", e);
}
}
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
logger.error("Error while closing result set", e);
}
}
if (con != null) {
try {
con.close();
} catch (SQLException e) {
logger.error("Error while closing connection", e);
}
}
}
}