Implemented paged operations and used for database cleanup tasks.

Author: strangeweaver

openid-connect-common/src/main/java/org/mitre/data/AbstractPageOperationTemplate.java

@@ -0,0 +1,160 @@
+package org.mitre.data;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Abstract class for performing an operation on a potentially large
+ * number of items by paging through the items in discreet chunks.
+ *
+ * @param <T> the type parameter
+ * @author Colm Smyth.
+ */
+public abstract class AbstractPageOperationTemplate<T> {
+
+ private static final Logger logger = LoggerFactory.getLogger(AbstractPageOperationTemplate.class);
+
+ private static int DEFAULT_MAX_PAGES = 1000;
+ private static long DEFAULT_MAX_TIME_MILLIS = 600000L; //10 Minutes
+
+ /**
+ * int specifying the maximum number of
+ * pages which should be fetched before
+ * execution should terminate
+ */
+ private int maxPages;
+
+ /**
+ * long specifying the maximum execution time
+ * in milliseconds
+ */
+ private long maxTime;
+
+ /**
+ * boolean specifying whether or not Exceptions
+ * incurred performing the operation should be
+ * swallowed during execution default true.
+ */
+ private boolean swallowExceptions = true;
+
+
+ /**
+ * default constructor which sets the value of
+ * maxPages and maxTime to DEFAULT_MAX_PAGES and
+ * DEFAULT_MAX_TIME_MILLIS respectively
+ */
+ public AbstractPageOperationTemplate(){
+ this(DEFAULT_MAX_PAGES, DEFAULT_MAX_TIME_MILLIS);
+ }
+
+
+ /**
+ * Instantiates a new AbstractPageOperationTemplate with the
+ * given maxPages and maxTime
+ *
+ * @param maxPages the maximum number of pages to fetch.
+ * @param maxTime the maximum execution time.
+ */
+ public AbstractPageOperationTemplate(int maxPages, long maxTime){
+ this.maxPages = maxPages;
+ this.maxTime = maxTime;
+ }
+
+
+ /**
+ * Execute the operation on each member of a page of results
+ * retrieved through the fetch method. the method will execute
+ * until either the maxPages or maxTime limit is reached or until
+ * the fetch method returns no more results. Exceptions thrown
+ * performing the operation on the item will be swallowed if the
+ * swallowException (default true) field is set true.
+ */
+ public void execute(){
+ logger.info("Starting execution of paged operation. maximum time: " + maxTime
+ + " maximum pages: " + maxPages);
+
+ long startTime = System.currentTimeMillis();
+ long executionTime = 0;
+ int i = 0;
+
+ int exceptionsSwallowedCount = 0;
+ int operationsCompleted = 0;
+ Set<String> exceptionsSwallowedClasses = new HashSet<String>();
+
+
+ while (i< maxPages && executionTime < maxTime){
+ Collection<T> page = fetchPage();
+ if(page == null || page.size() == 0){
+ break;
+ }
+
+ for (T item : page) {
+ try {
+ doOperation(item);
+ operationsCompleted++;
+ } catch (Exception e){
+ if(swallowExceptions){
+ exceptionsSwallowedCount++;
+ exceptionsSwallowedClasses.add(e.getClass().getName());
+ logger.debug("Swallowing exception " + e.getMessage(), e);
+ } else {
+ logger.debug("Rethrowing exception " + e.getMessage());
+ throw e;
+ }
+ }
+ }
+
+ i++;
+ executionTime = System.currentTimeMillis() - startTime;
+ }
+
+ logger.info("Paged operation run completed " + operationsCompleted + " swallowed " + exceptionsSwallowedCount + " exceptions");
+ for(String className: exceptionsSwallowedClasses) {
+ logger.warn("Paged operation swallowed at least one exception of type " + className);
+ }
+ }
+
+ /**
+ * method responsible for fetching
+ * a page of items.
+ *
+ * @return the collection of items
+ */
+ public abstract Collection<T> fetchPage();
+
+ /**
+ * method responsible for performing desired
+ * operation on a fetched page item.
+ *
+ * @param item the item
+ */
+ protected abstract void doOperation(T item);
+
+ public int getMaxPages() {
+ return maxPages;
+ }
+
+ public void setMaxPages(int maxPages) {
+ this.maxPages = maxPages;
+ }
+
+ public long getMaxTime() {
+ return maxTime;
+ }
+
+ public void setMaxTime(long maxTime) {
+ this.maxTime = maxTime;
+ }
+
+ public boolean isSwallowExceptions() {
+ return swallowExceptions;
+ }
+
+ public void setSwallowExceptions(boolean swallowExceptions) {
+ this.swallowExceptions = swallowExceptions;
+ }
+}

openid-connect-common/src/main/java/org/mitre/data/DefaultPageCriteria.java

