Changeset 5616


Ignore:
Timestamp:
08/29/14 08:36:39 (10 years ago)
Author:
Twan Goosen
Message:

Extracted interface from VirtualCollectionRegistry.
Created test for VirtualCollectionResource? of REST service that uses this interface for mocking.

Location:
VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src
Files:
2 added
2 edited
1 copied

Legend:

Unmodified
Added
Removed

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/VirtualCollectionRegistry.java

    r5591 r5616  
    11package eu.clarin.cmdi.virtualcollectionregistry;
    22
    3 import eu.clarin.cmdi.oai.provider.impl.OAIProvider;
    43import eu.clarin.cmdi.virtualcollectionregistry.model.User;
    5 import eu.clarin.cmdi.virtualcollectionregistry.model.User_;
    64import eu.clarin.cmdi.virtualcollectionregistry.model.VirtualCollection;
    75import eu.clarin.cmdi.virtualcollectionregistry.model.VirtualCollectionList;
    8 import eu.clarin.cmdi.virtualcollectionregistry.pid.PersistentIdentifier;
    9 import eu.clarin.cmdi.virtualcollectionregistry.pid.PersistentIdentifierProvider;
    10 import eu.clarin.cmdi.virtualcollectionregistry.query.ParsedQuery;
    11 import eu.clarin.cmdi.virtualcollectionregistry.service.VirtualCollectionValidator;
    126import java.security.Principal;
    13 import java.util.Date;
    147import java.util.List;
    15 import java.util.concurrent.Executors;
    16 import java.util.concurrent.ScheduledExecutorService;
    17 import java.util.concurrent.ThreadFactory;
    18 import java.util.concurrent.TimeUnit;
    19 import java.util.concurrent.atomic.AtomicBoolean;
    20 import java.util.concurrent.atomic.AtomicInteger;
    21 import javax.persistence.EntityManager;
    22 import javax.persistence.EntityTransaction;
    23 import javax.persistence.LockModeType;
    24 import javax.persistence.NoResultException;
    25 import javax.persistence.TypedQuery;
    26 import javax.persistence.criteria.CriteriaBuilder;
    27 import javax.persistence.criteria.CriteriaQuery;
    28 import javax.persistence.criteria.Order;
    29 import javax.persistence.criteria.Predicate;
    30 import javax.persistence.criteria.Root;
    31 import org.slf4j.Logger;
    32 import org.slf4j.LoggerFactory;
    33 import org.springframework.beans.factory.DisposableBean;
    34 import org.springframework.beans.factory.InitializingBean;
    35 import org.springframework.beans.factory.annotation.Autowired;
    36 import org.springframework.beans.factory.annotation.Qualifier;
    37 import org.springframework.stereotype.Service;
    388
    39 @Service
    40 public class VirtualCollectionRegistry implements InitializingBean, DisposableBean {
    41 
    42     @Autowired
    43     private DataStore datastore; //TODO: replace with Spring managed EM?
    44     @Autowired
    45     private PersistentIdentifierProvider pid_provider;
    46     @Autowired
    47     private OAIProvider oaiProvider;
    48     @Autowired
    49     @Qualifier("creation")
    50     private VirtualCollectionValidator validator;
    51     @Autowired
    52     private AdminUsersService adminUsersService;
    53 
    54     private static final Logger logger
    55             = LoggerFactory.getLogger(VirtualCollectionRegistry.class);
    56     private final AtomicBoolean intialized = new AtomicBoolean(false);
    57     /**
    58      * Scheduled executor service for the maintenance check
    59      *
    60      * @see #maintenance(long)
    61      */
    62     private final ScheduledExecutorService maintenanceExecutor
    63             = createSingleThreadScheduledExecutor("VirtualCollectionRegistry-Maintenance");
    64 
    65     @Override
    66     public void afterPropertiesSet() throws VirtualCollectionRegistryException {
    67         // called by Spring directly after Bean construction
    68         doInitalize();
    69     }
    70 
    71     private void doInitalize() throws VirtualCollectionRegistryException {
    72         if (intialized.get()) {
    73             throw new VirtualCollectionRegistryException("already initialized");
    74         }
    75         logger.info("Initializing virtual collection registry ...");
    76         try {
    77             maintenanceExecutor.scheduleWithFixedDelay(new Runnable() {
    78 
    79                 @Override
    80                 public void run() {
    81                     maintenance(new Date().getTime());
    82                 }
    83             }, 60, 60, TimeUnit.SECONDS);
    84             this.intialized.set(true);
    85             logger.info("virtual collection registry successfully intialized");
    86         } catch (RuntimeException e) {
    87             logger.error("error initalizing virtual collection registry", e);
    88             throw e;
    89         }
    90     }
    91 
    92     @Override
    93     public void destroy() throws VirtualCollectionRegistryException, InterruptedException {
    94         logger.info("Stopping Virtual Collection Registry maintenance schedule");
    95         maintenanceExecutor.shutdown();
    96         if (!maintenanceExecutor.awaitTermination(60, TimeUnit.SECONDS)) {
    97             logger.warn("Timeout while waiting for maintenance thread to terminate, will try to shut down");
    98         }
    99 
    100         logger.info("Shutting down OAI provider");
    101         oaiProvider.shutdown();
    102     }
     9public interface VirtualCollectionRegistry {
    10310
    10411    /**
    … …  
    11219     * @throws VirtualCollectionRegistryException
    11320     */
    114     public long createVirtualCollection(Principal principal,
    115             VirtualCollection vc) throws VirtualCollectionRegistryException {
    116         if (principal == null) {
    117             throw new NullPointerException("principal == null");
    118         }
    119         if (vc == null) {
    120             throw new NullPointerException("vc == null");
    121         }
     21    long createVirtualCollection(Principal principal,
     22            VirtualCollection vc) throws VirtualCollectionRegistryException;
    12223
    123         logger.debug("creating virtual collection");
     24    long updateVirtualCollection(Principal principal, long id,
     25            VirtualCollection vc) throws VirtualCollectionRegistryException;
    12426
    125         validator.validate(vc);
    126         try {
    127             EntityManager em = datastore.getEntityManager();
    128             em.getTransaction().begin();
     27    long deleteVirtualCollection(Principal principal, long id)
     28            throws VirtualCollectionRegistryException;
    12929
    130             // fetch user, if user does not exist create new
    131             User user = fetchUser(em, principal);
    132             if (user == null) {
    133                 user = new User(principal.getName());
    134                 em.persist(user);
    135             }
    136             vc.setOwner(user);
     30    VirtualCollection.State getVirtualCollectionState(long id)
     31            throws VirtualCollectionRegistryException;
    13732
    138             // force new collection to be private
    139             vc.setState(VirtualCollection.State.PRIVATE);
    140 
    141             // store virtual collection
    142             logger.debug("persisting new virtual collection", vc.getId());
    143             em.persist(vc);
    144             em.getTransaction().commit();
    145             logger.debug("virtual collection created (id={})", vc.getId());
    146             return vc.getId();
    147         } catch (Exception e) {
    148             logger.error("error while creating virtual collection", e);
    149             throw new VirtualCollectionRegistryException(
    150                     "error while creating virtual collection", e);
    151         }
    152     }
    153 
    154     public long updateVirtualCollection(Principal principal, long id,
    155             VirtualCollection vc) throws VirtualCollectionRegistryException {
    156         if (principal == null) {
    157             throw new NullPointerException("principal == null");
    158         }
    159         if (id <= 0) {
    160             throw new IllegalArgumentException("id <= 0");
    161         }
    162         if (vc == null) {
    163             throw new NullPointerException("vc == null");
    164         }
    165 
    166         logger.debug("updating virtual collection (id={})", id);
    167 
    168         validator.validate(vc);
    169 
    170         try {
    171             EntityManager em = datastore.getEntityManager();
    172             em.getTransaction().begin();
    173             VirtualCollection c = em.find(VirtualCollection.class,
    174                     Long.valueOf(id), LockModeType.PESSIMISTIC_WRITE);
    175             /*
    176              * Do not check for deleted state here, as we might want to
    177              * resurrect deleted virtual collections.
    178              */
    179             if (c == null) {
    180                 logger.debug("virtual collection (id={}) not found", id);
    181                 throw new VirtualCollectionNotFoundException(id);
    182             }
    183             if (!isAllowedToModify(principal, c)) {
    184                 throw new VirtualCollectionRegistryPermissionException(
    185                         "permission denied for user \""
    186                         + principal.getName() + "\"");
    187             }
    188 
    189             // update virtual collection
    190             c.updateFrom(vc);
    191 
    192             validator.validate(c);
    193             em.merge(c);
    194             em.getTransaction().commit();
    195             logger.debug("updated virtual collection (id={})", vc.getId());
    196             return c.getId();
    197         } catch (VirtualCollectionRegistryException e) {
    198             logger.warn("failed updating virtual collecion (id={}): {}", id,
    199                     e.getMessage());
    200             throw e;
    201         } catch (Exception e) {
    202             logger.error("error while updating virtual collection", e);
    203             throw new VirtualCollectionRegistryException(
    204                     "error while updating virtual collection", e);
    205         }
    206     }
    207 
    208     public long deleteVirtualCollection(Principal principal, long id)
    209             throws VirtualCollectionRegistryException {
    210         if (principal == null) {
    211             throw new NullPointerException("principal == null");
    212         }
    213         if (id <= 0) {
    214             throw new IllegalArgumentException("id <= 0");
    215         }
    216 
    217         logger.debug("deleting virtual collection (id={})", id);
    218 
    219         try {
    220             EntityManager em = datastore.getEntityManager();
    221             em.getTransaction().begin();
    222             VirtualCollection vc = em.find(VirtualCollection.class,
    223                     Long.valueOf(id), LockModeType.PESSIMISTIC_WRITE);
    224             if ((vc == null) || vc.isDeleted()) {
    225                 logger.debug("virtual collection (id={}) not found", id);
    226                 throw new VirtualCollectionNotFoundException(id);
    227             }
    228             if (!isAllowedToModify(principal, vc)) {
    229                 logger.debug("virtual collection (id={}) not owned by "
    230                         + "user '{}'", id, principal.getName());
    231                 throw new VirtualCollectionRegistryPermissionException(
    232                         "permission denied for user \""
    233                         + principal.getName() + "\"");
    234             }
    235             if (!vc.isPrivate()) {
    236                 logger.debug("virtual collection (id={}) cannot be "
    237                         + "deleted (invalid state)", id);
    238                 throw new VirtualCollectionRegistryPermissionException(
    239                         "virtual collection cannot be deleted");
    240             }
    241             vc.setState(VirtualCollection.State.DELETED);
    242             em.getTransaction().commit();
    243             return vc.getId();
    244         } catch (VirtualCollectionRegistryException e) {
    245             logger.debug("failed deleting virtual collecion (id={}): {}", id,
    246                     e.getMessage());
    247             throw e;
    248         } catch (Exception e) {
    249             logger.error("error while deleting virtual collection", e);
    250             throw new VirtualCollectionRegistryException(
    251                     "error while deleting virtual collection", e);
    252         }
    253     }
    254 
    255     public VirtualCollection.State getVirtualCollectionState(long id)
    256             throws VirtualCollectionRegistryException {
    257         if (id <= 0) {
    258             throw new IllegalArgumentException("id <= 0");
    259         }
    260 
    261         logger.debug("retrieve virtual collection state (id={})", id);
    262 
    263         try {
    264             EntityManager em = datastore.getEntityManager();
    265             em.getTransaction().begin();
    266             VirtualCollection vc
    267                     = em.find(VirtualCollection.class, Long.valueOf(id));
    268             em.getTransaction().commit();
    269             if ((vc == null) || vc.isDeleted()) {
    270                 logger.debug("virtual collection (id={}) not found", id);
    271                 throw new VirtualCollectionNotFoundException(id);
    272             }
    273             return vc.getState();
    274         } catch (VirtualCollectionRegistryException e) {
    275             throw e;
    276         } catch (Exception e) {
    277             logger.error(
    278                     "error while retrieving state of virtual collection", e);
    279             throw new VirtualCollectionRegistryException(
    280                     "error while retrieving state of virtual collection", e);
    281         }
    282     }
    283 
    284     public void setVirtualCollectionState(Principal principal, long id,
     33    void setVirtualCollectionState(Principal principal, long id,
    28534            VirtualCollection.State state)
    286             throws VirtualCollectionRegistryException {
    287         if (principal == null) {
    288             throw new NullPointerException("principal == null");
    289         }
    290         if (id <= 0) {
    291             throw new IllegalArgumentException("id <= 0");
    292         }
    293         if (state == null) {
    294             throw new NullPointerException("state == null");
    295         }
    296         if ((state != VirtualCollection.State.PUBLIC_PENDING)
    297                 && (state != VirtualCollection.State.PRIVATE)) {
    298             throw new IllegalArgumentException(
    299                     "only PUBLIC_PENDING or PRIVATE are allowed");
    300         }
    301 
    302         logger.debug("setting state virtual collection state (id={}) to '{}'",
    303                 id, state);
    304 
    305         try {
    306             EntityManager em = datastore.getEntityManager();
    307             em.getTransaction().begin();
    308             VirtualCollection vc = em.find(VirtualCollection.class,
    309                     Long.valueOf(id), LockModeType.PESSIMISTIC_WRITE);
    310             if ((vc == null) || vc.isDeleted()) {
    311                 logger.debug("virtual collection (id={}) not found", id);
    312                 throw new VirtualCollectionNotFoundException(id);
    313             }
    314             if (!isAllowedToModify(principal, vc)) {
    315                 logger.debug("virtual collection (id={}) not owned by "
    316                         + "user '{}'", id, principal.getName());
    317                 throw new VirtualCollectionRegistryPermissionException(
    318                         "permission denied for user \""
    319                         + principal.getName() + "\"");
    320             }
    321 
    322             /*
    323              * XXX: deny update from public to private?
    324              */
    325             boolean update = false;
    326             switch (state) {
    327                 case PRIVATE:
    328                     update = vc.getState() != state;
    329                     break;
    330                 case PUBLIC_PENDING:
    331                     update = vc.getState() != VirtualCollection.State.PUBLIC;
    332                     break;
    333                 default:
    334                     /* silence warning; update will stay false */
    335                     break;
    336             }
    337             if (update) {
    338                 vc.setState(state);
    339                 em.persist(vc);
    340             }
    341             em.getTransaction().commit();
    342         } catch (VirtualCollectionRegistryException e) {
    343             throw e;
    344         } catch (Exception e) {
    345             logger.error(
    346                     "error while setting state of virtual collection", e);
    347             throw new VirtualCollectionRegistryException(
    348                     "error while setting state of virtual collection", e);
    349         }
    350     }
     35            throws VirtualCollectionRegistryException;
    35136
    35237    /**
    … …  
    35742     * the specified identifier exists
    35843     */
    359     public VirtualCollection retrieveVirtualCollection(long id)
    360             throws VirtualCollectionRegistryException {
    361         if (id <= 0) {
    362             throw new IllegalArgumentException("id <= 0");
    363         }
     44    VirtualCollection retrieveVirtualCollection(long id)
     45            throws VirtualCollectionRegistryException;
    36446
    365         logger.debug("retrieve virtual collection (id={})", id);
     47    VirtualCollectionList getVirtualCollections(String query,
     48            int offset, int count) throws VirtualCollectionRegistryException;
    36649
    367         try {
    368             EntityManager em = datastore.getEntityManager();
    369             em.getTransaction().begin();
    370             VirtualCollection vc
    371                     = em.find(VirtualCollection.class, Long.valueOf(id));
    372             em.getTransaction().commit();
    373             if ((vc == null) || vc.isDeleted()) {
    374                 logger.debug("virtual collection (id={}) not found", id);
    375                 throw new VirtualCollectionNotFoundException(id);
    376             }
    377             logger.debug("virtual collection retrieved (id={})", id);
    378             return vc;
    379         } catch (VirtualCollectionRegistryException e) {
    380             throw e;
    381         } catch (Exception e) {
    382             logger.error("error while retrieving virtual collection", e);
    383             throw new VirtualCollectionRegistryException(
    384                     "error while retrieving virtual collection", e);
    385         }
    386     }
     50    VirtualCollectionList getVirtualCollections(Principal principal,
     51            String query, int offset, int count)
     52            throws VirtualCollectionRegistryException;
    38753
    388     public VirtualCollectionList getVirtualCollections(String query,
    389             int offset, int count) throws VirtualCollectionRegistryException {
    390         EntityManager em = datastore.getEntityManager();
    391         try {
    392             em.getTransaction().begin();
     54    int getVirtualCollectionCount(QueryOptions options)
     55            throws VirtualCollectionRegistryException;
    39356
    394             // setup queries
    395             TypedQuery<Long> cq = null;
    396             TypedQuery<VirtualCollection> q = null;
    397             if (query != null) {
    398                 ParsedQuery parsedQuery = ParsedQuery.parseQuery(query);
    399                 if (logger.isDebugEnabled()) {
    400                     logger.debug(parsedQuery.getPrettyPrinted());
    401                 }
    402                 cq = parsedQuery.getCountQuery(em, null, VirtualCollection.State.PUBLIC);
    403                 q = parsedQuery.getQuery(em, null, VirtualCollection.State.PUBLIC);
    404             } else {
    405                 cq = em.createNamedQuery("VirtualCollection.countAllPublic",
    406                         Long.class);
    407                 q = em.createNamedQuery("VirtualCollection.findAllPublic",
    408                         VirtualCollection.class);
    409             }
     57    List<User> getUsers();
    41058
    411             // commence query ...
    412             List<VirtualCollection> results = null;
    413             long totalCount = cq.getSingleResult();
     59    List<VirtualCollection> getVirtualCollections(
     60            int first, int count, QueryOptions options)
     61            throws VirtualCollectionRegistryException;
    41462
    415             // optimization; don't query, if we won't get any results
    416             /*
    417              *  FIXME: offset == -1 is temporary hack for just fetching
    418              *  total count; re-factor to have fetch-count and fetch-data
    419              *  methods!
    420              */
    421             if ((totalCount > 0) && (offset > -1)) {
    422                 if (offset > 0) {
    423                     q.setFirstResult(offset);
    424                 }
    425                 if (count > 0) {
    426                     q.setMaxResults(count);
    427                 }
    428                 results = q.getResultList();
    429             }
    430             return new VirtualCollectionList(results, offset, (int) totalCount);
    431         } catch (Exception e) {
    432             logger.error("error while enumerating virtual collections", e);
    433             throw new VirtualCollectionRegistryException(
    434                     "error while enumerating virtual collections", e);
    435         } finally {
    436             EntityTransaction tx = em.getTransaction();
    437             if ((tx != null) && !tx.getRollbackOnly()) {
    438                 tx.commit();
    439             }
    440         }
    441     }
    442 
    443     public VirtualCollectionList getVirtualCollections(Principal principal,
    444             String query, int offset, int count)
    445             throws VirtualCollectionRegistryException {
    446         if (principal == null) {
    447             throw new NullPointerException("principal == null");
    448         }
    449         EntityManager em = datastore.getEntityManager();
    450         try {
    451             List<VirtualCollection> results = null;
    452             long totalCount = 0;
    453 
    454             em.getTransaction().begin();
    455 
    456             /*
    457              * fetch user. if user is not found, he has not yet registered any
    458              * virtual collections, so just return an empty list
    459              */
    460             User user = fetchUser(em, principal);
    461             if (user != null) {
    462                 // setup queries
    463                 TypedQuery<Long> cq = null;
    464                 TypedQuery<VirtualCollection> q = null;
    465                 if (query != null) {
    466                     ParsedQuery parsedQuery = ParsedQuery.parseQuery(query);
    467                     if (logger.isDebugEnabled()) {
    468                         logger.debug(parsedQuery.getPrettyPrinted());
    469                     }
    470                     cq = parsedQuery.getCountQuery(em, user, null);
    471                     q = parsedQuery.getQuery(em, user, null);
    472                 } else {
    473                     cq = em.createNamedQuery("VirtualCollection.countByOwner",
    474                             Long.class);
    475                     cq.setParameter("owner", user);
    476                     q = em.createNamedQuery("VirtualCollection.findByOwner",
    477                             VirtualCollection.class);
    478                     q.setParameter("owner", user);
    479                 }
    480 
    481                 // commence query ...
    482                 totalCount = cq.getSingleResult();
    483 
    484                 // optimization; don't query, if we won't get any results
    485                 /*
    486                  *  FIXME: offset == -1 is temporary hack for just fetching
    487                  *  total count; re-factor to have fetch-count and fetch-data
    488                  *  methods!
    489                  */
    490                 if ((totalCount > 0) && (offset > -1)) {
    491                     if (offset > 0) {
    492                         q.setFirstResult(offset);
    493                     }
    494                     if (count > 0) {
    495                         q.setMaxResults(count);
    496                     }
    497                     results = q.getResultList();
    498                 }
    499             }
    500             return new VirtualCollectionList(results, offset, (int) totalCount);
    501         } catch (Exception e) {
    502             logger.error("error while enumerating virtual collections", e);
    503             throw new VirtualCollectionRegistryException(
    504                     "error while enumerating virtual collections", e);
    505         } finally {
    506             EntityTransaction tx = em.getTransaction();
    507             if ((tx != null) && !tx.getRollbackOnly()) {
    508                 tx.commit();
    509             }
    510         }
    511     }
    512 
    513     public int getVirtualCollectionCount(QueryOptions options)
    514             throws VirtualCollectionRegistryException {
    515         logger.trace("Getting virtual collection count");
    516         EntityManager em = datastore.getEntityManager();
    517         try {
    518             CriteriaBuilder cb = em.getCriteriaBuilder();
    519             CriteriaQuery<Long> cq = cb.createQuery(Long.class);
    520             Root<VirtualCollection> root = cq.from(VirtualCollection.class);
    521             if (options != null) {
    522                 Predicate where = options.getWhere(cb, cq, root);
    523                 if (where != null) {
    524                     cq.where(where);
    525                 }
    526             }
    527             em.getTransaction().begin();
    528             TypedQuery<Long> query
    529                     = em.createQuery(cq.select(cb.count(root)));
    530             final long count = query.getSingleResult();
    531             if (count >= Integer.MAX_VALUE) {
    532                 throw new VirtualCollectionRegistryException(
    533                         "resultset too large");
    534             }
    535             logger.trace("Counted {} collections", count);
    536             return (int) count;
    537         } catch (Exception e) {
    538             logger.error("error while counting virtual collections", e);
    539             throw new VirtualCollectionRegistryException(
    540                     "error while counting virtual collections", e);
    541         } finally {
    542             EntityTransaction tx = em.getTransaction();
    543             if ((tx != null) && tx.isActive() && !tx.getRollbackOnly()) {
    544                 tx.commit();
    545             }
    546         }
    547     }
    548 
    549     public List<User> getUsers() {
    550         final EntityManager em = datastore.getEntityManager();
    551         try {
    552             final CriteriaBuilder cb = em.getCriteriaBuilder();
    553             final CriteriaQuery<User> cq = cb.createQuery(User.class);
    554             final Root<User> root = cq.from(User.class);
    555 
    556             // select all users, sort by display name then name
    557             cq.select(root);
    558             cq.orderBy(
    559                     cb.asc(root.get(User_.displayName)),
    560                     cb.asc(root.get(User_.name)));
    561 
    562             em.getTransaction().begin();
    563             final TypedQuery<User> query = em.createQuery(cq);
    564             return query.getResultList();
    565         } finally {
    566             EntityTransaction tx = em.getTransaction();
    567             if ((tx != null) && tx.isActive() && !tx.getRollbackOnly()) {
    568                 tx.commit();
    569             }
    570         }
    571     }
    572 
    573     public List<VirtualCollection> getVirtualCollections(
    574             int first, int count, QueryOptions options)
    575             throws VirtualCollectionRegistryException {
    576         EntityManager em = datastore.getEntityManager();
    577         try {
    578             CriteriaBuilder cb = em.getCriteriaBuilder();
    579             CriteriaQuery<VirtualCollection> cq
    580                     = cb.createQuery(VirtualCollection.class);
    581             Root<VirtualCollection> root = cq.from(VirtualCollection.class);
    582             if (options != null) {
    583                 final Predicate where = options.getWhere(cb, cq, root);
    584                 if (where != null) {
    585                     cq.where(where);
    586                 }
    587                 final Order[] order = options.getOrderBy(cb, root);
    588                 if (order != null) {
    589                     cq.orderBy(order);
    590                 }
    591             }
    592             em.getTransaction().begin();
    593             TypedQuery<VirtualCollection> query
    594                     = em.createQuery(cq.select(root));
    595             if (first > -1) {
    596                 query.setFirstResult(first);
    597             }
    598             if (count > 0) {
    599                 query.setMaxResults(count);
    600             }
    601             return query.getResultList();
    602         } catch (Exception e) {
    603             logger.error("error while fetching virtual collections", e);
    604             throw new VirtualCollectionRegistryException(
    605                     "error while fetching virtual collections", e);
    606         } finally {
    607             EntityTransaction tx = em.getTransaction();
    608             if ((tx != null) && tx.isActive() && !tx.getRollbackOnly()) {
    609                 tx.commit();
    610             }
    611         }
    612     }
    613 
    614     private void maintenance(long now) {
    615         logger.debug("Maintenance check");
    616         // allocate persistent identifier roughly after 30 seconds
    617         final Date nowDateAlloc = new Date(now - 30 * 1000);
    618         // (for now) purge deleted collection roughly after 30 seconds
    619         final Date nowDatePurge = new Date(now - 30 * 1000);
    620 
    621         EntityManager em = datastore.getEntityManager();
    622         try {
    623             /*
    624              * delayed allocation of persistent identifier
    625              */
    626             em.getTransaction().begin();
    627             TypedQuery<VirtualCollection> q
    628                     = em.createNamedQuery("VirtualCollection.findAllByState",
    629                             VirtualCollection.class);
    630             q.setParameter("state", VirtualCollection.State.PUBLIC_PENDING);
    631             q.setParameter("date", nowDateAlloc);
    632             q.setLockMode(LockModeType.PESSIMISTIC_WRITE);
    633             for (VirtualCollection vc : q.getResultList()) {
    634                 if (vc.getPersistentIdentifier() == null) {
    635                     PersistentIdentifier pid = pid_provider.createIdentifier(vc);
    636                     vc.setPersistentIdentifier(pid);
    637                 }
    638                 vc.setState(VirtualCollection.State.PUBLIC);
    639                 em.persist(vc);
    640                 logger.info("assigned pid (identifer='{}') to virtual"
    641                         + "collection (id={})",
    642                         vc.getPersistentIdentifier().getIdentifier(),
    643                         vc.getId());
    644             }
    645             em.getTransaction().commit();
    646 
    647             /*
    648              * delayed purging of deleted virtual collections
    649              */
    650             em.getTransaction().begin();
    651             q.setParameter("state", VirtualCollection.State.DELETED);
    652             q.setParameter("date", nowDatePurge);
    653             q.setLockMode(LockModeType.PESSIMISTIC_WRITE);
    654             for (VirtualCollection vc : q.getResultList()) {
    655                 vc.setState(VirtualCollection.State.DEAD);
    656                 em.remove(vc);
    657                 logger.debug("purged virtual collection (id={})", vc.getId());
    658             }
    659             em.getTransaction().commit();
    660         } catch (VirtualCollectionRegistryException e) {
    661             logger.error("error while doing maintenance", e);
    662         } finally {
    663             datastore.closeEntityManager();
    664         }
    665     }
    666 
    667     private static User fetchUser(EntityManager em, Principal principal) {
    668         User user = null;
    669         try {
    670             TypedQuery<User> q
    671                     = em.createNamedQuery("User.findByName", User.class);
    672             q.setParameter("name", principal.getName());
    673             user = q.getSingleResult();
    674         } catch (NoResultException e) {
    675             /* IGNORE */
    676         }
    677         return user;
    678     }
    679 
    680     /**
    681      * Creates a single thread scheduled executor with the specified thread name
    682      *
    683      * @param threadName name for new executor threads
    684      * @return
    685      */
    686     private static ScheduledExecutorService createSingleThreadScheduledExecutor(final String threadName) {
    687         return Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
    688             // decorate default thread factory so that we can provide a
    689             // custom thread name
    690             final AtomicInteger i = new AtomicInteger(0);
    691 
    692             @Override
    693             public Thread newThread(Runnable r) {
    694                 final Thread thread = Executors.defaultThreadFactory().newThread(r);
    695                 thread.setName(threadName + "-" + i.addAndGet(1));
    696                 return thread;
    697             }
    698         });
    699     }
    700 
    701     private boolean isAllowedToModify(Principal principal, VirtualCollection c) {
    702         // admin and owner are allowed to modify collections
    703         return adminUsersService.isAdmin(principal.getName())
    704                 || c.getOwner().equalsPrincipal(principal);
    705     }
    706 
    707 } // class VirtualCollectionRegistry
     63} // interface VirtualCollectionRegistry

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/VirtualCollectionRegistryImpl.java

    r5607 r5616  
    3838
    3939@Service
    40 public class VirtualCollectionRegistry implements InitializingBean, DisposableBean {
     40public class VirtualCollectionRegistryImpl implements VirtualCollectionRegistry, InitializingBean, DisposableBean {
    4141
    4242    @Autowired
    … …  
    5353
    5454    private static final Logger logger
    55             = LoggerFactory.getLogger(VirtualCollectionRegistry.class);
     55            = LoggerFactory.getLogger(VirtualCollectionRegistryImpl.class);
    5656    private final AtomicBoolean intialized = new AtomicBoolean(false);
    5757    /**

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/rest/VirtualCollectionResource.java

    r5514 r5616  
    6969    }
    7070
     71    // for testing
     72    protected VirtualCollectionResource(VirtualCollectionRegistry registry, VirtualCollectionMarshaller marshaller, SecurityContext security, HttpHeaders headers, UriInfo uriInfo, Long id) {
     73        this.registry = registry;
     74        this.marshaller = marshaller;
     75        this.security = security;
     76        this.headers = headers;
     77        this.uriInfo = uriInfo;
     78        this.id = id;
     79    }
     80
     81   
     82   
    7183    /**
    7284     * Sets the id for this resource; should be called exactly once per
    … …  
    104116            // exclude CMDI from the options and check if this is ok for request
    105117            final List<Variant> variants = Variant.mediaTypes(
    106                     MediaType.TEXT_XML_TYPE, 
    107                     MediaType.APPLICATION_XML_TYPE, 
     118                    MediaType.TEXT_XML_TYPE,
     119                    MediaType.APPLICATION_XML_TYPE,
    108120                    MediaType.APPLICATION_JSON_TYPE).add().build();
    109121            final Variant selectVariant = request.selectVariant(variants);
    … …  
    212224            throws VirtualCollectionRegistryException {
    213225        VirtualCollection.State state = registry.getVirtualCollectionState(id);
    214         State result = null;
     226        final State result;
    215227        switch (state) {
    216228            case PUBLIC_PENDING:
Note: See TracChangeset for help on using the changeset viewer.