Example usage for javax.persistence FlushModeType COMMIT

List of usage examples for javax.persistence FlushModeType COMMIT

  1. HOME
  2. Java
  3. javax
  4. javax.persistence.*
  5. FlushModeType
  6. COMMIT

Introduction

In this page you can find the example usage for javax.persistence FlushModeType COMMIT.

Prototype

FlushModeType COMMIT

To view the source code for javax.persistence FlushModeType COMMIT.

Click Source Link

Document

Flushing to occur at transaction commit.

Usage

From source file:org.apache.roller.planet.business.jpa.JPAPersistenceStrategy.java

/**
 * Get named query with FlushModeType.COMMIT
 * @param queryName the name of the query
 * @throws org.apache.roller.planet.PlanetException on any error
 *//*  w w w  . j  a  v a2s. c  o  m*/
public Query getNamedQuery(String queryName) throws PlanetException {
    EntityManager em = getEntityManager(false);
    Query q = em.createNamedQuery(queryName);
    // Never flush for queries. Roller code assumes this behavior
    q.setFlushMode(FlushModeType.COMMIT);
    return q;
}

From source file:org.apache.roller.planet.business.jpa.JPAPersistenceStrategy.java

/**
 * Create query from queryString with FlushModeType.COMMIT
 * @param queryString the quuery/*from  w w  w.ja v  a 2  s.  c om*/
 * @throws org.apache.roller.planet.PlanetException on any error
 */
public Query getDynamicQuery(String queryString) throws PlanetException {
    EntityManager em = getEntityManager(false);
    Query q = em.createQuery(queryString);
    // Never flush for queries. Roller code assumes this behavior
    q.setFlushMode(FlushModeType.COMMIT);
    return q;
}

From source file:org.apache.roller.weblogger.business.jpa.JPAPersistenceStrategy.java

/**
 * Get named query with FlushModeType.COMMIT
 * @param queryName the name of the query
 * @throws org.apache.roller.weblogger.WebloggerException on any error
 *//*from  w  ww.j av  a 2  s. co m*/
public Query getNamedQuery(String queryName) throws WebloggerException {
    EntityManager em = getEntityManager(false);
    Query q = em.createNamedQuery(queryName);
    // Never flush for queries. Roller code assumes this behavior
    q.setFlushMode(FlushModeType.COMMIT);
    return q;
}

From source file:org.apache.roller.weblogger.business.jpa.JPAPersistenceStrategy.java

/**
 * Create query from queryString with FlushModeType.COMMIT
 * @param queryString the quuery//from w ww .java  2s .c om
 * @throws org.apache.roller.weblogger.WebloggerException on any error
 */
public Query getDynamicQuery(String queryString) throws WebloggerException {
    EntityManager em = getEntityManager(false);
    Query q = em.createQuery(queryString);
    // Never flush for queries. Roller code assumes this behavior
    q.setFlushMode(FlushModeType.COMMIT);
    return q;
}

From source file:org.apereo.portal.events.aggr.PortalRawEventsAggregatorImpl.java