@@ -0,0 +1,35 @@
+package org.mitre.data;
+
+/**
+ * Default implementation of PageCriteria which specifies
+ * both page to be retrieved and page size in the constructor.
+ *
+ * @author Colm Smyth
+ */
+public class DefaultPageCriteria implements PageCriteria {
+
+ private static final int DEFAULT_PAGE_NUMBER = 0;
+ private static final int DEFAULT_PAGE_SIZE = 100;
+
+ private int pageNumber;
+ private int pageSize;
+
+ public DefaultPageCriteria(){
+ this(DEFAULT_PAGE_NUMBER, DEFAULT_PAGE_SIZE);
+ }
+
+ public DefaultPageCriteria(int pageNumber, int pageSize) {
+ this.pageNumber = pageNumber;
+ this.pageSize = pageSize;
+ }
+
+ @Override
+ public int getPageNumber() {
+ return pageNumber;
+ }
+
+ @Override
+ public int getPageSize() {
+ return pageSize;
+ }
+}

openid-connect-common/src/main/java/org/mitre/data/PageCriteria.java

@@ -0,0 +1,13 @@
+package org.mitre.data;
+
+/**
+ * Interface which defines page criteria for use in
+ * a repository operation.
+ *
+ * @author Colm Smyth
+ */
+public interface PageCriteria {
+
+ public int getPageNumber();
+ public int getPageSize();
+}

openid-connect-common/src/main/java/org/mitre/oauth2/repository/AuthenticationHolderRepository.java

@@ -18,6 +18,7 @@
 
 import java.util.List;
 
+import org.mitre.data.PageCriteria;
 import org.mitre.oauth2.model.AuthenticationHolderEntity;
 
 public interface AuthenticationHolderRepository {
@@ -31,5 +32,5 @@ public interface AuthenticationHolderRepository {
 
 public List<AuthenticationHolderEntity> getOrphanedAuthenticationHolders();
 
-
+ public List<AuthenticationHolderEntity> getOrphanedAuthenticationHolders(PageCriteria pageCriteria);
 }

openid-connect-common/src/main/java/org/mitre/oauth2/repository/AuthorizationCodeRepository.java

@@ -18,6 +18,7 @@
 
 import java.util.Collection;
 
+import org.mitre.data.PageCriteria;
 import org.mitre.oauth2.model.AuthorizationCodeEntity;
 
 /**
@@ -56,4 +57,10 @@ public interface AuthorizationCodeRepository {
  */
 public Collection<AuthorizationCodeEntity> getExpiredCodes();
 
+ /**
+ * @return A collection of all expired codes, limited by the given
+ * PageCriteria.
+ */
+ public Collection<AuthorizationCodeEntity> getExpiredCodes(PageCriteria pageCriteria);
+
 }

openid-connect-common/src/main/java/org/mitre/oauth2/repository/OAuth2TokenRepository.java

@@ -19,6 +19,7 @@
 import java.util.List;
 import java.util.Set;
 
+import org.mitre.data.PageCriteria;
 import org.mitre.oauth2.model.ClientDetailsEntity;
 import org.mitre.oauth2.model.OAuth2AccessTokenEntity;
 import org.mitre.oauth2.model.OAuth2RefreshTokenEntity;
@@ -57,8 +58,12 @@ public interface OAuth2TokenRepository {
 
 public Set<OAuth2AccessTokenEntity> getAllExpiredAccessTokens();
 
+ public Set<OAuth2AccessTokenEntity> getAllExpiredAccessTokens(PageCriteria pageCriteria);
+
 public Set<OAuth2RefreshTokenEntity> getAllExpiredRefreshTokens();
 
+ public Set<OAuth2RefreshTokenEntity> getAllExpiredRefreshTokens(PageCriteria pageCriteria);
+
 public Set<OAuth2AccessTokenEntity> getAccessTokensForResourceSet(ResourceSet rs);
 
  /**

openid-connect-common/src/main/java/org/mitre/util/jpa/JpaUtil.java

@@ -16,17 +16,20 @@
  *******************************************************************************/
 package org.mitre.util.jpa;
 
+import org.mitre.data.PageCriteria;
+
 import java.util.List;
 
 import javax.persistence.EntityManager;
+import javax.persistence.TypedQuery;
 
 /**
  * @author mfranklin
  * Date: 4/28/11
  * Time: 2:13 PM
  */
 public class JpaUtil {
-public static <T> T getSingleResult(List<T> list) {
+ public static <T> T getSingleResult(List<T> list) {
 switch(list.size()) {
 case 0:
 return null;
@@ -37,6 +40,25 @@ public static <T> T getSingleResult(List<T> list) {
 }
 }
 
+
+ /**
+ * Get a page of results from the specified TypedQuery
+ * by using the given PageCriteria to limit the query
+ * results. The PageCriteria will override any size or
+ * offset already specified on the query.
+ *
+ * @param <T> the type parameter
+ * @param query the query
+ * @param pageCriteria the page criteria
+ * @return the list
+ */
+ public static <T> List<T> getResultPage(TypedQuery<T> query, PageCriteria pageCriteria){
+ query.setMaxResults(pageCriteria.getPageSize());
+ query.setFirstResult(pageCriteria.getPageNumber()*pageCriteria.getPageSize());
+
+ return query.getResultList();
+ }
+
 public static <T, I> T saveOrUpdate(I id, EntityManager entityManager, T entity) {
 T tmp = entityManager.merge(entity);
 entityManager.flush();