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.cns.persistence; import java.io.StringWriter; import java.io.Writer; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; 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.persistence.PersistenceFactory; 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.cns.model.CNSSubscription; import com.comcast.cns.model.CNSSubscriptionAttributes; import com.comcast.cns.model.CNSTopic; import com.comcast.cns.model.CNSSubscription.CnsSubscriptionProtocol; import com.comcast.cns.util.Util; import com.comcast.cqs.model.CQSQueue; /** * * Column-name for CNSTopicSubscriptions table is composite(Endpoint, Protocol). row-key is topicARn * @author aseem, bwolf, vvenkatraman, tina, jorge * * Class is immutable */ public class CNSSubscriptionCassandraPersistence implements ICNSSubscriptionPersistence { private static Logger logger = Logger.getLogger(CNSSubscriptionCassandraPersistence.class); private static final String columnFamilySubscriptions = "CNSTopicSubscriptions"; private static final String columnFamilySubscriptionsIndex = "CNSTopicSubscriptionsIndex"; private static final String columnFamilySubscriptionsUserIndex = "CNSTopicSubscriptionsUserIndex"; private static final String columnFamilySubscriptionsTokenIndex = "CNSTopicSubscriptionsTokenIndex"; private static final String columnFamilyTopicStats = "CNSTopicStats"; private static final AbstractDurablePersistence cassandraHandler = DurablePersistenceFactory.getInstance(); public CNSSubscriptionCassandraPersistence() { } @SuppressWarnings("serial") private Map<String, String> getIndexColumnValues(final String endpoint, final CnsSubscriptionProtocol protocol) { return new HashMap<String, String>() { { put(getEndpointAndProtoIndexVal(endpoint, protocol), ""); } }; } private String getColumnValuesJSON(CNSSubscription s) throws JSONException { Writer writer = new StringWriter(); JSONWriter jw = new JSONWriter(writer); jw = jw.object(); if (s.getEndpoint() != null) { jw.key("endPoint").value(s.getEndpoint()); } if (s.getToken() != null) { jw.key("token").value(s.getToken()); } if (s.getArn() != null) { jw.key("subArn").value(s.getArn()); } if (s.getUserId() != null) { jw.key("userId").value(s.getUserId()); } if (s.getConfirmDate() != null) { jw.key("confirmDate").value(s.getConfirmDate().getTime() + ""); } if (s.getProtocol() != null) { jw.key("protocol").value(s.getProtocol().toString()); } if (s.getRequestDate() != null) { jw.key("requestDate").value(s.getRequestDate().getTime() + ""); } jw.key("authenticateOnSubscribe").value(s.isAuthenticateOnUnsubscribe() + ""); jw.key("isConfirmed").value(s.isConfirmed() + ""); jw.key("rawMessageDelivery").value(s.getRawMessageDelivery() + ""); jw.endObject(); return writer.toString(); } /*private Map<String, String> getColumnValues(CNSSubscription s) { Map<String, String> columnValues = new HashMap<String, String>(); if (s.getEndpoint() != null) { columnValues.put("endPoint", s.getEndpoint()); } if (s.getToken() != null) { columnValues.put("token", s.getToken()); } if (s.getArn() != null) { columnValues.put("subArn", s.getArn()); } if (s.getUserId() != null) { columnValues.put("userId", s.getUserId()); } if (s.getConfirmDate() != null) { columnValues.put("confirmDate", s.getConfirmDate().getTime() + ""); } if (s.getProtocol() != null) { columnValues.put("protocol", s.getProtocol().toString()); } if (s.getRequestDate() != null) { columnValues.put("requestDate", s.getRequestDate().getTime() + ""); } columnValues.put("authenticateOnSubscribe", s.isAuthenticateOnUnsubscribe() + ""); columnValues.put("isConfirmed", s.isConfirmed() + ""); columnValues.put("rawMessageDelivery", s.getRawMessageDelivery() + ""); return columnValues; }*/ /*private static CNSSubscription getSubscriptionFromMap(Map<String, String> map) { String subArn = map.get("subArn"); CNSSubscription s = new CNSSubscription(subArn); s.setEndpoint(map.get("endPoint")); s.setUserId(map.get("userId")); String confirmDate = map.get("confirmDate"); if (confirmDate != null) { s.setConfirmDate(new Date(Long.parseLong(confirmDate))); } String requestDate = map.get("requestDate"); if (requestDate != null) { s.setRequestDate(new Date(Long.parseLong(requestDate))); } String protocol = map.get("protocol"); if (protocol != null) { s.setProtocol(CnsSubscriptionProtocol.valueOf(protocol)); } String isConfirmed = map.get("isConfirmed"); if (isConfirmed != null) { s.setConfirmed(Boolean.parseBoolean(isConfirmed)); } s.setToken(map.get("token")); String authenticateOnSubscribe = map.get("authenticateOnSubscribe"); if (authenticateOnSubscribe != null) { s.setAuthenticateOnUnsubscribe(Boolean.parseBoolean(authenticateOnSubscribe)); } String rawMessage = map.get("rawMessageDelivery"); if (rawMessage != null) { s.setRawMessageDelivery(Boolean.parseBoolean(rawMessage)); } return s; }*/ private static String getEndpointAndProtoIndexVal(String endpoint, CnsSubscriptionProtocol protocol) { return protocol.name() + ":" + endpoint; } private static String getEndpointAndProtoIndexValEndpoint(String composite) { String[] arr = composite.split(":"); if (arr.length < 2) { throw new IllegalArgumentException( "Bad format for EndpointAndProtocol composite. Must be of the form <protocol>:<endpoint>. Got:" + composite); } StringBuffer sb = new StringBuffer(arr[1]); for (int i = 2; i < arr.length; i++) { sb.append(":").append(arr[i]); } return sb.toString(); } private static CnsSubscriptionProtocol getEndpointAndProtoIndexValProtocol(String composite) { String[] arr = composite.split(":"); if (arr.length < 2) { throw new IllegalArgumentException( "Bad format for EndpointAndProtocol composite. Must be of the form <protocol>:<endpoint>. Got:" + composite); } return CnsSubscriptionProtocol.valueOf(arr[0]); } private void insertOrUpdateSubsAndIndexes(final CNSSubscription subscription, Integer ttl) throws Exception { subscription.checkIsValid(); CmbComposite columnName = cassandraHandler.getCmbComposite(subscription.getEndpoint(), subscription.getProtocol().name()); cassandraHandler.update(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, subscription.getTopicArn(), columnName, getColumnValuesJSON(subscription), CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); cassandraHandler.insertRow(AbstractDurablePersistence.CNS_KEYSPACE, subscription.getArn(), columnFamilySubscriptionsIndex, getIndexColumnValues(subscription.getEndpoint(), subscription.getProtocol()), CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); cassandraHandler.insertRow(AbstractDurablePersistence.CNS_KEYSPACE, subscription.getUserId(), columnFamilySubscriptionsUserIndex, new HashMap<String, String>() { { put(subscription.getArn(), ""); } }, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); cassandraHandler.insertRow(AbstractDurablePersistence.CNS_KEYSPACE, subscription.getToken(), columnFamilySubscriptionsTokenIndex, new HashMap<String, String>() { { put(subscription.getArn(), ""); } }, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, ttl); } @Override public CNSSubscription subscribe(String endpoint, CnsSubscriptionProtocol protocol, String topicArn, String userId) throws Exception { // subscription is unique by protocol + endpoint + topic final CNSSubscription subscription = new CNSSubscription(endpoint, protocol, topicArn, userId); CNSTopic t = PersistenceFactory.getTopicPersistence().getTopic(topicArn); if (t == null) { throw new TopicNotFoundException("Resource not found."); } // check if queue exists for cqs endpoints if (protocol.equals(CnsSubscriptionProtocol.cqs)) { CQSQueue queue = PersistenceFactory.getQueuePersistence() .getQueue(com.comcast.cqs.util.Util.getRelativeQueueUrlForArn(endpoint)); if (queue == null) { throw new CMBException(CMBErrorCodes.NotFound, "Queue with arn " + endpoint + " does not exist."); } } subscription.setArn(Util.generateCnsTopicSubscriptionArn(topicArn, protocol, endpoint)); // attempt to delete existing subscription /*Composite superColumnName = new Composite(subscription.getEndpoint(), subscription.getProtocol().name()); HSuperColumn<Composite, String, String> superCol = readColumnFromSuperColumnFamily(columnFamilySubscriptions, subscription.getTopicArn(), superColumnName, new StringSerializer(), new CompositeSerializer(), StringSerializer.get(), StringSerializer.get(), CMBProperties.getInstance().getReadConsistencyLevel()); if (superCol != null) { CNSSubscription exisitingSub = extractSubscriptionFromSuperColumn(superCol, topicArn); deleteIndexes(exisitingSub.getArn(), exisitingSub.getUserId(), exisitingSub.getToken()); deleteSuperColumn(subscriptionsTemplate, exisitingSub.getTopicArn(), superColumnName); }*/ // then set confirmation stuff and update cassandra CNSSubscription retrievedSubscription = getSubscription(subscription.getArn()); if (!CMBProperties.getInstance().getCNSRequireSubscriptionConfirmation()) { subscription.setConfirmed(true); subscription.setConfirmDate(new Date()); insertOrUpdateSubsAndIndexes(subscription, null); if (retrievedSubscription == null) { cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, subscription.getTopicArn(), "subscriptionConfirmed", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } else { // protocols that cannot confirm subscriptions (e.g. redisPubSub) // get an automatic confirmation here if (!protocol.canConfirmSubscription()) { subscription.setConfirmed(true); subscription.setConfirmDate(new Date()); insertOrUpdateSubsAndIndexes(subscription, null); // auto confirm subscription to cqs queue by owner } else if (protocol.equals(CnsSubscriptionProtocol.cqs)) { String queueOwner = com.comcast.cqs.util.Util.getQueueOwnerFromArn(endpoint); if (queueOwner != null && queueOwner.equals(userId)) { subscription.setConfirmed(true); subscription.setConfirmDate(new Date()); insertOrUpdateSubsAndIndexes(subscription, null); if (retrievedSubscription == null) { cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, subscription.getTopicArn(), "subscriptionConfirmed", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } else { // use cassandra ttl to implement expiration after 3 days insertOrUpdateSubsAndIndexes(subscription, 3 * 24 * 60 * 60); if (retrievedSubscription == null) { cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, subscription.getTopicArn(), "subscriptionPending", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } } else { // use cassandra ttl to implement expiration after 3 days insertOrUpdateSubsAndIndexes(subscription, 3 * 24 * 60 * 60); if (retrievedSubscription == null) { cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, subscription.getTopicArn(), "subscriptionPending", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } } CNSSubscriptionAttributes attributes = new CNSSubscriptionAttributes(topicArn, subscription.getArn(), userId); PersistenceFactory.getCNSAttributePersistence().setSubscriptionAttributes(attributes, subscription.getArn()); return subscription; } @Override public CNSSubscription getSubscription(String arn) throws Exception { //read form index to get composite col-name CmbColumnSlice<String, String> slice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsIndex, arn, null, null, 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (slice != null) { //get Column from main table String colName = slice.getColumns().get(0).getName(); CnsSubscriptionProtocol protocol = getEndpointAndProtoIndexValProtocol(colName); String endpoint = getEndpointAndProtoIndexValEndpoint(colName); CmbComposite columnName = cassandraHandler.getCmbComposite(endpoint, protocol.name()); CmbColumn<CmbComposite, String> column = cassandraHandler.readColumn( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, Util.getCnsTopicArn(arn), columnName, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (column != null) { CNSSubscription s = extractSubscriptionFromColumn(column, Util.getCnsTopicArn(arn)); s.checkIsValid(); return s; } } return null; } private static CNSSubscription extractSubscriptionFromColumn(CmbColumn<CmbComposite, String> column, String topicArn) throws JSONException { JSONObject json = new JSONObject(column.getValue()); CNSSubscription s = new CNSSubscription(json.getString("subArn")); s.setEndpoint(json.getString("endPoint")); s.setUserId(json.getString("userId")); if (json.has("confirmDate")) { s.setConfirmDate(new Date(json.getLong("confirmDate"))); } if (json.has("requestDate")) { s.setRequestDate(new Date(json.getLong("requestDate"))); } if (json.has("protocol")) { s.setProtocol(CnsSubscriptionProtocol.valueOf(json.getString("protocol"))); } if (json.has("isConfirmed")) { s.setConfirmed(json.getBoolean("isConfirmed")); } s.setToken(json.getString("token")); if (json.has("authenticateOnSubscribe")) { s.setAuthenticateOnUnsubscribe(json.getBoolean("authenticateOnSubscribe")); } if (json.has("rawMessageDelivery")) { s.setRawMessageDelivery(json.getBoolean("rawMessageDelivery")); } s.setTopicArn(topicArn); return s; } /*private static CNSSubscription extractSubscriptionFromSuperColumn(CmbSuperColumn<CmbComposite, String, String> superCol, String topicArn) { Map<String, String> messageMap = new HashMap<String, String>(superCol.getColumns().size()); for (CmbColumn<String, String> column : superCol.getColumns()) { messageMap.put(column.getName(), column.getValue()); } CNSSubscription sub = getSubscriptionFromMap(messageMap); sub.setTopicArn(topicArn); return sub; }*/ @Override /** * List all subscription for a user, unconfirmed subscriptions will not reveal their arns. Pagination for more than 100 subscriptions. * @param nextToken initially null, on subsequent calls arn of last result from prior call * @param protocol optional filter by protocol (this parameter is not part of official AWS API) * @return list of subscriptions. If nextToken is not null, the subscription corresponding to it is not returned. * @throws Exception */ public List<CNSSubscription> listSubscriptions(String nextToken, CnsSubscriptionProtocol protocol, String userId) throws Exception { return listSubscriptions(nextToken, protocol, userId, true); } private List<CNSSubscription> listSubscriptions(String nextToken, CnsSubscriptionProtocol protocol, String userId, boolean hidePendingArn) throws Exception { if (nextToken != null) { if (getSubscription(nextToken) == null) { throw new SubscriberNotFoundException("Subscriber not found for arn " + nextToken); } } //Algorithm is to keep reading in chunks of 100 till we've seen 500 from the nextToken-ARN List<CNSSubscription> l = new ArrayList<CNSSubscription>(); //read form index to get sub-arn while (l.size() < 100) { CmbColumnSlice<String, String> slice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsUserIndex, userId, nextToken, null, 500, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (slice == null) { return l; } //get Column from main table List<CmbColumn<String, String>> cols = slice.getColumns(); if (nextToken != null) { cols.remove(0); } if (cols.size() == 0) { return l; } for (CmbColumn<String, String> col : cols) { String subArn = col.getName(); CNSSubscription subscription = getSubscription(subArn); if (subscription == null) { throw new IllegalStateException( "Subscriptions-user-index contains subscription-arn which doesn't exist in subscriptions-index. subArn:" + subArn); } // ignore invalid subscriptions coming from Cassandra try { subscription.checkIsValid(); } catch (CMBException ex) { logger.error("event=invalid_subscription " + subscription.toString(), ex); continue; } if (protocol != null && subscription.getProtocol() != protocol) { continue; } if (hidePendingArn) { if (subscription.isConfirmed()) { l.add(subscription); } else { subscription.setArn("PendingConfirmation"); l.add(subscription); } } else { l.add(subscription); } if (l.size() == 100) { return l; } } nextToken = cols.get(cols.size() - 1).getName(); } return l; } @Override public List<CNSSubscription> listAllSubscriptions(String nextToken, CnsSubscriptionProtocol protocol, String userId) throws Exception { return listSubscriptions(nextToken, protocol, userId, false); } @Override public List<CNSSubscription> listSubscriptionsByTopic(String nextToken, String topicArn, CnsSubscriptionProtocol protocol) throws Exception { return listSubscriptionsByTopic(nextToken, topicArn, protocol, 100); } @Override public List<CNSSubscription> listSubscriptionsByTopic(String nextToken, String topicArn, CnsSubscriptionProtocol protocol, int pageSize) throws Exception { return listSubscriptionsByTopic(nextToken, topicArn, protocol, pageSize, true); } /** * Enumerate all subs in a topic * @param nextToken The ARN of the last sub-returned or null is first time call. * @param topicArn * @param protocol * @param pageSize * @param hidePendingArn * @return The list of subscriptions given a topic. Note: if nextToken is provided, the returned list will not contain it for convenience * @throws Exception */ public List<CNSSubscription> listSubscriptionsByTopic(String nextToken, String topicArn, CnsSubscriptionProtocol protocol, int pageSize, boolean hidePendingArn) throws Exception { if (nextToken != null) { if (getSubscription(nextToken) == null) { throw new SubscriberNotFoundException("Subscriber not found for arn " + nextToken); } } //read from index to get composite-col-name corresponding to nextToken CmbComposite nextTokenComposite = null; if (nextToken != null) { CmbColumnSlice<String, String> slice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsIndex, nextToken, null, null, 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (slice == null) { throw new IllegalArgumentException("Could not find any subscription with arn " + nextToken); } //get Column from main table String colName = slice.getColumns().get(0).getName(); CnsSubscriptionProtocol tokProtocol = getEndpointAndProtoIndexValProtocol(colName); String endpoint = getEndpointAndProtoIndexValEndpoint(colName); nextTokenComposite = cassandraHandler.getCmbComposite(endpoint, tokProtocol.name()); } List<CNSSubscription> l = new ArrayList<CNSSubscription>(); CNSTopic t = PersistenceFactory.getTopicPersistence().getTopic(topicArn); if (t == null) { throw new TopicNotFoundException("Resource not found."); } // read pageSize at a time CmbColumnSlice<CmbComposite, String> cols = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, topicArn, nextTokenComposite, null, pageSize, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (nextToken != null && cols.size() > 0) { cols.getColumns().remove(0); } while (l.size() < pageSize) { if (cols == null || cols.size() == 0) { return l; } for (CmbColumn<CmbComposite, String> col : cols.getColumns()) { CNSSubscription sub = extractSubscriptionFromColumn(col, topicArn); // ignore invalid subscriptions coming from Cassandra try { sub.checkIsValid(); } catch (CMBException ex) { logger.error("event=invalid_subscription " + sub.toString(), ex); continue; } if (protocol != null && protocol != sub.getProtocol()) { continue; } if (hidePendingArn) { if (sub.isConfirmed()) { l.add(sub); } else { sub.setArn("PendingConfirmation"); l.add(sub); } } else { l.add(sub); } if (l.size() == pageSize) { return l; } } nextTokenComposite = cols.getColumns().get(cols.size() - 1).getName(); cols = cassandraHandler.readColumnSlice(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, topicArn, nextTokenComposite, null, pageSize, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (cols.size() > 0) { cols.getColumns().remove(0); } } return l; } @Override public List<CNSSubscription> listAllSubscriptionsByTopic(String nextToken, String topicArn, CnsSubscriptionProtocol protocol) throws Exception { return listSubscriptionsByTopic(nextToken, topicArn, protocol, 100, false); } @Override public CNSSubscription confirmSubscription(boolean authenticateOnUnsubscribe, String token, String topicArn) throws Exception { //get Sub-arn given token CmbColumnSlice<String, String> slice = cassandraHandler.readColumnSlice( AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsTokenIndex, token, null, null, 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (slice == null) { throw new CMBException(CMBErrorCodes.NotFound, "Resource not found."); } //get Column from main table String subArn = slice.getColumns().get(0).getName(); //get Subscription given subArn final CNSSubscription s = getSubscription(subArn); if (s == null) { throw new SubscriberNotFoundException("Could not find subscription given subscription arn " + subArn); } s.setAuthenticateOnUnsubscribe(authenticateOnUnsubscribe); s.setConfirmed(true); s.setConfirmDate(new Date()); //re-insert with no TTL. will clobber the old one which had ttl insertOrUpdateSubsAndIndexes(s, null); cassandraHandler.decrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, s.getTopicArn(), "subscriptionPending", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, s.getTopicArn(), "subscriptionConfirmed", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); return s; } private void deleteIndexesAll(List<CNSSubscription> subscriptionList) throws PersistenceException { List<String> subArnList = new LinkedList<String>(); List<String> userIdList = new LinkedList<String>(); List<String> tokenList = new LinkedList<String>(); for (CNSSubscription sub : subscriptionList) { subArnList.add(sub.getArn()); userIdList.add(sub.getUserId()); tokenList.add(sub.getToken()); } cassandraHandler.deleteBatch(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsIndex, subArnList, null, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); cassandraHandler.deleteBatch(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsUserIndex, userIdList, subArnList, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); cassandraHandler.deleteBatch(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsTokenIndex, tokenList, subArnList, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } private void deleteIndexes(String subArn, String userId, String token) throws PersistenceException { cassandraHandler.delete(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsIndex, subArn, null, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); cassandraHandler.delete(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsUserIndex, userId, subArn, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); cassandraHandler.delete(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptionsTokenIndex, token, subArn, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } @Override public void unsubscribe(String arn) throws Exception { CNSSubscription s = getSubscription(arn); if (s != null) { deleteIndexes(arn, s.getUserId(), s.getToken()); CmbComposite columnName = cassandraHandler.getCmbComposite(s.getEndpoint(), s.getProtocol().name()); cassandraHandler.delete(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, Util.getCnsTopicArn(arn), columnName, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.COMPOSITE_SERIALIZER); if (s.isConfirmed()) { cassandraHandler.decrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, s.getTopicArn(), "subscriptionConfirmed", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } else { cassandraHandler.decrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, s.getTopicArn(), "subscriptionPending", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, s.getTopicArn(), "subscriptionDeleted", 1, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } public long getCountSubscription(String topicArn, String columnName) throws Exception { return cassandraHandler.getCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, columnName, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } @Override public void unsubscribeAll(String topicArn) throws Exception { int pageSize = 1000; String nextToken = null; List<CNSSubscription> subs = listSubscriptionsByTopic(nextToken, topicArn, null, pageSize, false); // for pagination to work we need the nextToken's corresponding sub to not be deleted. CNSSubscription nextTokenSub = null; while (subs.size() > 0) { if (subs.size() < pageSize) { deleteIndexesAll(subs); cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionDeleted", subs.size(), CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); break; } else { //keep the last subscription for pagination purpose. nextTokenSub = subs.get(subs.size() - 1); nextToken = nextTokenSub.getArn(); subs.remove(subs.size() - 1); deleteIndexesAll(subs); subs = listSubscriptionsByTopic(nextToken, topicArn, null, pageSize, false); deleteIndexes(nextTokenSub.getArn(), nextTokenSub.getUserId(), nextTokenSub.getToken()); cassandraHandler.incrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionDeleted", subs.size(), CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } } long subscriptionConfirmed = cassandraHandler.getCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionConfirmed", CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (subscriptionConfirmed > 0) { cassandraHandler.decrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionConfirmed", (int) subscriptionConfirmed, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } long subscriptionPending = cassandraHandler.getCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionPending", CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); if (subscriptionPending > 0) { cassandraHandler.decrementCounter(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilyTopicStats, topicArn, "subscriptionPending", (int) subscriptionPending, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } cassandraHandler.delete(AbstractDurablePersistence.CNS_KEYSPACE, columnFamilySubscriptions, topicArn, null, CMB_SERIALIZER.STRING_SERIALIZER, CMB_SERIALIZER.STRING_SERIALIZER); } @Override public void setRawMessageDelivery(String subscriptionArn, boolean rawMessageDelivery) throws Exception { CNSSubscription sub; sub = getSubscription(subscriptionArn); if (sub != null) { sub.setRawMessageDelivery(rawMessageDelivery); insertOrUpdateSubsAndIndexes(sub, null); } } }