Java tutorial
/** * Copyright 2012 Comcast Corporation * * Licensed 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 com.comcast.cqs.persistence; import java.io.IOException; import java.io.StringWriter; import java.io.UnsupportedEncodingException; import java.io.Writer; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Random; import java.util.Set; import org.apache.log4j.Logger; import org.json.JSONException; import org.json.JSONObject; import org.json.JSONWriter; import com.comcast.cmb.common.persistence.AbstractDurablePersistence; import com.comcast.cmb.common.persistence.AbstractDurablePersistence.CMB_SERIALIZER; import com.comcast.cmb.common.persistence.AbstractDurablePersistence.CmbColumn; import com.comcast.cmb.common.persistence.AbstractDurablePersistence.CmbColumnSlice; import com.comcast.cmb.common.persistence.AbstractDurablePersistence.CmbComposite; import com.comcast.cmb.common.persistence.DurablePersistenceFactory; import com.comcast.cmb.common.util.CMBErrorCodes; import com.comcast.cmb.common.util.CMBException; import com.comcast.cmb.common.util.CMBProperties; import com.comcast.cmb.common.util.PersistenceException; import com.comcast.cqs.controller.CQSCache; import com.comcast.cqs.model.CQSMessage; import com.comcast.cqs.model.CQSMessageAttribute; import com.comcast.cqs.model.CQSQueue; import com.comcast.cqs.util.CQSConstants; import com.comcast.cqs.util.CQSErrorCodes; import com.comcast.cqs.util.RandomNumberCollection; import com.comcast.cqs.util.Util; import com.eaio.uuid.UUIDGen; /** * Cassandra persistence for CQS Message * @author aseem, vvenkatraman, bwolf * */ public class CQSMessagePartitionedCassandraPersistence implements ICQSMessagePersistence { private static final String COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES = "CQSPartitionedQueueMessages"; private static final Random rand = new Random(); private static Logger logger = Logger.getLogger(CQSMessagePartitionedCassandraPersistence.class); private static final AbstractDurablePersistence cassandraHandler = DurablePersistenceFactory.getInstance(); public CQSMessagePartitionedCassandraPersistence() { } @Override public String sendMessage(CQSQueue queue, int shard, CQSMessage message) throws PersistenceException, IOException, InterruptedException, NoSuchAlgorithmException, JSONException { if (queue == null) { throw new PersistenceException(CQSErrorCodes.NonExistentQueue, "The supplied queue does not exist"); } if (message == null) { throw new PersistenceException(CQSErrorCodes.InvalidMessageContents, "The supplied message is invalid"); } int delaySeconds = 0; if (message.getAttributes().containsKey(CQSConstants.DELAY_SECONDS)) { delaySeconds = Integer.parseInt(message.getAttributes().get(CQSConstants.DELAY_SECONDS)); } long ts = System.currentTimeMillis() + delaySeconds * 1000; CmbComposite columnName = cassandraHandler.getCmbComposite(AbstractDurablePersistence.newTime(ts, false), UUIDGen.getClockSeqAndNode()); int ttl = queue.getMsgRetentionPeriod(); int partition = rand.nextInt(queue.getNumberOfPartitions()); String key = Util.hashQueueUrl(queue.getRelativeUrl()) + "_" + shard + "_" + partition; if (queue.isCompressed()) { message.setBody(Util.compress(message.getBody())); } message.setMessageId(key + ":" + columnName.get(0) + ":" + columnName.get(1)); logger.debug("event=send_message ttl=" + ttl + " delay_sec=" + delaySeconds + " msg_id=" + message.getMessageId() + " key=" + key + " col=" + columnName); cassandraHandler.update(AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, key, columnName, getMessageJSON(message), CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); return message.getMessageId(); } public List<CQSMessage> extractMessagesFromColumnSlice(String queueUrl, int length, CmbComposite previousHandle, CmbComposite nextHandle, CmbColumnSlice<CmbComposite, String> columnSlice, boolean ignoreFirstLastColumn) throws NoSuchAlgorithmException, IOException, JSONException, PersistenceException { List<CQSMessage> messageList = new ArrayList<CQSMessage>(); if (columnSlice != null && columnSlice.getColumns() != null) { boolean noMatch = true; for (CmbColumn<CmbComposite, String> column : columnSlice.getColumns()) { CmbComposite columnName = column.getName(); if (ignoreFirstLastColumn && (previousHandle != null && columnName.compareTo(previousHandle) == 0) || (nextHandle != null && columnName.compareTo(nextHandle) == 0)) { noMatch = false; continue; } else if (column.getValue() == null || column.getValue().length() == 0) { continue; } CQSMessage message = extractMessageFromJSON(queueUrl, column); messageList.add(message); } if (noMatch && messageList.size() > length) { messageList.remove(messageList.size() - 1); } } return messageList; } private CQSMessage extractMessageFromJSON(String queueUrl, CmbColumn column) throws JSONException, IOException, PersistenceException { CQSQueue queue = null; CQSMessage m = new CQSMessage(); try { queue = CQSCache.getCachedQueue(queueUrl); } catch (Exception ex) { throw new PersistenceException(ex); } if (queue == null) { throw new PersistenceException(CMBErrorCodes.InternalError, "Unknown queue " + queueUrl); } JSONObject json = new JSONObject((String) column.getValue()); m.setMessageId(json.getString("MessageId")); m.setReceiptHandle(json.getString("MessageId")); m.setMD5OfBody(json.getString("MD5OfBody")); m.setBody(json.getString("Body")); if (m.getAttributes() == null) { m.setAttributes(new HashMap<String, String>()); } if (json.has(CQSConstants.SENT_TIMESTAMP)) { m.getAttributes().put(CQSConstants.SENT_TIMESTAMP, json.getString(CQSConstants.SENT_TIMESTAMP)); } if (json.has(CQSConstants.APPROXIMATE_RECEIVE_COUNT)) { m.getAttributes().put(CQSConstants.APPROXIMATE_RECEIVE_COUNT, json.getString(CQSConstants.APPROXIMATE_RECEIVE_COUNT)); } if (json.has(CQSConstants.SENDER_ID)) { m.getAttributes().put(CQSConstants.SENDER_ID, json.getString(CQSConstants.SENDER_ID)); } if (json.has("MessageAttributes")) { m.setMD5OfMessageAttributes(json.getString("MD5OfMessageAttributes")); JSONObject messageAttributes = json.getJSONObject("MessageAttributes"); Map<String, CQSMessageAttribute> ma = new HashMap<String, CQSMessageAttribute>(); Iterator<String> iter = messageAttributes.keys(); while (iter.hasNext()) { String key = iter.next(); ma.put(key, new CQSMessageAttribute(messageAttributes.getJSONObject(key).getString("StringValue"), messageAttributes.getJSONObject(key).getString("DataType"))); } m.setMessageAttributes(ma); } m.setTimebasedId(column.getName()); if (queue.isCompressed()) { m.setBody(Util.decompress(m.getBody())); } return m; } private String getMessageJSON(CQSMessage message) throws JSONException { Writer writer = new StringWriter(); JSONWriter jw = new JSONWriter(writer); jw = jw.object(); jw.key("MessageId").value(message.getMessageId()); jw.key("MD5OfBody").value(message.getMD5OfBody()); jw.key("Body").value(message.getBody()); if (message.getAttributes() == null) { message.setAttributes(new HashMap<String, String>()); } if (!message.getAttributes().containsKey(CQSConstants.SENT_TIMESTAMP)) { message.getAttributes().put(CQSConstants.SENT_TIMESTAMP, "" + System.currentTimeMillis()); } if (!message.getAttributes().containsKey(CQSConstants.APPROXIMATE_RECEIVE_COUNT)) { message.getAttributes().put(CQSConstants.APPROXIMATE_RECEIVE_COUNT, "0"); } if (message.getAttributes() != null) { for (String key : message.getAttributes().keySet()) { String value = message.getAttributes().get(key); if (value == null || value.isEmpty()) { value = ""; } jw.key(key).value(value); } } if (message.getMessageAttributes() != null && message.getMessageAttributes().size() > 0) { jw.key("MD5OfMessageAttributes").value(message.getMD5OfMessageAttributes()); jw.key("MessageAttributes"); jw.object(); for (String key : message.getMessageAttributes().keySet()) { jw.key(key); jw.object(); CQSMessageAttribute messageAttribute = message.getMessageAttributes().get(key); if (messageAttribute.getStringValue() != null) { jw.key("StringValue").value(messageAttribute.getStringValue()); } else if (messageAttribute.getBinaryValue() != null) { jw.key("BinaryValue").value(messageAttribute.getBinaryValue()); } jw.key("DataType").value(messageAttribute.getDataType()); jw.endObject(); } jw.endObject(); } jw.endObject(); return writer.toString(); } @Override public Map<String, String> sendMessageBatch(CQSQueue queue, int shard, List<CQSMessage> messages) throws PersistenceException, IOException, InterruptedException, NoSuchAlgorithmException, JSONException { if (queue == null) { throw new PersistenceException(CQSErrorCodes.NonExistentQueue, "The supplied queue doesn't exist"); } if (messages == null || messages.size() == 0) { throw new PersistenceException(CQSErrorCodes.InvalidQueryParameter, "No messages are supplied."); } Map<CmbComposite, String> messageDataMap = new HashMap<CmbComposite, String>(); Map<String, String> ret = new HashMap<String, String>(); int ttl = queue.getMsgRetentionPeriod(); String key = Util.hashQueueUrl(queue.getRelativeUrl()) + "_" + shard + "_" + rand.nextInt(queue.getNumberOfPartitions()); for (CQSMessage message : messages) { if (message == null) { throw new PersistenceException(CQSErrorCodes.InvalidMessageContents, "The supplied message is invalid"); } if (queue.isCompressed()) { message.setBody(Util.compress(message.getBody())); } int delaySeconds = 0; if (message.getAttributes().containsKey(CQSConstants.DELAY_SECONDS)) { delaySeconds = Integer.parseInt(message.getAttributes().get(CQSConstants.DELAY_SECONDS)); } long ts = System.currentTimeMillis() + delaySeconds * 1000; CmbComposite columnName = cassandraHandler .getCmbComposite(AbstractDurablePersistence.newTime(ts, false), UUIDGen.getClockSeqAndNode()); message.setMessageId(key + ":" + columnName.get(0) + ":" + columnName.get(1)); logger.debug("event=send_message_batch msg_id=" + message.getMessageId() + " ttl=" + ttl + " delay_sec=" + delaySeconds + " key=" + key + " col=" + columnName); String messageJson = getMessageJSON(message); messageDataMap.put(columnName, messageJson); ret.put(message.getSuppliedMessageId(), message.getMessageId()); } cassandraHandler.insertRow(AbstractDurablePersistence.CQS_KEYSPACE, key, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, messageDataMap, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); return ret; } @Override public void deleteMessage(String queueUrl, String receiptHandle) throws PersistenceException { if (receiptHandle == null) { logger.error("event=delete_message event=no_receipt_handle queue_url=" + queueUrl); return; } String[] receiptHandleParts = receiptHandle.split(":"); if (receiptHandleParts.length != 3) { logger.error("event=delete_message event=invalid_receipt_handle queue_url=" + queueUrl + " receipt_handle=" + receiptHandle); return; } CmbComposite columnName = cassandraHandler.getCmbComposite( Arrays.asList(Long.parseLong(receiptHandleParts[1]), Long.parseLong(receiptHandleParts[2]))); if (columnName != null) { logger.debug("event=delete_message receipt_handle=" + receiptHandle + " col=" + columnName + " key=" + receiptHandleParts[0]); cassandraHandler.delete(AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, receiptHandleParts[0], columnName, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER); } } @Override public List<CQSMessage> receiveMessage(CQSQueue queue, Map<String, String> receiveAttributes) throws PersistenceException, IOException, NoSuchAlgorithmException, InterruptedException { throw new UnsupportedOperationException("ReceiveMessage is not supported, please call getMessages instead"); } @Override public boolean changeMessageVisibility(CQSQueue queue, String receiptHandle, int visibilityTO) throws PersistenceException, IOException, NoSuchAlgorithmException, InterruptedException { throw new UnsupportedOperationException("ChangeMessageVisibility is not supported"); } @Override public List<CQSMessage> peekQueue(String queueUrl, int shard, String previousReceiptHandle, String nextReceiptHandle, int length) throws IOException, NoSuchAlgorithmException, JSONException, PersistenceException { String queueHash = Util.hashQueueUrl(queueUrl); String key = queueHash + "_" + shard + "_0"; String handle = null; List<CQSMessage> messageList = new ArrayList<CQSMessage>(); CmbComposite previousHandle = null; CmbComposite nextHandle = null; int numberPartitions = getNumberOfPartitions(queueUrl); int numberShards = getNumberOfShards(queueUrl); logger.debug("event=peek_queue queue_url=" + queueUrl + " prev_receipt_handle=" + previousReceiptHandle + " next_receipt_handle=" + nextReceiptHandle + " length=" + length + " num_partitions=" + numberPartitions); if (previousReceiptHandle != null) { handle = previousReceiptHandle; String[] handleParts = handle.split(":"); if (handleParts.length != 3) { logger.error("event=peek_queue error_code=corrupt_receipt_handle receipt_handle=" + handle); throw new IllegalArgumentException("Corrupt receipt handle " + handle); } key = handleParts[0]; previousHandle = cassandraHandler .getCmbComposite(Arrays.asList(Long.parseLong(handleParts[1]), Long.parseLong(handleParts[2]))); } else if (nextReceiptHandle != null) { handle = nextReceiptHandle; String[] handleParts = handle.split(":"); if (handleParts.length != 3) { logger.error("action=peek_queue error_code=corrupt_receipt_handle receipt_handle=" + handle); throw new IllegalArgumentException("Corrupt receipt handle " + handle); } key = handleParts[0]; nextHandle = cassandraHandler .getCmbComposite(Arrays.asList(Long.parseLong(handleParts[1]), Long.parseLong(handleParts[2]))); } String[] queueParts = key.split("_"); if (queueParts.length != 3) { logger.error("event=peek_queue error_code=invalid_queue_key key=" + key); throw new IllegalArgumentException("Invalid queue key " + key); } int shardNumber = Integer.parseInt(queueParts[1]); int partitionNumber = Integer.parseInt(queueParts[2]); if (partitionNumber < 0 || partitionNumber > numberPartitions - 1) { logger.error( "event=peek_queue error_code=invalid_partition_number partition_number=" + partitionNumber); throw new IllegalArgumentException("Invalid queue partition number " + partitionNumber); } if (shardNumber < 0 || shardNumber > numberShards - 1) { logger.error("event=peek_queue error_code=invalid_shard_number shard_number=" + shardNumber); throw new IllegalArgumentException("Invalid queue shard number " + shardNumber); } while (messageList.size() < length && -1 < partitionNumber && partitionNumber < numberPartitions) { key = queueHash + "_" + shardNumber + "_" + partitionNumber; CmbColumnSlice<CmbComposite, String> columnSlice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, key, previousHandle, nextHandle, length - messageList.size() + 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); messageList.addAll(extractMessagesFromColumnSlice(queueUrl, length - messageList.size(), previousHandle, nextHandle, columnSlice, true)); if (messageList.size() < length && -1 < partitionNumber && partitionNumber < numberPartitions) { if (previousHandle != null) { partitionNumber++; if (partitionNumber > -1) { previousHandle = cassandraHandler.getCmbComposite(Arrays.asList( AbstractDurablePersistence.newTime(System.currentTimeMillis() - 1209600000, false), UUIDGen.getClockSeqAndNode())); } } else if (nextHandle != null) { partitionNumber--; if (partitionNumber < numberPartitions) { nextHandle = cassandraHandler.getCmbComposite(Arrays.asList( AbstractDurablePersistence.newTime(System.currentTimeMillis() + 1209600000, false), UUIDGen.getClockSeqAndNode())); } } else { partitionNumber++; } } } return messageList; } @Override public void clearQueue(String queueUrl, int shard) throws PersistenceException, NoSuchAlgorithmException, UnsupportedEncodingException { int numberPartitions = getNumberOfPartitions(queueUrl); logger.debug("event=clear_queue queue_url=" + queueUrl + " num_partitions=" + numberPartitions); for (int i = 0; i < numberPartitions; i++) { String key = Util.hashQueueUrl(queueUrl) + "_" + shard + "_" + i; //cassandraHandler.deleteSuperColumn(COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, key, null, CMB_SERIALIZER.STRING_SERIALIZER, CompositeSerializer.get()); cassandraHandler.delete(AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, key, null, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } @Override public Map<String, CQSMessage> getMessages(String queueUrl, List<String> ids) throws NoSuchAlgorithmException, IOException, JSONException, PersistenceException { Map<String, CQSMessage> messageMap = new HashMap<String, CQSMessage>(); logger.debug("event=get_messages ids=" + ids); if (ids == null || ids.size() == 0) { return messageMap; } else if (ids.size() > 100) { return getMessagesBulk(queueUrl, ids); } for (String id : ids) { String[] idParts = id.split(":"); if (idParts.length != 3) { logger.error("event=get_messages error_code=invalid_message_id id=" + id); throw new IllegalArgumentException("Invalid message id " + id); } CmbComposite columnName = cassandraHandler .getCmbComposite(Arrays.asList(Long.parseLong(idParts[1]), Long.parseLong(idParts[2]))); CmbColumn<CmbComposite, String> column = cassandraHandler.readColumn( AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, idParts[0], columnName, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); CQSMessage message = null; if (column != null) { message = extractMessageFromJSON(queueUrl, column); } messageMap.put(id, message); } return messageMap; } private Map<String, CQSMessage> getMessagesBulk(String queueUrl, List<String> ids) throws NoSuchAlgorithmException, IOException, JSONException, NumberFormatException, PersistenceException { logger.debug("event=get_message_bulk ids=" + ids); Map<String, CQSMessage> messageMap = new HashMap<String, CQSMessage>(); Set<String> messageIdSet = new HashSet<String>(); Map<String, Map<String, String>> firstLastIdsForEachPartition = getFirstAndLastIdsForEachPartition(ids, messageIdSet); if (firstLastIdsForEachPartition.size() == 0) { return messageMap; } for (String queuePartition : firstLastIdsForEachPartition.keySet()) { int messageCount = 200; Map<String, String> firstLastForPartition = firstLastIdsForEachPartition.get(queuePartition); String firstParts[] = firstLastForPartition.get("First").split(":"); String lastParts[] = firstLastForPartition.get("Last").split(":"); CmbColumnSlice<CmbComposite, String> columnSlice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, queuePartition, cassandraHandler.getCmbComposite( Arrays.asList(Long.parseLong(firstParts[0]), Long.parseLong(firstParts[1]))), cassandraHandler.getCmbComposite( Arrays.asList(Long.parseLong(lastParts[0]), Long.parseLong(lastParts[1]))), messageCount, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); List<CQSMessage> messageList = extractMessagesFromColumnSlice(queueUrl, messageCount, null, null, columnSlice, false); for (CQSMessage message : messageList) { if (messageIdSet.contains(message.getMessageId())) { messageMap.put(message.getMessageId(), message); messageIdSet.remove(message.getMessageId()); } } } for (String messageId : messageIdSet) { messageMap.put(messageId, null); } return messageMap; } private Map<String, Map<String, String>> getFirstAndLastIdsForEachPartition(List<String> ids, Set<String> messageIdSet) { Map<String, Map<String, String>> firstLastForEachPartitionMap = new HashMap<String, Map<String, String>>(); if (ids == null || ids.size() == 0) { return firstLastForEachPartitionMap; } for (String id : ids) { messageIdSet.add(id); String[] idParts = id.split(":"); if (idParts.length != 3) { logger.error("action=get_messages_bulk error_code=corrupt_receipt_handle receipt_handle=" + id); throw new IllegalArgumentException("Corrupt receipt handle " + id); } String queuePartition = idParts[0]; final String messageId = idParts[1] + ":" + idParts[2]; if (!firstLastForEachPartitionMap.containsKey(queuePartition)) { firstLastForEachPartitionMap.put(queuePartition, new HashMap<String, String>() { { put("First", messageId); put("Last", messageId); } }); } else { Map<String, String> firstLastForPartition = firstLastForEachPartitionMap.get(queuePartition); if (firstLastForPartition.get("First").compareTo(messageId) > 0) { firstLastForPartition.put("First", messageId); } else if (firstLastForPartition.get("Last").compareTo(messageId) < 0) { firstLastForPartition.put("Last", messageId); } } } return firstLastForEachPartitionMap; } private int getNumberOfPartitions(String queueUrl) { int numberPartitions = CMBProperties.getInstance().getCQSNumberOfQueuePartitions(); try { CQSQueue queue = CQSCache.getCachedQueue(queueUrl); if (queue != null) { numberPartitions = queue.getNumberOfPartitions(); } } catch (Exception ex) { logger.warn("event=queue_cache_failure queue_url=" + queueUrl, ex); } return numberPartitions; } private int getNumberOfShards(String queueUrl) { int numberShards = 1; try { CQSQueue queue = CQSCache.getCachedQueue(queueUrl); if (queue != null) { numberShards = queue.getNumberOfShards(); } } catch (Exception ex) { logger.warn("event=queue_cache_failure queue_url=" + queueUrl, ex); } return numberShards; } @Override public List<CQSMessage> peekQueueRandom(String queueUrl, int shard, int length) throws IOException, NoSuchAlgorithmException, JSONException, PersistenceException { String queueHash = Util.hashQueueUrl(queueUrl); int numberPartitions = getNumberOfPartitions(queueUrl); logger.debug("event=peek_queue_random queue_url=" + queueUrl + " shard=" + shard + " queue_hash=" + queueHash + " num_partitions=" + numberPartitions); List<CQSMessage> messageList = new ArrayList<CQSMessage>(); if (length > numberPartitions) { // no randomness, get from all rows, subsequent calls will return the same result return peekQueue(queueUrl, shard, null, null, length); } else { // get from random set of rows // note: as a simplification we may return less messages than length if not all rows contain messages RandomNumberCollection rc = new RandomNumberCollection(numberPartitions); int numFound = 0; for (int i = 0; i < numberPartitions && numFound < length; i++) { int partition = rc.getNext(); String key = queueHash + "_" + shard + "_" + partition; CmbColumnSlice<CmbComposite, String> columnSlice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CQS_KEYSPACE, COLUMN_FAMILY_PARTITIONED_QUEUE_MESSAGES, key, null, null, 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); List<CQSMessage> messages = extractMessagesFromColumnSlice(queueUrl, 1, null, null, columnSlice, false); numFound += messages.size(); messageList.addAll(messages); } return messageList; } } @Override public List<String> getIdsFromHead(String queueUrl, int shard, int num) throws PersistenceException { // TODO Auto-generated method stub return null; } @Override public long getQueueMessageCount(String queueUrl) { // TODO Auto-generated method stub return 0; } @Override public boolean checkCacheConsistency(String queueUrl, int shard, boolean trueOnFiller) { // TODO Auto-generated method stub return false; } @Override public long getQueueMessageCount(String queueUrl, boolean processHiddenIds) throws Exception { // TODO Auto-generated method stub return 0; } @Override public int getNumConnections() { // TODO Auto-generated method stub return 0; } @Override public long getCacheQueueMessageCount(String queueUrl) throws Exception { // TODO Auto-generated method stub return 0; } @Override public long getQueueNotVisibleMessageCount(String queueUrl, boolean visibilityProcessFlag) throws Exception { // TODO Auto-generated method stub return 0; } @Override public long getQueueDelayedMessageCount(String queueUrl, boolean visibilityProcessFlag) throws Exception { // TODO Auto-generated method stub return 0; } @Override public void flushAll() { // TODO Auto-generated method stub } @Override public boolean isAlive() { // TODO Auto-generated method stub return false; } @Override public int getNumberOfRedisShards() { // TODO Auto-generated method stub return 0; } @Override public void shutdown() { // TODO Auto-generated method stub } @Override public List<Map<String, String>> getInfo() { // TODO Auto-generated method stub return null; } @Override public long getMemQueueMessageCreatedTS(String memId) { // TODO Auto-generated method stub return 0; } }