@Override
@AggrEventsTransactional//from  www .  j a  v a 2 s  .  co  m
public EventProcessingResult doCloseAggregations() {
    if (!this.clusterLockService.isLockOwner(AGGREGATION_LOCK_NAME)) {
        throw new IllegalStateException("The cluster lock " + AGGREGATION_LOCK_NAME
                + " must be owned by the current thread and server");
    }

    final IEventAggregatorStatus cleanUnclosedStatus = eventAggregationManagementDao
            .getEventAggregatorStatus(IEventAggregatorStatus.ProcessingType.CLEAN_UNCLOSED, true);

    //Update status with current server name
    final String serverName = this.portalInfoProvider.getUniqueServerName();
    cleanUnclosedStatus.setServerName(serverName);
    cleanUnclosedStatus.setLastStart(new DateTime());

    //Determine date of most recently aggregated data
    final IEventAggregatorStatus eventAggregatorStatus = eventAggregationManagementDao
            .getEventAggregatorStatus(IEventAggregatorStatus.ProcessingType.AGGREGATION, false);
    if (eventAggregatorStatus == null || eventAggregatorStatus.getLastEventDate() == null) {
        //Nothing has been aggregated, skip unclosed cleanup

        cleanUnclosedStatus.setLastEnd(new DateTime());
        eventAggregationManagementDao.updateEventAggregatorStatus(cleanUnclosedStatus);

        return new EventProcessingResult(0, null, null, true);
    }

    final DateTime lastAggregatedDate = eventAggregatorStatus.getLastEventDate();

    //If lastCleanUnclosedDate is null use the oldest date dimension as there can be 
    //no aggregations that exist before it
    final DateTime lastCleanUnclosedDate;
    if (cleanUnclosedStatus.getLastEventDate() == null) {
        final DateDimension oldestDateDimension = this.dateDimensionDao.getOldestDateDimension();
        lastCleanUnclosedDate = oldestDateDimension.getDate().toDateTime();
    } else {
        lastCleanUnclosedDate = cleanUnclosedStatus.getLastEventDate();
    }

    if (!(lastCleanUnclosedDate.isBefore(lastAggregatedDate))) {
        logger.debug("No events aggregated since last unclosed aggregation cleaning, skipping clean: {}",
                lastAggregatedDate);
        return new EventProcessingResult(0, lastCleanUnclosedDate, lastAggregatedDate, true);
    }

    //Switch to flush on commit to avoid flushes during queries
    final EntityManager entityManager = this.getEntityManager();
    entityManager.flush();
    entityManager.setFlushMode(FlushModeType.COMMIT);

    //Track the number of closed aggregations and the last date of a cleaned interval
    int closedAggregations = 0;
    int cleanedIntervals = 0;
    DateTime cleanUnclosedEnd;

    final Thread currentThread = Thread.currentThread();
    final String currentName = currentThread.getName();
    try {
        currentThread.setName(currentName + "-" + lastCleanUnclosedDate + "-" + lastAggregatedDate);

        //Local caches used to reduce db io
        final IntervalsForAggregatorHelper intervalsForAggregatorHelper = new IntervalsForAggregatorHelper();
        final Map<AggregationInterval, AggregationIntervalInfo> previousIntervals = new HashMap<AggregationInterval, AggregationIntervalInfo>();

        //A DateTime within the next interval to close aggregations in
        DateTime nextIntervalDate = lastCleanUnclosedDate;
        do {
            //Reset our goal of catching up to the last aggregated event on every iteration
            cleanUnclosedEnd = lastAggregatedDate;

            //For each interval the aggregator supports, cleanup the unclosed aggregations
            for (final AggregationInterval interval : intervalsForAggregatorHelper.getHandledIntervals()) {
                final AggregationIntervalInfo previousInterval = previousIntervals.get(interval);
                if (previousInterval != null && nextIntervalDate.isBefore(previousInterval.getEnd())) {
                    logger.debug(
                            "{} interval before {} has already been cleaned during this execution, ignoring",
                            interval, previousInterval.getEnd());
                    continue;
                }

                //The END date of the last clean session will find us the next interval to clean
                final AggregationIntervalInfo nextIntervalToClean = intervalHelper.getIntervalInfo(interval,
                        nextIntervalDate);
                previousIntervals.put(interval, nextIntervalToClean);
                if (nextIntervalToClean == null) {
                    continue;
                }

                final DateTime start = nextIntervalToClean.getStart();
                final DateTime end = nextIntervalToClean.getEnd();
                if (!end.isBefore(lastAggregatedDate)) {
                    logger.debug("{} interval between {} and {} is still active, ignoring",
                            new Object[] { interval, start, end });
                    continue;
                }

                //Track the oldest interval end, this ensures that nothing is missed
                if (end.isBefore(cleanUnclosedEnd)) {
                    cleanUnclosedEnd = end;
                }

                logger.debug("Cleaning unclosed {} aggregations between {} and {}",
                        new Object[] { interval, start, end });

                for (final IntervalAwarePortalEventAggregator<PortalEvent> portalEventAggregator : intervalAwarePortalEventAggregators) {
                    checkShutdown();

                    final Class<? extends IPortalEventAggregator<?>> aggregatorType = getClass(
                            portalEventAggregator);

                    //Get aggregator specific interval info config
                    final AggregatedIntervalConfig aggregatorIntervalConfig = intervalsForAggregatorHelper
                            .getAggregatorIntervalConfig(aggregatorType);

                    //If the aggregator is being used for the specified interval call cleanUnclosedAggregations
                    if (aggregatorIntervalConfig.isIncluded(interval)) {
                        closedAggregations += portalEventAggregator.cleanUnclosedAggregations(start, end,
                                interval);
                    }
                }

                cleanedIntervals++;
            }

            //Set the next interval to the end date from the last aggregation run
            nextIntervalDate = cleanUnclosedEnd;

            logger.debug("Closed {} aggregations across {} interval before {} with goal of {}", new Object[] {
                    closedAggregations, cleanedIntervals, cleanUnclosedEnd, lastAggregatedDate });
            //Loop until either the batchSize of cleaned aggregations has been reached or no aggregation work is done
        } while (closedAggregations <= cleanUnclosedAggregationsBatchSize
                && cleanedIntervals <= cleanUnclosedIntervalsBatchSize
                && cleanUnclosedEnd.isBefore(lastAggregatedDate));
    } finally {
        currentThread.setName(currentName);
    }

    //Update the status object and store it
    cleanUnclosedStatus.setLastEventDate(cleanUnclosedEnd);
    cleanUnclosedStatus.setLastEnd(new DateTime());
    eventAggregationManagementDao.updateEventAggregatorStatus(cleanUnclosedStatus);

    return new EventProcessingResult(closedAggregations, lastCleanUnclosedDate, lastAggregatedDate,
            !cleanUnclosedEnd.isBefore(lastAggregatedDate));
}

