From 73f2871235331a9b86f39768d0eec13f47b7654b Mon Sep 17 00:00:00 2001 From: Athou Date: Thu, 25 Jul 2013 10:21:11 +0200 Subject: [PATCH] revamp cache service --- .../commafeed/backend/cache/CacheService.java | 26 +++- .../backend/cache/NoopCacheService.java | 34 ++++- .../backend/cache/RedisCacheService.java | 134 +++++++++++++----- .../backend/dao/FeedEntryStatusDAO.java | 24 ---- .../commafeed/backend/feeds/OPMLImporter.java | 3 +- .../backend/services/FeedCategoryService.java | 35 +++++ .../backend/services/FeedEntryService.java | 34 +++++ .../services/FeedSubscriptionService.java | 46 ++++-- .../backend/services/FeedUpdateService.java | 2 +- .../frontend/rest/resources/CategoryREST.java | 44 +++--- .../frontend/rest/resources/EntryREST.java | 5 - .../frontend/rest/resources/FeedREST.java | 17 ++- .../frontend/rest/resources/UserREST.java | 5 - 13 files changed, 285 insertions(+), 124 deletions(-) create mode 100644 src/main/java/com/commafeed/backend/services/FeedCategoryService.java diff --git a/src/main/java/com/commafeed/backend/cache/CacheService.java b/src/main/java/com/commafeed/backend/cache/CacheService.java index e5d89416..52353bf6 100644 --- a/src/main/java/com/commafeed/backend/cache/CacheService.java +++ b/src/main/java/com/commafeed/backend/cache/CacheService.java @@ -1,17 +1,18 @@ package com.commafeed.backend.cache; import java.util.List; -import java.util.Map; import org.apache.commons.codec.digest.DigestUtils; import com.commafeed.backend.model.Feed; +import com.commafeed.backend.model.FeedCategory; import com.commafeed.backend.model.FeedEntry; +import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; -import com.commafeed.frontend.model.Category; public abstract class CacheService { + // feed entries for faster refresh public abstract List getLastEntries(Feed feed); public abstract void setLastEntries(Feed feed, List entries); @@ -20,14 +21,25 @@ public abstract class CacheService { return DigestUtils.sha1Hex(entry.getGuid() + entry.getUrl()); } - public abstract Category getRootCategory(User user); + // user categories + public abstract List getUserCategories(User user); - public abstract void setRootCategory(User user, Category category); + public abstract void setUserCategories(User user, List categories); - public abstract Map getUnreadCounts(User user); + public abstract void invalidateUserCategories(User user); - public abstract void setUnreadCounts(User user, Map map); + // subscriptions + public abstract List getUserSubscriptions(User user); - public abstract void invalidateUserData(User... users); + public abstract void setUserSubscriptions(User user, List subs); + + public abstract void invalidateUserSubscriptions(User user); + + // unread count + public abstract Long getUnreadCount(FeedSubscription sub); + + public abstract void setUnreadCount(FeedSubscription sub, Long count); + + public abstract void invalidateUnreadCount(FeedSubscription... subs); } diff --git a/src/main/java/com/commafeed/backend/cache/NoopCacheService.java b/src/main/java/com/commafeed/backend/cache/NoopCacheService.java index cd2b841f..65286e82 100644 --- a/src/main/java/com/commafeed/backend/cache/NoopCacheService.java +++ b/src/main/java/com/commafeed/backend/cache/NoopCacheService.java @@ -2,14 +2,14 @@ package com.commafeed.backend.cache; import java.util.Collections; import java.util.List; -import java.util.Map; import javax.enterprise.context.ApplicationScoped; import javax.enterprise.inject.Alternative; import com.commafeed.backend.model.Feed; +import com.commafeed.backend.model.FeedCategory; +import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; -import com.commafeed.frontend.model.Category; @Alternative @ApplicationScoped @@ -25,27 +25,47 @@ public class NoopCacheService extends CacheService { } @Override - public Category getRootCategory(User user) { + public Long getUnreadCount(FeedSubscription sub) { return null; } @Override - public void setRootCategory(User user, Category category) { + public void setUnreadCount(FeedSubscription sub, Long count) { } @Override - public Map getUnreadCounts(User user) { + public List getUserCategories(User user) { return null; } @Override - public void setUnreadCounts(User user, Map map) { + public void setUserCategories(User user, List categories) { } @Override - public void invalidateUserData(User... users) { + public void invalidateUserCategories(User user) { + + } + + @Override + public List getUserSubscriptions(User user) { + return null; + } + + @Override + public void setUserSubscriptions(User user, List subs) { + + } + + @Override + public void invalidateUserSubscriptions(User user) { + + } + + @Override + public void invalidateUnreadCount(FeedSubscription... subs) { } diff --git a/src/main/java/com/commafeed/backend/cache/RedisCacheService.java b/src/main/java/com/commafeed/backend/cache/RedisCacheService.java index 36a28a1c..749c030f 100644 --- a/src/main/java/com/commafeed/backend/cache/RedisCacheService.java +++ b/src/main/java/com/commafeed/backend/cache/RedisCacheService.java @@ -1,7 +1,6 @@ package com.commafeed.backend.cache; import java.util.List; -import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; @@ -17,12 +16,13 @@ import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.Pipeline; import com.commafeed.backend.model.Feed; +import com.commafeed.backend.model.FeedCategory; +import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.Models; import com.commafeed.backend.model.User; -import com.commafeed.frontend.model.Category; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.type.MapType; +import com.fasterxml.jackson.databind.type.CollectionType; import com.google.api.client.util.Lists; @Alternative @@ -30,9 +30,12 @@ import com.google.api.client.util.Lists; public class RedisCacheService extends CacheService { private static final Logger log = LoggerFactory.getLogger(RedisCacheService.class); + private static ObjectMapper mapper = new ObjectMapper(); + private static CollectionType TYPE_LIST_CATEGORIES = mapper.getTypeFactory().constructCollectionType(List.class, FeedCategory.class); + private static CollectionType TYPE_LIST_SUBSCRIPTIONS = mapper.getTypeFactory().constructCollectionType(List.class, + FeedSubscription.class); private JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost"); - private ObjectMapper mapper = new ObjectMapper(); @Override public List getLastEntries(Feed feed) { @@ -69,32 +72,32 @@ public class RedisCacheService extends CacheService { } @Override - public Category getRootCategory(User user) { - Category cat = null; + public List getUserCategories(User user) { + List cats = null; Jedis jedis = pool.getResource(); try { - String key = buildRedisRootCategoryKey(user); + String key = buildRedisUserCategoriesKey(user); String json = jedis.get(key); if (json != null) { - cat = mapper.readValue(json, Category.class); + cats = mapper.readValue(json, TYPE_LIST_CATEGORIES); } } catch (Exception e) { log.error(e.getMessage(), e); } finally { pool.returnResource(jedis); } - return cat; + return cats; } @Override - public void setRootCategory(User user, Category category) { + public void setUserCategories(User user, List categories) { Jedis jedis = pool.getResource(); try { - String key = buildRedisRootCategoryKey(user); + String key = buildRedisUserCategoriesKey(user); Pipeline pipe = jedis.pipelined(); pipe.del(key); - pipe.set(key, mapper.writeValueAsString(category)); + pipe.set(key, mapper.writeValueAsString(categories)); pipe.expire(key, (int) TimeUnit.MINUTES.toSeconds(30)); pipe.sync(); } catch (JsonProcessingException e) { @@ -105,33 +108,32 @@ public class RedisCacheService extends CacheService { } @Override - public Map getUnreadCounts(User user) { - Map map = null; + public List getUserSubscriptions(User user) { + List subs = null; Jedis jedis = pool.getResource(); try { - String key = buildRedisUnreadCountKey(user); + String key = buildRedisUserSubscriptionsKey(user); String json = jedis.get(key); if (json != null) { - MapType type = mapper.getTypeFactory().constructMapType(Map.class, Long.class, Long.class); - map = mapper.readValue(json, type); + subs = mapper.readValue(json, TYPE_LIST_SUBSCRIPTIONS); } } catch (Exception e) { log.error(e.getMessage(), e); } finally { pool.returnResource(jedis); } - return map; + return subs; } @Override - public void setUnreadCounts(User user, Map map) { + public void setUserSubscriptions(User user, List subs) { Jedis jedis = pool.getResource(); try { - String key = buildRedisUnreadCountKey(user); + String key = buildRedisUserSubscriptionsKey(user); Pipeline pipe = jedis.pipelined(); pipe.del(key); - pipe.set(key, mapper.writeValueAsString(map)); + pipe.set(key, mapper.writeValueAsString(subs)); pipe.expire(key, (int) TimeUnit.MINUTES.toSeconds(30)); pipe.sync(); } catch (JsonProcessingException e) { @@ -142,15 +144,71 @@ public class RedisCacheService extends CacheService { } @Override - public void invalidateUserData(User... users) { + public Long getUnreadCount(FeedSubscription sub) { + Long count = null; + Jedis jedis = pool.getResource(); + try { + String key = buildRedisUnreadCountKey(sub); + String countString = jedis.get(key); + if (countString != null) { + count = Long.valueOf(countString); + } + } catch (Exception e) { + log.error(e.getMessage(), e); + } finally { + pool.returnResource(jedis); + } + return count; + } + + @Override + public void setUnreadCount(FeedSubscription sub, Long count) { + Jedis jedis = pool.getResource(); + try { + String key = buildRedisUnreadCountKey(sub); + + Pipeline pipe = jedis.pipelined(); + pipe.del(key); + pipe.set(key, String.valueOf(count)); + pipe.expire(key, (int) TimeUnit.MINUTES.toSeconds(30)); + pipe.sync(); + } catch (Exception e) { + log.error(e.getMessage(), e); + } finally { + pool.returnResource(jedis); + } + } + + @Override + public void invalidateUserCategories(User user) { + Jedis jedis = pool.getResource(); + try { + String key = buildRedisUserCategoriesKey(user); + jedis.del(key); + } finally { + pool.returnResource(jedis); + } + } + + @Override + public void invalidateUserSubscriptions(User user) { + Jedis jedis = pool.getResource(); + try { + String key = buildRedisUserSubscriptionsKey(user); + jedis.del(key); + } finally { + pool.returnResource(jedis); + } + } + + @Override + public void invalidateUnreadCount(FeedSubscription... subs) { Jedis jedis = pool.getResource(); try { Pipeline pipe = jedis.pipelined(); - if (users != null) { - for (User user : users) { - String key = buildRedisRootCategoryKey(user); - pipe.del(key); - key = buildRedisUnreadCountKey(user); + if (subs != null) { + for (FeedSubscription sub : subs) { + String key = buildRedisUnreadCountKey(sub); pipe.del(key); } } @@ -160,16 +218,20 @@ public class RedisCacheService extends CacheService { } } - private String buildRedisRootCategoryKey(User user) { - return "root_cat:" + Models.getId(user); - } - - private String buildRedisUnreadCountKey(User user) { - return "unread_count:" + Models.getId(user); - } - private String buildRedisEntryKey(Feed feed) { - return "feed:" + feed.getId(); + return "f:" + Models.getId(feed); + } + + private String buildRedisUserCategoriesKey(User user) { + return "c:" + Models.getId(user); + } + + private String buildRedisUserSubscriptionsKey(User user) { + return "s:" + Models.getId(user); + } + + private String buildRedisUnreadCountKey(FeedSubscription sub) { + return "u:" + Models.getId(sub); } } diff --git a/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java b/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java index c9ab57dd..e03a62b9 100644 --- a/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java +++ b/src/main/java/com/commafeed/backend/dao/FeedEntryStatusDAO.java @@ -266,28 +266,4 @@ public class FeedEntryStatusDAO extends GenericDAO { setTimeout(query, applicationSettingsService.get().getQueryTimeout()); } - public void markSubscriptionEntries(List subscriptions, Date olderThan) { - List statuses = findBySubscriptions(subscriptions, true, null, null, -1, -1, null, false); - markList(statuses, olderThan); - } - - public void markStarredEntries(User user, Date olderThan) { - List statuses = findStarred(user, null, -1, -1, null, false); - markList(statuses, olderThan); - } - - private void markList(List statuses, Date olderThan) { - List list = Lists.newArrayList(); - for (FeedEntryStatus status : statuses) { - if (!status.isRead()) { - Date inserted = status.getEntry().getInserted(); - if (olderThan == null || inserted == null || olderThan.after(inserted)) { - status.setRead(true); - list.add(status); - } - } - } - saveOrUpdate(list); - } - } diff --git a/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java b/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java index df048338..6733a55d 100644 --- a/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java +++ b/src/main/java/com/commafeed/backend/feeds/OPMLImporter.java @@ -97,6 +97,7 @@ public class OPMLImporter { log.error("error while importing {}: {}", outline.getXmlUrl(), e.getMessage()); } } - cache.invalidateUserData(user); + cache.invalidateUserCategories(user); + cache.invalidateUserSubscriptions(user); } } diff --git a/src/main/java/com/commafeed/backend/services/FeedCategoryService.java b/src/main/java/com/commafeed/backend/services/FeedCategoryService.java new file mode 100644 index 00000000..b494bf0b --- /dev/null +++ b/src/main/java/com/commafeed/backend/services/FeedCategoryService.java @@ -0,0 +1,35 @@ +package com.commafeed.backend.services; + +import java.util.List; + +import javax.inject.Inject; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.commafeed.backend.cache.CacheService; +import com.commafeed.backend.dao.FeedCategoryDAO; +import com.commafeed.backend.model.FeedCategory; +import com.commafeed.backend.model.Models; +import com.commafeed.backend.model.User; + +public class FeedCategoryService { + private static Logger log = LoggerFactory.getLogger(FeedSubscriptionService.class); + + @Inject + FeedCategoryDAO feedCategoryDAO; + + @Inject + CacheService cache; + + public List getCategories(User user) { + List list = cache.getUserCategories(user); + if (list == null) { + log.debug("cat list miss for {}", Models.getId(user)); + list = feedCategoryDAO.findAll(user); + cache.setUserCategories(user, list); + } + return list; + } + +} diff --git a/src/main/java/com/commafeed/backend/services/FeedEntryService.java b/src/main/java/com/commafeed/backend/services/FeedEntryService.java index dfb96644..02b4ebab 100644 --- a/src/main/java/com/commafeed/backend/services/FeedEntryService.java +++ b/src/main/java/com/commafeed/backend/services/FeedEntryService.java @@ -1,8 +1,12 @@ package com.commafeed.backend.services; +import java.util.Date; +import java.util.List; + import javax.ejb.Stateless; import javax.inject.Inject; +import com.commafeed.backend.cache.CacheService; import com.commafeed.backend.dao.FeedEntryDAO; import com.commafeed.backend.dao.FeedEntryStatusDAO; import com.commafeed.backend.dao.FeedSubscriptionDAO; @@ -10,6 +14,7 @@ import com.commafeed.backend.model.FeedEntry; import com.commafeed.backend.model.FeedEntryStatus; import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; +import com.google.common.collect.Lists; @Stateless public class FeedEntryService { @@ -23,6 +28,9 @@ public class FeedEntryService { @Inject FeedEntryDAO feedEntryDAO; + @Inject + CacheService cache; + public void markEntry(User user, Long entryId, Long subscriptionId, boolean read) { FeedSubscription sub = feedSubscriptionDAO.findById(user, subscriptionId); if (sub == null) { @@ -38,6 +46,7 @@ public class FeedEntryService { if (status.isMarkable()) { status.setRead(read); feedEntryStatusDAO.saveOrUpdate(status); + cache.invalidateUnreadCount(sub); } } @@ -57,4 +66,29 @@ public class FeedEntryService { status.setStarred(starred); feedEntryStatusDAO.saveOrUpdate(status); } + + public void markSubscriptionEntries(List subscriptions, Date olderThan) { + List statuses = feedEntryStatusDAO.findBySubscriptions(subscriptions, true, null, null, -1, -1, null, false); + markList(statuses, olderThan); + cache.invalidateUnreadCount(subscriptions.toArray(new FeedSubscription[0])); + } + + public void markStarredEntries(User user, Date olderThan) { + List statuses = feedEntryStatusDAO.findStarred(user, null, -1, -1, null, false); + markList(statuses, olderThan); + } + + private void markList(List statuses, Date olderThan) { + List list = Lists.newArrayList(); + for (FeedEntryStatus status : statuses) { + if (!status.isRead()) { + Date inserted = status.getEntry().getInserted(); + if (olderThan == null || inserted == null || olderThan.after(inserted)) { + status.setRead(true); + list.add(status); + } + } + } + feedEntryStatusDAO.saveOrUpdate(list); + } } diff --git a/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java b/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java index bbe45791..26b2fbb4 100644 --- a/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java +++ b/src/main/java/com/commafeed/backend/services/FeedSubscriptionService.java @@ -80,20 +80,48 @@ public class FeedSubscriptionService { feedSubscriptionDAO.saveOrUpdate(sub); taskGiver.add(feed); + cache.invalidateUserSubscriptions(user); return feed; } + + public boolean unsubscribe(User user, Long subId){ + FeedSubscription sub = feedSubscriptionDAO.findById(user, subId); + if (sub != null) { + feedSubscriptionDAO.delete(sub); + cache.invalidateUserSubscriptions(user); + return true; + } else { + return false; + } + } + + public List getSubscriptions(User user) { + List list = cache.getUserSubscriptions(user); + if (list == null) { + log.debug("sub list miss for {}", Models.getId(user)); + list = feedSubscriptionDAO.findAll(user); + cache.setUserSubscriptions(user, list); + } + return list; + } + + public Long getUnreadCount(FeedSubscription sub) { + Long count = cache.getUnreadCount(sub); + if (count == null) { + log.debug("unread count cache miss for {}", Models.getId(sub)); + count = feedEntryStatusDAO.getUnreadCount(sub); + cache.setUnreadCount(sub, count); + } + return count; + } public Map getUnreadCount(User user) { - Map map = cache.getUnreadCounts(user); - if (map == null) { - log.debug("unread count cache miss for {}", Models.getId(user)); - List subs = feedSubscriptionDAO.findAll(user); - map = Maps.newHashMap(); - for (FeedSubscription sub : subs) { - map.put(sub.getId(), feedEntryStatusDAO.getUnreadCount(sub)); - } - cache.setUnreadCounts(user, map); + Map map = Maps.newHashMap(); + List subs = getSubscriptions(user); + for (FeedSubscription sub : subs) { + map.put(sub.getId(), getUnreadCount(sub)); } return map; } + } diff --git a/src/main/java/com/commafeed/backend/services/FeedUpdateService.java b/src/main/java/com/commafeed/backend/services/FeedUpdateService.java index 1d16a059..6342d630 100644 --- a/src/main/java/com/commafeed/backend/services/FeedUpdateService.java +++ b/src/main/java/com/commafeed/backend/services/FeedUpdateService.java @@ -69,6 +69,6 @@ public class FeedUpdateService { } feedEntryDAO.saveOrUpdate(entry); metricsBean.entryInserted(); - cache.invalidateUserData(users.toArray(new User[0])); + cache.invalidateUnreadCount(subscriptions.toArray(new FeedSubscription[0])); } } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/CategoryREST.java b/src/main/java/com/commafeed/frontend/rest/resources/CategoryREST.java index 134a446c..89e11292 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/CategoryREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/CategoryREST.java @@ -33,6 +33,8 @@ import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.User; import com.commafeed.backend.model.UserRole.Role; import com.commafeed.backend.model.UserSettings.ReadingOrder; +import com.commafeed.backend.services.FeedCategoryService; +import com.commafeed.backend.services.FeedEntryService; import com.commafeed.backend.services.FeedSubscriptionService; import com.commafeed.frontend.SecurityCheck; import com.commafeed.frontend.model.Category; @@ -68,6 +70,9 @@ public class CategoryREST extends AbstractResourceREST { @Inject FeedEntryStatusDAO feedEntryStatusDAO; + @Inject + FeedEntryService feedEntryService; + @Inject FeedCategoryDAO feedCategoryDAO; @@ -77,6 +82,9 @@ public class CategoryREST extends AbstractResourceREST { @Inject FeedSubscriptionService feedSubscriptionService; + @Inject + FeedCategoryService feedCategoryService; + @Inject CacheService cache; @@ -206,17 +214,16 @@ public class CategoryREST extends AbstractResourceREST { Date olderThan = req.getOlderThan() == null ? null : new Date(req.getOlderThan()); if (ALL.equals(req.getId())) { - List subscriptions = feedSubscriptionDAO.findAll(getUser()); - feedEntryStatusDAO.markSubscriptionEntries(subscriptions, olderThan); + List subscriptions = feedSubscriptionService.getSubscriptions(getUser()); + feedEntryService.markSubscriptionEntries(subscriptions, olderThan); } else if (STARRED.equals(req.getId())) { - feedEntryStatusDAO.markStarredEntries(getUser(), olderThan); + feedEntryService.markStarredEntries(getUser(), olderThan); } else { FeedCategory parent = feedCategoryDAO.findById(getUser(), Long.valueOf(req.getId())); List categories = feedCategoryDAO.findAllChildrenCategories(getUser(), parent); List subs = feedSubscriptionDAO.findByCategories(getUser(), categories); - feedEntryStatusDAO.markSubscriptionEntries(subs, olderThan); + feedEntryService.markSubscriptionEntries(subs, olderThan); } - cache.invalidateUserData(getUser()); return Response.ok(Status.OK).build(); } @@ -238,7 +245,7 @@ public class CategoryREST extends AbstractResourceREST { cat.setParent(parent); } feedCategoryDAO.saveOrUpdate(cat); - cache.invalidateUserData(getUser()); + cache.invalidateUserCategories(getUser()); return Response.ok().build(); } @@ -266,7 +273,7 @@ public class CategoryREST extends AbstractResourceREST { feedCategoryDAO.saveOrUpdate(categories); feedCategoryDAO.delete(cat); - cache.invalidateUserData(getUser()); + cache.invalidateUserCategories(getUser()); return Response.ok().build(); } else { return Response.status(Status.NOT_FOUND).build(); @@ -322,7 +329,7 @@ public class CategoryREST extends AbstractResourceREST { } feedCategoryDAO.saveOrUpdate(category); - cache.invalidateUserData(getUser()); + cache.invalidateUserCategories(getUser()); return Response.ok(Status.OK).build(); } @@ -339,7 +346,7 @@ public class CategoryREST extends AbstractResourceREST { } category.setCollapsed(req.isCollapse()); feedCategoryDAO.saveOrUpdate(category); - cache.invalidateUserData(getUser()); + cache.invalidateUserCategories(getUser()); return Response.ok(Status.OK).build(); } @@ -364,18 +371,15 @@ public class CategoryREST extends AbstractResourceREST { public Response getSubscriptions() { User user = getUser(); - Category root = cache.getRootCategory(user); - if (root == null) { - log.debug("root category cache miss for {}", user.getName()); - List categories = feedCategoryDAO.findAll(user); - List subscriptions = feedSubscriptionDAO.findAll(getUser()); - Map unreadCount = feedSubscriptionService.getUnreadCount(getUser()); + Category root = null; + List categories = feedCategoryService.getCategories(user); + List subscriptions = feedSubscriptionService.getSubscriptions(getUser()); + Map unreadCount = feedSubscriptionService.getUnreadCount(getUser()); + + root = buildCategory(null, categories, subscriptions, unreadCount); + root.setId("all"); + root.setName("All"); - root = buildCategory(null, categories, subscriptions, unreadCount); - root.setId("all"); - root.setName("All"); - cache.setRootCategory(user, root); - } return Response.ok(root).build(); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/EntryREST.java b/src/main/java/com/commafeed/frontend/rest/resources/EntryREST.java index a655c4aa..7cef115c 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/EntryREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/EntryREST.java @@ -13,7 +13,6 @@ import javax.ws.rs.core.Response.Status; import org.apache.commons.lang.StringUtils; -import com.commafeed.backend.cache.CacheService; import com.commafeed.backend.dao.FeedEntryStatusDAO; import com.commafeed.backend.dao.FeedSubscriptionDAO; import com.commafeed.backend.model.FeedEntryStatus; @@ -44,9 +43,6 @@ public class EntryREST extends AbstractResourceREST { @Inject FeedSubscriptionDAO feedSubscriptionDAO; - @Inject - CacheService cache; - @Path("/mark") @POST @ApiOperation(value = "Mark a feed entry", notes = "Mark a feed entry as read/unread") @@ -56,7 +52,6 @@ public class EntryREST extends AbstractResourceREST { Preconditions.checkNotNull(req.getFeedId()); feedEntryService.markEntry(getUser(), Long.valueOf(req.getId()), req.getFeedId(), req.isRead()); - cache.invalidateUserData(getUser()); return Response.ok(Status.OK).build(); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/FeedREST.java b/src/main/java/com/commafeed/frontend/rest/resources/FeedREST.java index 9d18e119..c699a85f 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/FeedREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/FeedREST.java @@ -55,6 +55,7 @@ import com.commafeed.backend.model.FeedEntryStatus; import com.commafeed.backend.model.FeedSubscription; import com.commafeed.backend.model.UserRole.Role; import com.commafeed.backend.model.UserSettings.ReadingOrder; +import com.commafeed.backend.services.FeedEntryService; import com.commafeed.backend.services.FeedSubscriptionService; import com.commafeed.frontend.SecurityCheck; import com.commafeed.frontend.model.Entries; @@ -97,6 +98,9 @@ public class FeedREST extends AbstractResourceREST { @Inject FeedSubscriptionDAO feedSubscriptionDAO; + @Inject + FeedEntryService feedEntryService; + @Inject FeedSubscriptionService feedSubscriptionService; @@ -274,9 +278,8 @@ public class FeedREST extends AbstractResourceREST { FeedSubscription subscription = feedSubscriptionDAO.findById(getUser(), Long.valueOf(req.getId())); if (subscription != null) { - feedEntryStatusDAO.markSubscriptionEntries(Arrays.asList(subscription), olderThan); + feedEntryService.markSubscriptionEntries(Arrays.asList(subscription), olderThan); } - cache.invalidateUserData(getUser()); return Response.ok(Status.OK).build(); } @@ -353,7 +356,6 @@ public class FeedREST extends AbstractResourceREST { log.info("Failed to subscribe to URL {}: {}", url, e.getMessage()); return Response.status(Status.SERVICE_UNAVAILABLE).entity("Failed to subscribe to URL " + url + ": " + e.getMessage()).build(); } - cache.invalidateUserData(getUser()); return Response.ok(Status.OK).build(); } @@ -390,10 +392,8 @@ public class FeedREST extends AbstractResourceREST { Preconditions.checkNotNull(req); Preconditions.checkNotNull(req.getId()); - FeedSubscription sub = feedSubscriptionDAO.findById(getUser(), req.getId()); - if (sub != null) { - feedSubscriptionDAO.delete(sub); - cache.invalidateUserData(getUser()); + boolean deleted = feedSubscriptionService.unsubscribe(getUser(), req.getId()); + if (deleted) { return Response.ok(Status.OK).build(); } else { return Response.status(Status.NOT_FOUND).build(); @@ -446,7 +446,7 @@ public class FeedREST extends AbstractResourceREST { } else { feedSubscriptionDAO.saveOrUpdate(subscription); } - cache.invalidateUserData(getUser()); + cache.invalidateUserSubscriptions(getUser()); return Response.ok(Status.OK).build(); } @@ -480,7 +480,6 @@ public class FeedREST extends AbstractResourceREST { } catch (Exception e) { throw new WebApplicationException(Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build()); } - cache.invalidateUserData(getUser()); return Response.temporaryRedirect(URI.create(applicationSettingsService.get().getPublicUrl())).build(); } diff --git a/src/main/java/com/commafeed/frontend/rest/resources/UserREST.java b/src/main/java/com/commafeed/frontend/rest/resources/UserREST.java index 89f9a992..6793cc31 100644 --- a/src/main/java/com/commafeed/frontend/rest/resources/UserREST.java +++ b/src/main/java/com/commafeed/frontend/rest/resources/UserREST.java @@ -12,7 +12,6 @@ import javax.ws.rs.core.Response.Status; import org.apache.commons.lang.StringUtils; import com.commafeed.backend.StartupBean; -import com.commafeed.backend.cache.CacheService; import com.commafeed.backend.dao.UserDAO; import com.commafeed.backend.dao.UserRoleDAO; import com.commafeed.backend.dao.UserSettingsDAO; @@ -58,9 +57,6 @@ public class UserREST extends AbstractResourceREST { @Inject PasswordEncryptionService encryptionService; - @Inject - CacheService cache; - @Inject ApplicationSettingsService applicationSettingsService; @@ -200,7 +196,6 @@ public class UserREST extends AbstractResourceREST { return Response.status(Status.FORBIDDEN).build(); } userService.unregister(getUser()); - cache.invalidateUserData(getUser()); return Response.ok().build(); } }