split client and server into maven modules

commafeed-server/src/main/java/com/commafeed/backend/service/DatabaseCleaningService.java

@@ -0,0 +1,113 @@
+package com.commafeed.backend.service;
+
+import java.util.Date;
+import java.util.List;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.hibernate.SessionFactory;
+
+import com.commafeed.backend.dao.FeedDAO;
+import com.commafeed.backend.dao.FeedEntryContentDAO;
+import com.commafeed.backend.dao.FeedEntryDAO;
+import com.commafeed.backend.dao.FeedEntryDAO.FeedCapacity;
+import com.commafeed.backend.dao.FeedEntryStatusDAO;
+import com.commafeed.backend.dao.UnitOfWork;
+import com.commafeed.backend.model.Feed;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Contains utility methods for cleaning the database
+ * 
+ */
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class DatabaseCleaningService {
+
+	private static final int BATCH_SIZE = 100;
+
+	private final SessionFactory sessionFactory;
+	private final FeedDAO feedDAO;
+	private final FeedEntryDAO feedEntryDAO;
+	private final FeedEntryContentDAO feedEntryContentDAO;
+	private final FeedEntryStatusDAO feedEntryStatusDAO;
+
+	public long cleanFeedsWithoutSubscriptions() {
+		log.info("cleaning feeds without subscriptions");
+		long total = 0;
+		int deleted = 0;
+		long entriesTotal = 0;
+		do {
+			List<Feed> feeds = UnitOfWork.call(sessionFactory, () -> feedDAO.findWithoutSubscriptions(1));
+			for (Feed feed : feeds) {
+				int entriesDeleted = 0;
+				do {
+					entriesDeleted = UnitOfWork.call(sessionFactory, () -> feedEntryDAO.delete(feed.getId(), BATCH_SIZE));
+					entriesTotal += entriesDeleted;
+					log.info("removed {} entries for feeds without subscriptions", entriesTotal);
+				} while (entriesDeleted > 0);
+			}
+			deleted = UnitOfWork.call(sessionFactory, () -> feedDAO.delete(feeds));
+			total += deleted;
+			log.info("removed {} feeds without subscriptions", total);
+		} while (deleted != 0);
+		log.info("cleanup done: {} feeds without subscriptions deleted", total);
+		return total;
+	}
+
+	public long cleanContentsWithoutEntries() {
+		log.info("cleaning contents without entries");
+		long total = 0;
+		int deleted = 0;
+		do {
+			deleted = UnitOfWork.call(sessionFactory, () -> feedEntryContentDAO.deleteWithoutEntries(BATCH_SIZE));
+			total += deleted;
+			log.info("removed {} contents without entries", total);
+		} while (deleted != 0);
+		log.info("cleanup done: {} contents without entries deleted", total);
+		return total;
+	}
+
+	public long cleanEntriesForFeedsExceedingCapacity(final int maxFeedCapacity) {
+		long total = 0;
+		while (true) {
+			List<FeedCapacity> feeds = UnitOfWork.call(sessionFactory,
+					() -> feedEntryDAO.findFeedsExceedingCapacity(maxFeedCapacity, BATCH_SIZE));
+			if (feeds.isEmpty()) {
+				break;
+			}
+
+			for (final FeedCapacity feed : feeds) {
+				long remaining = feed.getCapacity() - maxFeedCapacity;
+				do {
+					final long rem = remaining;
+					int deleted = UnitOfWork.call(sessionFactory,
+							() -> feedEntryDAO.deleteOldEntries(feed.getId(), Math.min(BATCH_SIZE, rem)));
+					total += deleted;
+					remaining -= deleted;
+					log.info("removed {} entries for feeds exceeding capacity", total);
+				} while (remaining > 0);
+			}
+		}
+		log.info("cleanup done: {} entries for feeds exceeding capacity deleted", total);
+		return total;
+	}
+
+	public long cleanStatusesOlderThan(final Date olderThan) {
+		log.info("cleaning old read statuses");
+		long total = 0;
+		int deleted = 0;
+		do {
+			deleted = UnitOfWork.call(sessionFactory,
+					() -> feedEntryStatusDAO.delete(feedEntryStatusDAO.getOldStatuses(olderThan, BATCH_SIZE)));
+			total += deleted;
+			log.info("removed {} old read statuses", total);
+		} while (deleted != 0);
+		log.info("cleanup done: {} old read statuses deleted", total);
+		return total;
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedEntryContentService.java

@@ -0,0 +1,48 @@
+package com.commafeed.backend.service;
+
+import java.util.List;
+import java.util.Optional;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import com.commafeed.backend.dao.FeedEntryContentDAO;
+import com.commafeed.backend.feed.FeedUtils;
+import com.commafeed.backend.model.FeedEntryContent;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedEntryContentService {
+
+	private final FeedEntryContentDAO feedEntryContentDAO;
+
+	/**
+	 * this is NOT thread-safe
+	 */
+	public FeedEntryContent findOrCreate(FeedEntryContent content, String baseUrl) {
+		content.setAuthor(FeedUtils.truncate(FeedUtils.handleContent(content.getAuthor(), baseUrl, true), 128));
+		content.setTitle(FeedUtils.truncate(FeedUtils.handleContent(content.getTitle(), baseUrl, true), 2048));
+		content.setContent(FeedUtils.handleContent(content.getContent(), baseUrl, false));
+		content.setMediaDescription(FeedUtils.handleContent(content.getMediaDescription(), baseUrl, false));
+
+		String contentHash = DigestUtils.sha1Hex(StringUtils.trimToEmpty(content.getContent()));
+		content.setContentHash(contentHash);
+
+		String titleHash = DigestUtils.sha1Hex(StringUtils.trimToEmpty(content.getTitle()));
+		content.setTitleHash(titleHash);
+
+		List<FeedEntryContent> existing = feedEntryContentDAO.findExisting(contentHash, titleHash);
+		Optional<FeedEntryContent> equivalentContent = existing.stream().filter(c -> content.equivalentTo(c)).findFirst();
+		if (equivalentContent.isPresent()) {
+			return equivalentContent.get();
+		}
+
+		feedEntryContentDAO.saveOrUpdate(content);
+		return content;
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedEntryFilteringService.java

@@ -0,0 +1,122 @@
+package com.commafeed.backend.service;
+
+import java.time.Year;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.jexl2.JexlContext;
+import org.apache.commons.jexl2.JexlEngine;
+import org.apache.commons.jexl2.JexlException;
+import org.apache.commons.jexl2.JexlInfo;
+import org.apache.commons.jexl2.MapContext;
+import org.apache.commons.jexl2.Script;
+import org.apache.commons.jexl2.introspection.JexlMethod;
+import org.apache.commons.jexl2.introspection.JexlPropertyGet;
+import org.apache.commons.jexl2.introspection.Uberspect;
+import org.apache.commons.jexl2.introspection.UberspectImpl;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.logging.LogFactory;
+import org.jsoup.Jsoup;
+
+import com.commafeed.backend.model.FeedEntry;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedEntryFilteringService {
+
+	private static final JexlEngine ENGINE = initEngine();
+
+	private final ExecutorService executor = Executors.newCachedThreadPool();
+
+	private static JexlEngine initEngine() {
+		// classloader that prevents object creation
+		ClassLoader cl = new ClassLoader() {
+			@Override
+			protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+				return null;
+			}
+		};
+
+		// uberspect that prevents access to .class and .getClass()
+		Uberspect uberspect = new UberspectImpl(LogFactory.getLog(JexlEngine.class)) {
+			@Override
+			public JexlPropertyGet getPropertyGet(Object obj, Object identifier, JexlInfo info) {
+				if ("class".equals(identifier)) {
+					return null;
+				}
+				return super.getPropertyGet(obj, identifier, info);
+			}
+
+			@Override
+			public JexlMethod getMethod(Object obj, String method, Object[] args, JexlInfo info) {
+				if ("getClass".equals(method)) {
+					return null;
+				}
+				return super.getMethod(obj, method, args, info);
+			}
+		};
+
+		JexlEngine engine = new JexlEngine(uberspect, null, null, null);
+		engine.setStrict(true);
+		engine.setClassLoader(cl);
+		return engine;
+	}
+
+	public boolean filterMatchesEntry(String filter, FeedEntry entry) throws FeedEntryFilterException {
+		if (StringUtils.isBlank(filter)) {
+			return true;
+		}
+
+		Script script = null;
+		try {
+			script = ENGINE.createScript(filter);
+		} catch (JexlException e) {
+			throw new FeedEntryFilterException("Exception while parsing expression " + filter, e);
+		}
+
+		JexlContext context = new MapContext();
+		context.set("title", entry.getContent().getTitle() == null ? "" : Jsoup.parse(entry.getContent().getTitle()).text().toLowerCase());
+		context.set("author", entry.getContent().getAuthor() == null ? "" : entry.getContent().getAuthor().toLowerCase());
+		context.set("content",
+				entry.getContent().getContent() == null ? "" : Jsoup.parse(entry.getContent().getContent()).text().toLowerCase());
+		context.set("url", entry.getUrl() == null ? "" : entry.getUrl().toLowerCase());
+		context.set("categories", entry.getContent().getCategories() == null ? "" : entry.getContent().getCategories().toLowerCase());
+
+		context.set("year", Year.now().getValue());
+
+		Callable<Object> callable = script.callable(context);
+		Future<Object> future = executor.submit(callable);
+		Object result = null;
+		try {
+			result = future.get(500, TimeUnit.MILLISECONDS);
+		} catch (InterruptedException e) {
+			throw new FeedEntryFilterException("interrupted while evaluating expression " + filter, e);
+		} catch (ExecutionException e) {
+			throw new FeedEntryFilterException("Exception while evaluating expression " + filter, e);
+		} catch (TimeoutException e) {
+			throw new FeedEntryFilterException("Took too long evaluating expression " + filter, e);
+		}
+		try {
+			return (boolean) result;
+		} catch (ClassCastException e) {
+			throw new FeedEntryFilterException(e.getMessage(), e);
+		}
+	}
+
+	@SuppressWarnings("serial")
+	public static class FeedEntryFilterException extends Exception {
+		public FeedEntryFilterException(String message, Throwable t) {
+			super(message, t);
+		}
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedEntryService.java

@@ -0,0 +1,95 @@
+package com.commafeed.backend.service;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import com.commafeed.backend.cache.CacheService;
+import com.commafeed.backend.dao.FeedEntryDAO;
+import com.commafeed.backend.dao.FeedEntryStatusDAO;
+import com.commafeed.backend.dao.FeedSubscriptionDAO;
+import com.commafeed.backend.feed.FeedEntryKeyword;
+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 lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedEntryService {
+
+	private final FeedSubscriptionDAO feedSubscriptionDAO;
+	private final FeedEntryDAO feedEntryDAO;
+	private final FeedEntryStatusDAO feedEntryStatusDAO;
+	private final CacheService cache;
+
+	public void markEntry(User user, Long entryId, boolean read) {
+
+		FeedEntry entry = feedEntryDAO.findById(entryId);
+		if (entry == null) {
+			return;
+		}
+
+		FeedSubscription sub = feedSubscriptionDAO.findByFeed(user, entry.getFeed());
+		if (sub == null) {
+			return;
+		}
+
+		FeedEntryStatus status = feedEntryStatusDAO.getStatus(user, sub, entry);
+		if (status.isMarkable()) {
+			status.setRead(read);
+			feedEntryStatusDAO.saveOrUpdate(status);
+			cache.invalidateUnreadCount(sub);
+			cache.invalidateUserRootCategory(user);
+		}
+	}
+
+	public void starEntry(User user, Long entryId, Long subscriptionId, boolean starred) {
+
+		FeedSubscription sub = feedSubscriptionDAO.findById(user, subscriptionId);
+		if (sub == null) {
+			return;
+		}
+
+		FeedEntry entry = feedEntryDAO.findById(entryId);
+		if (entry == null) {
+			return;
+		}
+
+		FeedEntryStatus status = feedEntryStatusDAO.getStatus(user, sub, entry);
+		status.setStarred(starred);
+		feedEntryStatusDAO.saveOrUpdate(status);
+	}
+
+	public void markSubscriptionEntries(User user, List<FeedSubscription> subscriptions, Date olderThan, List<FeedEntryKeyword> keywords) {
+		List<FeedEntryStatus> statuses = feedEntryStatusDAO.findBySubscriptions(user, subscriptions, true, keywords, null, -1, -1, null,
+				false, false, null);
+		markList(statuses, olderThan);
+		cache.invalidateUnreadCount(subscriptions.toArray(new FeedSubscription[0]));
+		cache.invalidateUserRootCategory(user);
+	}
+
+	public void markStarredEntries(User user, Date olderThan) {
+		List<FeedEntryStatus> statuses = feedEntryStatusDAO.findStarred(user, null, -1, -1, null, false);
+		markList(statuses, olderThan);
+	}
+
+	private void markList(List<FeedEntryStatus> statuses, Date olderThan) {
+		List<FeedEntryStatus> list = new ArrayList<>();
+		for (FeedEntryStatus status : statuses) {
+			if (!status.isRead()) {
+				Date entryDate = status.getEntry().getUpdated();
+				if (olderThan == null || entryDate == null || olderThan.after(entryDate)) {
+					status.setRead(true);
+					list.add(status);
+				}
+			}
+		}
+		feedEntryStatusDAO.saveOrUpdate(list);
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedEntryTagService.java

@@ -0,0 +1,44 @@
+package com.commafeed.backend.service;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import com.commafeed.backend.dao.FeedEntryDAO;
+import com.commafeed.backend.dao.FeedEntryTagDAO;
+import com.commafeed.backend.model.FeedEntry;
+import com.commafeed.backend.model.FeedEntryTag;
+import com.commafeed.backend.model.User;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedEntryTagService {
+
+	private final FeedEntryDAO feedEntryDAO;
+	private final FeedEntryTagDAO feedEntryTagDAO;
+
+	public void updateTags(User user, Long entryId, List<String> tagNames) {
+		FeedEntry entry = feedEntryDAO.findById(entryId);
+		if (entry == null) {
+			return;
+		}
+
+		List<FeedEntryTag> existingTags = feedEntryTagDAO.findByEntry(user, entry);
+		Set<String> existingTagNames = existingTags.stream().map(FeedEntryTag::getName).collect(Collectors.toSet());
+
+		List<FeedEntryTag> addList = tagNames.stream()
+				.filter(name -> !existingTagNames.contains(name))
+				.map(name -> new FeedEntryTag(user, entry, name))
+				.collect(Collectors.toList());
+		List<FeedEntryTag> removeList = existingTags.stream().filter(tag -> !tagNames.contains(tag.getName())).collect(Collectors.toList());
+
+		feedEntryTagDAO.saveOrUpdate(addList);
+		feedEntryTagDAO.delete(removeList);
+	}
+
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedService.java

@@ -0,0 +1,68 @@
+package com.commafeed.backend.service;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.Set;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.io.IOUtils;
+
+import com.commafeed.backend.dao.FeedDAO;
+import com.commafeed.backend.favicon.AbstractFaviconFetcher;
+import com.commafeed.backend.favicon.AbstractFaviconFetcher.Favicon;
+import com.commafeed.backend.feed.FeedUtils;
+import com.commafeed.backend.model.Feed;
+
+@Singleton
+public class FeedService {
+
+	private final FeedDAO feedDAO;
+	private final Set<AbstractFaviconFetcher> faviconFetchers;
+
+	private Favicon defaultFavicon;
+
+	@Inject
+	public FeedService(FeedDAO feedDAO, Set<AbstractFaviconFetcher> faviconFetchers) {
+		this.feedDAO = feedDAO;
+		this.faviconFetchers = faviconFetchers;
+
+		try {
+			defaultFavicon = new Favicon(IOUtils.toByteArray(getClass().getResource("/images/default_favicon.gif")), "image/gif");
+		} catch (IOException e) {
+			throw new RuntimeException("could not load default favicon", e);
+		}
+	}
+
+	public synchronized Feed findOrCreate(String url) {
+		String normalized = FeedUtils.normalizeURL(url);
+		Feed feed = feedDAO.findByUrl(normalized);
+		if (feed == null) {
+			feed = new Feed();
+			feed.setUrl(url);
+			feed.setNormalizedUrl(normalized);
+			feed.setNormalizedUrlHash(DigestUtils.sha1Hex(normalized));
+			feed.setDisabledUntil(new Date(0));
+			feedDAO.saveOrUpdate(feed);
+		}
+		return feed;
+	}
+
+	public Favicon fetchFavicon(Feed feed) {
+
+		Favicon icon = null;
+		for (AbstractFaviconFetcher faviconFetcher : faviconFetchers) {
+			icon = faviconFetcher.fetch(feed);
+			if (icon != null) {
+				break;
+			}
+		}
+		if (icon == null) {
+			icon = defaultFavicon;
+		}
+		return icon;
+	}
+
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedSubscriptionService.java

@@ -0,0 +1,124 @@
+package com.commafeed.backend.service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.cache.CacheService;
+import com.commafeed.backend.dao.FeedDAO;
+import com.commafeed.backend.dao.FeedEntryStatusDAO;
+import com.commafeed.backend.dao.FeedSubscriptionDAO;
+import com.commafeed.backend.feed.FeedQueues;
+import com.commafeed.backend.feed.FeedUtils;
+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.UnreadCount;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedSubscriptionService {
+
+	private final FeedDAO feedDAO;
+	private final FeedEntryStatusDAO feedEntryStatusDAO;
+	private final FeedSubscriptionDAO feedSubscriptionDAO;
+	private final FeedService feedService;
+	private final FeedQueues queues;
+	private final CacheService cache;
+	private final CommaFeedConfiguration config;
+
+	public Feed subscribe(User user, String url, String title) {
+		return subscribe(user, url, title, null, 0);
+	}
+
+	public Feed subscribe(User user, String url, String title, FeedCategory parent) {
+		return subscribe(user, url, title, parent, 0);
+	}
+
+	public Feed subscribe(User user, String url, String title, FeedCategory category, int position) {
+
+		final String pubUrl = config.getApplicationSettings().getPublicUrl();
+		if (StringUtils.isBlank(pubUrl)) {
+			throw new FeedSubscriptionException("Public URL of this CommaFeed instance is not set");
+		}
+		if (url.startsWith(pubUrl)) {
+			throw new FeedSubscriptionException("Could not subscribe to a feed from this CommaFeed instance");
+		}
+
+		Feed feed = feedService.findOrCreate(url);
+
+		// upgrade feed to https if it was using http
+		if (FeedUtils.isHttp(feed.getUrl()) && FeedUtils.isHttps(url)) {
+			feed.setUrl(url);
+			feedDAO.saveOrUpdate(feed);
+		}
+
+		FeedSubscription sub = feedSubscriptionDAO.findByFeed(user, feed);
+		if (sub == null) {
+			sub = new FeedSubscription();
+			sub.setFeed(feed);
+			sub.setUser(user);
+		}
+		sub.setCategory(category);
+		sub.setPosition(position);
+		sub.setTitle(FeedUtils.truncate(title, 128));
+		feedSubscriptionDAO.saveOrUpdate(sub);
+
+		queues.add(feed, false);
+		cache.invalidateUserRootCategory(user);
+		return feed;
+	}
+
+	public boolean unsubscribe(User user, Long subId) {
+		FeedSubscription sub = feedSubscriptionDAO.findById(user, subId);
+		if (sub != null) {
+			feedSubscriptionDAO.delete(sub);
+			cache.invalidateUserRootCategory(user);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	public void refreshAll(User user) {
+		List<FeedSubscription> subs = feedSubscriptionDAO.findAll(user);
+		for (FeedSubscription sub : subs) {
+			Feed feed = sub.getFeed();
+			queues.add(feed, true);
+		}
+	}
+
+	public Map<Long, UnreadCount> getUnreadCount(User user) {
+		return feedSubscriptionDAO.findAll(user).stream().collect(Collectors.toMap(FeedSubscription::getId, s -> getUnreadCount(user, s)));
+	}
+
+	private UnreadCount getUnreadCount(User user, FeedSubscription sub) {
+		UnreadCount count = cache.getUnreadCount(sub);
+		if (count == null) {
+			log.debug("unread count cache miss for {}", Models.getId(sub));
+			count = feedEntryStatusDAO.getUnreadCount(user, sub);
+			cache.setUnreadCount(sub, count);
+		}
+		return count;
+	}
+
+	@SuppressWarnings("serial")
+	public static class FeedSubscriptionException extends RuntimeException {
+		private FeedSubscriptionException(String msg) {
+			super(msg);
+		}
+	}
+
+}

commafeed-server/src/main/java/com/commafeed/backend/service/FeedUpdateService.java

@@ -0,0 +1,67 @@
+package com.commafeed.backend.service;
+
+import java.util.Date;
+import java.util.List;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.codec.digest.DigestUtils;
+
+import com.commafeed.backend.dao.FeedEntryDAO;
+import com.commafeed.backend.dao.FeedEntryStatusDAO;
+import com.commafeed.backend.model.Feed;
+import com.commafeed.backend.model.FeedEntry;
+import com.commafeed.backend.model.FeedEntryContent;
+import com.commafeed.backend.model.FeedEntryStatus;
+import com.commafeed.backend.model.FeedSubscription;
+import com.commafeed.backend.service.FeedEntryFilteringService.FeedEntryFilterException;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class FeedUpdateService {
+
+	private final FeedEntryDAO feedEntryDAO;
+	private final FeedEntryStatusDAO feedEntryStatusDAO;
+	private final FeedEntryContentService feedEntryContentService;
+	private final FeedEntryFilteringService feedEntryFilteringService;
+
+	/**
+	 * this is NOT thread-safe
+	 */
+	public boolean addEntry(Feed feed, FeedEntry entry, List<FeedSubscription> subscriptions) {
+
+		Long existing = feedEntryDAO.findExisting(entry.getGuid(), feed);
+		if (existing != null) {
+			return false;
+		}
+
+		FeedEntryContent content = feedEntryContentService.findOrCreate(entry.getContent(), feed.getLink());
+		entry.setGuidHash(DigestUtils.sha1Hex(entry.getGuid()));
+		entry.setContent(content);
+		entry.setInserted(new Date());
+		entry.setFeed(feed);
+		feedEntryDAO.saveOrUpdate(entry);
+
+		// if filter does not match the entry, mark it as read
+		for (FeedSubscription sub : subscriptions) {
+			boolean matches = true;
+			try {
+				matches = feedEntryFilteringService.filterMatchesEntry(sub.getFilter(), entry);
+			} catch (FeedEntryFilterException e) {
+				log.error("could not evaluate filter {}", sub.getFilter(), e);
+			}
+			if (!matches) {
+				FeedEntryStatus status = new FeedEntryStatus(sub.getUser(), sub, entry);
+				status.setRead(true);
+				feedEntryStatusDAO.saveOrUpdate(status);
+			}
+		}
+
+		return true;
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/MailService.java

@@ -0,0 +1,64 @@
+package com.commafeed.backend.service;
+
+import java.util.Optional;
+import java.util.Properties;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.mail.Authenticator;
+import javax.mail.Message;
+import javax.mail.PasswordAuthentication;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.CommaFeedConfiguration.ApplicationSettings;
+import com.commafeed.backend.model.User;
+
+import lombok.RequiredArgsConstructor;
+
+/**
+ * Mailing service
+ * 
+ */
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class MailService {
+
+	private final CommaFeedConfiguration config;
+
+	public void sendMail(User user, String subject, String content) throws Exception {
+
+		ApplicationSettings settings = config.getApplicationSettings();
+
+		final String username = settings.getSmtpUserName();
+		final String password = settings.getSmtpPassword();
+		final String fromAddress = Optional.ofNullable(settings.getSmtpFromAddress()).orElse(settings.getSmtpUserName());
+
+		String dest = user.getEmail();
+
+		Properties props = new Properties();
+		props.put("mail.smtp.auth", "true");
+		props.put("mail.smtp.starttls.enable", "" + settings.isSmtpTls());
+		props.put("mail.smtp.host", settings.getSmtpHost());
+		props.put("mail.smtp.port", "" + settings.getSmtpPort());
+
+		Session session = Session.getInstance(props, new Authenticator() {
+			@Override
+			protected PasswordAuthentication getPasswordAuthentication() {
+				return new PasswordAuthentication(username, password);
+			}
+		});
+
+		Message message = new MimeMessage(session);
+		message.setFrom(new InternetAddress(fromAddress, "CommaFeed"));
+		message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(dest));
+		message.setSubject("CommaFeed - " + subject);
+		message.setContent(content, "text/html; charset=utf-8");
+
+		Transport.send(message);
+
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/PasswordEncryptionService.java

@@ -0,0 +1,95 @@
+package com.commafeed.backend.service;
+
+import java.io.Serializable;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.spec.KeySpec;
+
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.PBEKeySpec;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.lang3.StringUtils;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+// taken from http://www.javacodegeeks.com/2012/05/secure-password-storage-donts-dos-and.html
+@SuppressWarnings("serial")
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class PasswordEncryptionService implements Serializable {
+
+	public boolean authenticate(String attemptedPassword, byte[] encryptedPassword, byte[] salt) {
+		if (StringUtils.isBlank(attemptedPassword)) {
+			return false;
+		}
+		// Encrypt the clear-text password using the same salt that was used to
+		// encrypt the original password
+		byte[] encryptedAttemptedPassword = null;
+		try {
+			encryptedAttemptedPassword = getEncryptedPassword(attemptedPassword, salt);
+		} catch (Exception e) {
+			// should never happen
+			log.error(e.getMessage(), e);
+		}
+
+		if (encryptedAttemptedPassword == null) {
+			return false;
+		}
+
+		// Authentication succeeds if encrypted password that the user entered
+		// is equal to the stored hash
+		return MessageDigest.isEqual(encryptedPassword, encryptedAttemptedPassword);
+	}
+
+	public byte[] getEncryptedPassword(String password, byte[] salt) {
+		// PBKDF2 with SHA-1 as the hashing algorithm. Note that the NIST
+		// specifically names SHA-1 as an acceptable hashing algorithm for
+		// PBKDF2
+		String algorithm = "PBKDF2WithHmacSHA1";
+		// SHA-1 generates 160 bit hashes, so that's what makes sense here
+		int derivedKeyLength = 160;
+		// Pick an iteration count that works for you. The NIST recommends at
+		// least 1,000 iterations:
+		// http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf
+		// iOS 4.x reportedly uses 10,000:
+		// http://blog.crackpassword.com/2010/09/smartphone-forensics-cracking-blackberry-backup-passwords/
+		int iterations = 20000;
+
+		KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, derivedKeyLength);
+
+		byte[] bytes = null;
+		try {
+			SecretKeyFactory f = SecretKeyFactory.getInstance(algorithm);
+			SecretKey key = f.generateSecret(spec);
+			bytes = key.getEncoded();
+		} catch (Exception e) {
+			// should never happen
+			log.error(e.getMessage(), e);
+		}
+		return bytes;
+	}
+
+	public byte[] generateSalt() {
+		// VERY important to use SecureRandom instead of just Random
+
+		byte[] salt = null;
+		try {
+			SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
+
+			// Generate a 8 byte (64 bit) salt as recommended by RSA PKCS5
+			salt = new byte[8];
+			random.nextBytes(salt);
+		} catch (NoSuchAlgorithmException e) {
+			// should never happen
+			log.error(e.getMessage(), e);
+		}
+		return salt;
+	}
+
+}

commafeed-server/src/main/java/com/commafeed/backend/service/PubSubService.java

@@ -0,0 +1,91 @@
+package com.commafeed.backend.service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.ws.rs.core.MediaType;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.HttpHeaders;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.util.EntityUtils;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.HttpGetter;
+import com.commafeed.backend.feed.FeedQueues;
+import com.commafeed.backend.feed.FeedUtils;
+import com.commafeed.backend.model.Feed;
+import com.commafeed.frontend.resource.PubSubHubbubCallbackREST;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Sends push subscription requests. Callback is handled by {@link PubSubHubbubCallbackREST}
+ * 
+ */
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class PubSubService {
+
+	private final CommaFeedConfiguration config;
+	private final FeedQueues queues;
+
+	public void subscribe(Feed feed) {
+		String hub = feed.getPushHub();
+		String topic = feed.getPushTopic();
+		String publicUrl = FeedUtils.removeTrailingSlash(config.getApplicationSettings().getPublicUrl());
+
+		log.debug("sending new pubsub subscription to {} for {}", hub, topic);
+
+		HttpPost post = new HttpPost(hub);
+		List<NameValuePair> nvp = new ArrayList<>();
+		nvp.add(new BasicNameValuePair("hub.callback", publicUrl + "/rest/push/callback"));
+		nvp.add(new BasicNameValuePair("hub.topic", topic));
+		nvp.add(new BasicNameValuePair("hub.mode", "subscribe"));
+		nvp.add(new BasicNameValuePair("hub.verify", "async"));
+		nvp.add(new BasicNameValuePair("hub.secret", ""));
+		nvp.add(new BasicNameValuePair("hub.verify_token", ""));
+		nvp.add(new BasicNameValuePair("hub.lease_seconds", ""));
+
+		post.setHeader(HttpHeaders.USER_AGENT, "CommaFeed");
+		post.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED);
+
+		CloseableHttpClient client = HttpGetter.newClient(20000);
+		CloseableHttpResponse response = null;
+		try {
+			post.setEntity(new UrlEncodedFormEntity(nvp));
+			response = client.execute(post);
+
+			int code = response.getStatusLine().getStatusCode();
+			if (code != 204 && code != 202 && code != 200) {
+				String message = EntityUtils.toString(response.getEntity());
+				String pushpressError = " is value is not allowed.  You may only subscribe to";
+				if (code == 400 && StringUtils.contains(message, pushpressError)) {
+					String[] tokens = message.split(" ");
+					feed.setPushTopic(tokens[tokens.length - 1]);
+					queues.giveBack(feed);
+					log.debug("handled pushpress subfeed {} : {}", topic, feed.getPushTopic());
+				} else {
+					throw new Exception(
+							"Unexpected response code: " + code + " " + response.getStatusLine().getReasonPhrase() + " - " + message);
+				}
+			}
+			log.debug("subscribed to {} for {}", hub, topic);
+		} catch (Exception e) {
+			log.error("Could not subscribe to {} for {} : " + e.getMessage(), hub, topic);
+		} finally {
+			IOUtils.closeQuietly(response);
+			IOUtils.closeQuietly(client);
+		}
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/StartupService.java

@@ -0,0 +1,89 @@
+package com.commafeed.backend.service;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.dao.UnitOfWork;
+import com.commafeed.backend.dao.UserDAO;
+
+import io.dropwizard.lifecycle.Managed;
+import liquibase.Liquibase;
+import liquibase.database.Database;
+import liquibase.database.DatabaseFactory;
+import liquibase.database.core.PostgresDatabase;
+import liquibase.database.jvm.JdbcConnection;
+import liquibase.resource.ClassLoaderResourceAccessor;
+import liquibase.resource.ResourceAccessor;
+import liquibase.structure.DatabaseObject;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class StartupService implements Managed {
+
+	private final SessionFactory sessionFactory;
+	private final UserDAO userDAO;
+	private final UserService userService;
+	private final CommaFeedConfiguration config;
+
+	@Override
+	public void start() throws Exception {
+		updateSchema();
+		long count = UnitOfWork.call(sessionFactory, () -> userDAO.count());
+		if (count == 0) {
+			UnitOfWork.run(sessionFactory, this::initialData);
+		}
+	}
+
+	private void updateSchema() {
+		Session session = sessionFactory.openSession();
+		session.doWork(connection -> {
+			try {
+				JdbcConnection jdbcConnection = new JdbcConnection(connection);
+				Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(jdbcConnection);
+
+				if (database instanceof PostgresDatabase) {
+					database = new PostgresDatabase() {
+						@Override
+						public String escapeObjectName(String objectName, Class<? extends DatabaseObject> objectType) {
+							return objectName;
+						}
+					};
+					database.setConnection(jdbcConnection);
+				}
+
+				ResourceAccessor accessor = new ClassLoaderResourceAccessor(Thread.currentThread().getContextClassLoader());
+				try (Liquibase liq = new Liquibase("migrations.xml", accessor, database)) {
+					liq.update("prod");
+				}
+
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		});
+		session.close();
+	}
+
+	private void initialData() {
+		log.info("Populating database with default values");
+		try {
+			userService.createAdminUser();
+			if (config.getApplicationSettings().getCreateDemoAccount()) {
+				userService.createDemoUser();
+			}
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+		}
+	}
+
+	@Override
+	public void stop() throws Exception {
+
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/UserService.java

@@ -0,0 +1,145 @@
+package com.commafeed.backend.service;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import com.commafeed.CommaFeedApplication;
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.dao.FeedCategoryDAO;
+import com.commafeed.backend.dao.FeedSubscriptionDAO;
+import com.commafeed.backend.dao.UserDAO;
+import com.commafeed.backend.dao.UserRoleDAO;
+import com.commafeed.backend.dao.UserSettingsDAO;
+import com.commafeed.backend.model.User;
+import com.commafeed.backend.model.UserRole;
+import com.commafeed.backend.model.UserRole.Role;
+import com.commafeed.backend.service.internal.PostLoginActivities;
+import com.google.common.base.Preconditions;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class UserService {
+
+	private final FeedCategoryDAO feedCategoryDAO;
+	private final FeedSubscriptionDAO feedSubscriptionDAO;
+	private final UserDAO userDAO;
+	private final UserRoleDAO userRoleDAO;
+	private final UserSettingsDAO userSettingsDAO;
+
+	private final PasswordEncryptionService encryptionService;
+	private final CommaFeedConfiguration config;
+
+	private final PostLoginActivities postLoginActivities;
+
+	/**
+	 * try to log in with given credentials
+	 */
+	public Optional<User> login(String nameOrEmail, String password) {
+		if (nameOrEmail == null || password == null) {
+			return Optional.empty();
+		}
+
+		User user = userDAO.findByName(nameOrEmail);
+		if (user == null) {
+			user = userDAO.findByEmail(nameOrEmail);
+		}
+		if (user != null && !user.isDisabled()) {
+			boolean authenticated = encryptionService.authenticate(password, user.getPassword(), user.getSalt());
+			if (authenticated) {
+				performPostLoginActivities(user);
+				return Optional.of(user);
+			}
+		}
+		return Optional.empty();
+	}
+
+	/**
+	 * try to log in with given api key
+	 */
+	public Optional<User> login(String apiKey) {
+		if (apiKey == null) {
+			return Optional.empty();
+		}
+
+		User user = userDAO.findByApiKey(apiKey);
+		if (user != null && !user.isDisabled()) {
+			performPostLoginActivities(user);
+			return Optional.of(user);
+		}
+		return Optional.empty();
+	}
+
+	/**
+	 * should triggers after successful login
+	 */
+	public void performPostLoginActivities(User user) {
+		postLoginActivities.executeFor(user);
+	}
+
+	public User register(String name, String password, String email, Collection<Role> roles) {
+		return register(name, password, email, roles, false);
+	}
+
+	public User register(String name, String password, String email, Collection<Role> roles, boolean forceRegistration) {
+
+		if (!forceRegistration) {
+			Preconditions.checkState(config.getApplicationSettings().getAllowRegistrations(),
+					"Registrations are closed on this CommaFeed instance");
+		}
+
+		Preconditions.checkArgument(userDAO.findByName(name) == null, "Name already taken");
+		if (StringUtils.isNotBlank(email)) {
+			Preconditions.checkArgument(userDAO.findByEmail(email) == null, "Email already taken");
+		}
+
+		User user = new User();
+		byte[] salt = encryptionService.generateSalt();
+		user.setName(name);
+		user.setEmail(email);
+		user.setCreated(new Date());
+		user.setSalt(salt);
+		user.setPassword(encryptionService.getEncryptedPassword(password, salt));
+		userDAO.saveOrUpdate(user);
+		for (Role role : roles) {
+			userRoleDAO.saveOrUpdate(new UserRole(user, role));
+		}
+		return user;
+	}
+
+	public void createAdminUser() {
+		register(CommaFeedApplication.USERNAME_ADMIN, "admin", "admin@commafeed.com", Arrays.asList(Role.ADMIN, Role.USER), true);
+	}
+
+	public void createDemoUser() {
+		register(CommaFeedApplication.USERNAME_DEMO, "demo", "demo@commafeed.com", Arrays.asList(Role.USER), true);
+	}
+
+	public void unregister(User user) {
+		userSettingsDAO.delete(userSettingsDAO.findByUser(user));
+		userRoleDAO.delete(userRoleDAO.findAll(user));
+		feedSubscriptionDAO.delete(feedSubscriptionDAO.findAll(user));
+		feedCategoryDAO.delete(feedCategoryDAO.findAll(user));
+		userDAO.delete(user);
+	}
+
+	public String generateApiKey(User user) {
+		byte[] key = encryptionService.getEncryptedPassword(UUID.randomUUID().toString(), user.getSalt());
+		return DigestUtils.sha1Hex(key);
+	}
+
+	public Set<Role> getRoles(User user) {
+		return userRoleDAO.findRoles(user);
+	}
+}

commafeed-server/src/main/java/com/commafeed/backend/service/internal/PostLoginActivities.java

@@ -0,0 +1,46 @@
+package com.commafeed.backend.service.internal;
+
+import java.util.Date;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.apache.commons.lang3.time.DateUtils;
+
+import com.commafeed.CommaFeedConfiguration;
+import com.commafeed.backend.dao.UserDAO;
+import com.commafeed.backend.model.User;
+import com.commafeed.backend.service.FeedSubscriptionService;
+
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(onConstructor = @__({ @Inject }))
+@Singleton
+public class PostLoginActivities {
+
+	private final UserDAO userDAO;
+	private final FeedSubscriptionService feedSubscriptionService;
+	private final CommaFeedConfiguration config;
+
+	public void executeFor(User user) {
+		Date lastLogin = user.getLastLogin();
+		Date now = new Date();
+
+		boolean saveUser = false;
+		// only update lastLogin field every hour in order to not
+		// invalidate the cache every time someone logs in
+		if (lastLogin == null || lastLogin.before(DateUtils.addHours(now, -1))) {
+			user.setLastLogin(now);
+			saveUser = true;
+		}
+		if (config.getApplicationSettings().getHeavyLoad() && user.shouldRefreshFeedsAt(now)) {
+			feedSubscriptionService.refreshAll(user);
+			user.setLastFullRefresh(now);
+			saveUser = true;
+		}
+		if (saveUser) {
+			userDAO.saveOrUpdate(user);
+		}
+	}
+
+}