From source file:org.apereo.portal.events.aggr.PortalRawEventsAggregatorImpl.java

private EventProcessingResult doAggregateRawEventsInternal() {
    if (!this.clusterLockService.isLockOwner(AGGREGATION_LOCK_NAME)) {
        throw new IllegalStateException("The cluster lock " + AGGREGATION_LOCK_NAME
                + " must be owned by the current thread and server");
    }/*  ww w.  ja  v  a2s. c  o m*/

    if (!this.portalEventDimensionPopulator.isCheckedDimensions()) {
        //First time aggregation has happened, run populateDimensions to ensure enough dimension data exists
        final boolean populatedDimensions = this.portalEventAggregationManager.populateDimensions();
        if (!populatedDimensions) {
            this.logger.warn(
                    "Aborting raw event aggregation, populateDimensions returned false so the state of date/time dimensions is unknown");
            return null;
        }
    }

    //Flush any dimension creation before aggregation
    final EntityManager entityManager = this.getEntityManager();
    entityManager.flush();
    entityManager.setFlushMode(FlushModeType.COMMIT);

    final IEventAggregatorStatus eventAggregatorStatus = eventAggregationManagementDao
            .getEventAggregatorStatus(IEventAggregatorStatus.ProcessingType.AGGREGATION, true);

    //Update status with current server name
    final String serverName = this.portalInfoProvider.getUniqueServerName();
    final String previousServerName = eventAggregatorStatus.getServerName();
    if (previousServerName != null && !serverName.equals(previousServerName)) {
        this.logger.debug("Last aggregation run on {} clearing all aggregation caches", previousServerName);
        final Session session = getEntityManager().unwrap(Session.class);
        final Cache cache = session.getSessionFactory().getCache();
        cache.evictEntityRegions();
    }

    eventAggregatorStatus.setServerName(serverName);

    //Calculate date range for aggregation
    DateTime lastAggregated = eventAggregatorStatus.getLastEventDate();
    if (lastAggregated == null) {
        lastAggregated = portalEventDao.getOldestPortalEventTimestamp();

        //No portal events to aggregate, skip aggregation
        if (lastAggregated == null) {
            return new EventProcessingResult(0, null, null, true);
        }

        //First time aggregation has run, initialize the CLEAN_UNCLOSED status to save catch-up time 
        final IEventAggregatorStatus cleanUnclosedStatus = eventAggregationManagementDao
                .getEventAggregatorStatus(IEventAggregatorStatus.ProcessingType.CLEAN_UNCLOSED, true);
        AggregationIntervalInfo oldestMinuteInterval = this.intervalHelper
                .getIntervalInfo(AggregationInterval.MINUTE, lastAggregated);
        cleanUnclosedStatus.setLastEventDate(oldestMinuteInterval.getStart().minusMinutes(1));
        eventAggregationManagementDao.updateEventAggregatorStatus(cleanUnclosedStatus);
    }

    final DateTime newestEventTime = DateTime.now().minus(this.aggregationDelay).secondOfMinute()
            .roundFloorCopy();

    final Thread currentThread = Thread.currentThread();
    final String currentName = currentThread.getName();
    final MutableInt events = new MutableInt();
    final MutableObject lastEventDate = new MutableObject(newestEventTime);

    boolean complete;
    try {
        currentThread.setName(currentName + "-" + lastAggregated + "_" + newestEventTime);

        logger.debug("Starting aggregation of events between {} (inc) and {} (exc)", lastAggregated,
                newestEventTime);

        //Do aggregation, capturing the start and end dates
        eventAggregatorStatus.setLastStart(DateTime.now());

        complete = portalEventDao.aggregatePortalEvents(lastAggregated, newestEventTime,
                this.eventAggregationBatchSize,
                new AggregateEventsHandler(events, lastEventDate, eventAggregatorStatus));

        eventAggregatorStatus.setLastEventDate((DateTime) lastEventDate.getValue());
        eventAggregatorStatus.setLastEnd(DateTime.now());
    } finally {
        currentThread.setName(currentName);
    }

    //Store the results of the aggregation
    eventAggregationManagementDao.updateEventAggregatorStatus(eventAggregatorStatus);

    complete = complete
            && (this.eventAggregationBatchSize <= 0 || events.intValue() < this.eventAggregationBatchSize);
    return new EventProcessingResult(events.intValue(), lastAggregated,
            eventAggregatorStatus.getLastEventDate(), complete);
}

From source file:org.cesecore.audit.impl.queued.QueuedAuditorSessionBean.java

@Override
public void delete(AuthenticationToken token, Date timestamp) {
    // get last signed log before the specified timestamp
    final AuditLogData lastSigned = AuditLogData.getLastSignedAuditLog(em, timestamp);
    final boolean delete = lastSigned != null;
    if (delete) {
        final Map<String, Object> details = new LinkedHashMap<String, Object>();
        details.put("timestamp", FastDateFormat
                .getTimeInstance(FastDateFormat.FULL, TimeZone.getTimeZone("GMT")).format(timestamp));
        securityEventsLogger.log(EventTypes.LOG_DELETE, EventStatus.VOID, ModuleTypes.SECURITY_AUDIT,
                ServiceTypes.CORE, token.toString(), null, null, null, details);

        if (log.isDebugEnabled()) {
            log.debug("deleting exported logs");
        }/*from  w  w w . ja v a  2  s.com*/

        // important to set flushmode to commit (commit only occurs on flush or explicit commit)
        em.setFlushMode(FlushModeType.COMMIT);
        // delete till the obtained log.
        AuditLogData.delete(em, QueryCriteria.create()
                .add(Criteria.lsr(AuditLogEntry.FIELD_SEQUENCENUMBER, lastSigned.getSequenceNumber())));
        em.flush();
    }
}

From source file:org.cesecore.audit.impl.queued.QueuedAuditorSessionBean.java

@Override
public AuditLogValidationReport verifyLogsIntegrity(final AuthenticationToken token, final Date timestamp,
        final Properties properties) throws AuditLogValidatorException {

    Connection conn = null;/*from  w w w. j  a va 2s  . c o m*/
    try {
        conn = ds.getConnection();
        em.setFlushMode(FlushModeType.COMMIT);

        final AuditLogValidator validator = new AuditLogDbValidator(em, conn);
        final AuditLogValidationReport report = validator.validate(timestamp,
                AuditDevicesConfig.getAuditLogValidationFetchSize(properties));
        final Map<String, Object> details = new LinkedHashMap<String, Object>();
        details.put("timestamp", FastDateFormat
                .getTimeInstance(FastDateFormat.FULL, TimeZone.getTimeZone("GMT")).format(timestamp));
        // Success or failure depending on if verification returns error or not
        EventStatus status = EventStatus.SUCCESS;
        if (report.errors().size() > 0) {
            status = EventStatus.FAILURE;
            details.put("errors", report.errors().size());
        }
        securityEventsLogger.log(EventTypes.LOG_VERIFY, status, ModuleTypes.SECURITY_AUDIT, ServiceTypes.CORE,
                token.toString(), null, null, null, details);
        return report;
    } catch (final SQLException e) {
        throw new AuditLogValidatorException(e.getMessage(), e);
    } finally {
        em.flush();
        if (conn != null) {
            try {
                conn.close();
            } catch (final SQLException e) {
                throw new AuditLogValidatorException(e.getMessage(), e);
            }
        }
    }
}

From source file:org.easy.criteria.BaseDAO.java

/**
 * @see {@link javax.persistence.EntityManager#flush()}
 *///  w ww  . j a v  a2 s  .c  om
public void flushAndCommit() {
    Preconditions.checkState(_entityManager != null);

    try {
        FlushModeType flushModeType = _entityManager.getFlushMode();
        _entityManager.setFlushMode(FlushModeType.COMMIT);
        _entityManager.flush();
        _entityManager.setFlushMode(flushModeType);
    } catch (RuntimeException re) {
        log.error("flushAndCommit failed", re);
        throw new RuntimeException("flushAndCommit failed");
    }
}

From source file:org.eurekastreams.server.persistence.CommonGadgetDefinitionMapper.java

/**
 * Look up the GeneralGadgetDefinition identified by this URL.
 * //  www. ja va2  s.  c o m
 * @param gadgetDefinitionLocation
 *            URL of the XML file that defines the GadgetDefinition
 * @return the GeneralGadgetDefinition specified by the URL
 */
@SuppressWarnings("unchecked")
public GeneralGadgetDefinition findByUrl(final String gadgetDefinitionLocation) {
    try {
        Query q = getEntityManager()
                .createQuery("from " + getDomainEntityName() + " where url = :gadgetDefinitionUrl")
                .setParameter("gadgetDefinitionUrl", gadgetDefinitionLocation.toLowerCase());

        // This avoids entity manager doing a flush before executing
        // the query. We don't want to get the object that is modified
        // in the persistenceContext back as a result.
        q.setFlushMode(FlushModeType.COMMIT);

        //TODO this shouldn't use an exception for logic.
        return (GeneralGadgetDefinition) q.getSingleResult();
    } catch (Exception ex) {
        return null;
    }
}