Example usage for org.springframework.data.gemfire GemfireCallback GemfireCallback

List of usage examples for org.springframework.data.gemfire GemfireCallback GemfireCallback

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.data.gemfire.*
  5. GemfireCallback
  6. GemfireCallback

Introduction

In this page you can find the example usage for org.springframework.data.gemfire GemfireCallback GemfireCallback.

Prototype

GemfireCallback

Source Link

Usage

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
public Object lock(final Serializable id) throws CannotAcquireLockException {
    final GemfireTemplate template = gemfireDatastore.getTemplate(getPersistentEntity());

    return template.execute(new GemfireCallback() {
        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            final Lock lock = region.getDistributedLock(id);
            lock.lock();/*from www .  j av a  2 s  .  co m*/
            final Object o = region.get(id);
            distributedLocksHeld.put(o, lock);
            return o;
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
public Object lock(final Serializable id, final int timeout) throws CannotAcquireLockException {
    final GemfireTemplate template = gemfireDatastore.getTemplate(getPersistentEntity());

    return template.execute(new GemfireCallback() {
        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            final Lock lock = region.getDistributedLock(id);
            try {
                if (lock.tryLock(timeout, TimeUnit.SECONDS)) {
                    final Object o = region.get(id);
                    distributedLocksHeld.put(o, lock);
                    return o;
                }//ww w. j a  v a2s  .  c  o m
                throw new CannotAcquireLockException("Timeout acquiring Gemfire lock on object type ["
                        + getPersistentEntity() + "] with identifier [" + id + "]");
            } catch (InterruptedException e) {
                throw new CannotAcquireLockException("Cannot acquire Gemfire lock on object type ["
                        + getPersistentEntity() + "] with identifier [" + id + "]: " + e.getMessage(), e);
            }
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected List<Object> retrieveAllEntities(PersistentEntity persistentEntity, final Serializable[] keys) {
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);
    return (List<Object>) template.execute(new GemfireCallback() {
        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            return region.getAll(Arrays.asList(keys));
        }/*from  ww w  . ja v  a  2  s.c  o  m*/
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected List<Object> retrieveAllEntities(PersistentEntity persistentEntity,
        final Iterable<Serializable> keys) {
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);
    return (List<Object>) template.execute(new GemfireCallback() {
        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            if (keys instanceof Collection) {
                return getListOfValues(region.getAll((Collection) keys));
            }/*from   w  w  w .  jav a2  s  .  c  o m*/
            Collection keyList = new ArrayList();
            for (Serializable key : keys) {
                keyList.add(key);
            }
            return getListOfValues(region.getAll(keyList));
        }

        List getListOfValues(final Map all) {
            if (all != null) {
                return new ArrayList(all.values());
            }
            return Collections.emptyList();
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected List<Serializable> persistEntities(final PersistentEntity persistentEntity, Iterable objs) {
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);
    final Map putMap = new HashMap();
    List<Serializable> identifiers = new ArrayList<Serializable>();
    final Map<Object, EntityAccess> entityAccessObjects = new HashMap<Object, EntityAccess>();

    final Map<Object, Boolean> updates = new HashMap<Object, Boolean>();
    for (Object obj : objs) {
        final EntityAccess access = createEntityAccess(persistentEntity, obj);
        entityAccessObjects.put(obj, access);
        Object identifier = access.getIdentifier();
        boolean isUpdate = true;
        if (identifier == null) {
            identifier = generateIdentifier(persistentEntity, access);
            isUpdate = false;/*from   www  .  j  a v  a2  s. c om*/
        }

        AbstractPersistenceEvent event = isUpdate
                ? new PreUpdateEvent(session.getDatastore(), persistentEntity, access)
                : new PreInsertEvent(session.getDatastore(), persistentEntity, access);
        updates.put(obj, isUpdate);
        publisher.publishEvent(event);
        if (event.isCancelled()) {
            break;
        }

        putMap.put(identifier, obj);
        identifiers.add((Serializable) identifier);
    }

    template.execute(new GemfireCallback() {

        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            region.putAll(putMap);

            if (!persistentEntity.isRoot()) {
                doWithParents(persistentEntity, new GemfireCallback() {
                    @SuppressWarnings("hiding")
                    public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
                        region.putAll(putMap);
                        return null;
                    }
                });
            }

            for (Object id : putMap.keySet()) {
                Object obj = putMap.get(id);
                final EntityAccess access = entityAccessObjects.get(obj);
                if (access != null) {
                    cascadeSaveOrUpdate(persistentEntity, obj, access);
                    if (updates.get(obj)) {
                        firePostUpdateEvent(persistentEntity, access);
                    } else {
                        firePostInsertEvent(persistentEntity, access);
                    }
                }
            }

            return null;
        }
    });

    return identifiers;
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected Object retrieveEntity(final PersistentEntity persistentEntity, final Serializable key) {

    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);
    return template.execute(new GemfireCallback() {
        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            final Class idType = persistentEntity.getIdentity().getType();
            Object lookupKey = getMappingContext().getConversionService().convert(key, idType);
            final Object entry = region.get(lookupKey);

            if (entry != null) {
                publisher.publishEvent(new PreLoadEvent(session.getDatastore(), getPersistentEntity(),
                        new EntityAccess(persistentEntity, entry)));
            }/*from  ww w.ja  v a2s.co m*/

            for (Association association : persistentEntity.getAssociations()) {
                if (association instanceof OneToMany) {
                    final EntityAccess ea = createEntityAccess(persistentEntity, entry);
                    final String propertyName = association.getName();
                    final Object currentState = ea.getProperty(propertyName);
                    if (currentState == null) {
                        initializeCollectionState(association, ea, propertyName);
                    }
                }
            }
            return entry;
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected Serializable persistEntity(final PersistentEntity persistentEntity, final Object obj) {
    final EntityAccess access = createEntityAccess(persistentEntity, obj);
    Object identifier = access.getIdentifier();
    boolean isUpdate = true;
    if (identifier == null) {
        identifier = generateIdentifier(persistentEntity, access);
        isUpdate = false;//from   w w  w .  j a  v  a 2s  . c  o  m
    }
    final Object finalId = identifier;
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);

    final boolean finalIsUpdate = isUpdate;
    template.execute(new GemfireCallback() {

        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {

            AbstractPersistenceEvent event = finalIsUpdate
                    ? new PreUpdateEvent(session.getDatastore(), persistentEntity, access)
                    : new PreInsertEvent(session.getDatastore(), persistentEntity, access);
            publisher.publishEvent(event);
            if (event.isCancelled()) {
                return finalId;
            }

            if (finalIsUpdate && isVersioned(access)) {
                // TODO this should be done with a CAS approach if possible
                checkVersion(region, access, persistentEntity, finalId);
            }

            region.put(finalId, obj);
            if (!persistentEntity.isRoot()) {
                doWithParents(persistentEntity, new GemfireCallback() {
                    @SuppressWarnings("hiding")
                    public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
                        region.put(finalId, obj);
                        return null;
                    }
                });
            }

            cascadeSaveOrUpdate(persistentEntity, obj, access);

            if (finalIsUpdate) {
                firePostUpdateEvent(persistentEntity, access);
            } else {
                firePostInsertEvent(persistentEntity, access);
            }

            return null;
        }
    });
    return (Serializable) identifier;
}

From source file:org.grails.datastore.mapping.gemfire.query.GemfireQuery.java

@Override
protected List executeQuery(final PersistentEntity entity, Junction criteria) {
    final ProjectionList projectionList = projections();
    if (criteria.isEmpty() && !(max > -1)) {
        return (List) gemfireDatastore.getTemplate(entity).execute(new GemfireCallback() {

            public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {

                List finalResults;
                if (projectionList.isEmpty()) {
                    finalResults = new ArrayList(region.values());
                } else {
                    List results = new ArrayList();
                    for (Projection projection : projectionList.getProjectionList()) {
                        Collection values = null;
                        if (projection instanceof CountProjection) {
                            results.add(region.size());
                        } else if (projection instanceof MinProjection) {
                            MinProjection min = (MinProjection) projection;
                            if (values == null) {
                                values = region.values();
                            }/*from   www. ja  va  2s .  c  om*/
                            results.add(manualProjections.min(values, min.getPropertyName()));
                        } else if (projection instanceof MaxProjection) {
                            if (values == null) {
                                values = region.values();
                            }
                            MaxProjection maxProjection = (MaxProjection) projection;
                            results.add(manualProjections.max(values, maxProjection.getPropertyName()));
                        } else if (projection instanceof IdProjection) {
                            results.add(region.keySet());
                        } else if (projection instanceof CountDistinctProjection) {
                            if (values == null) {
                                values = region.values();
                            }
                            results.add(manualProjections.countDistinct(values,
                                    ((PropertyProjection) projection).getPropertyName()));
                        } else if (projection.getClass() == PropertyProjection.class) {
                            if (values == null) {
                                values = region.values();
                            }
                            final List propertyProjectionResults = manualProjections.property(values,
                                    ((PropertyProjection) projection).getPropertyName());
                            if (projectionList.getProjectionList().size() == 1) {
                                results = propertyProjectionResults;
                            } else {
                                results.add(propertyProjectionResults);
                            }
                        }

                    }
                    finalResults = results;
                }
                finalResults = ordering.applyOrder(finalResults, getOrderBy());
                return finalResults;
            }
        });
    }

    GemfireTemplate template = gemfireDatastore.getTemplate(entity);
    final List params = new ArrayList();
    final String queryString = getQueryString(params, true);

    return (List) template.execute(new GemfireCallback() {

        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {

            final QueryService queryService = gemfireDatastore.getGemfireCache().getQueryService();

            final com.gemstone.gemfire.cache.query.Query gemfireQuery = queryService.newQuery(queryString);

            final Object result = gemfireQuery.execute(params.toArray());
            List finalResults = Collections.emptyList();
            if (projectionList.isEmpty()) {
                if (result instanceof SelectResults) {
                    finalResults = ((SelectResults) result).asList();
                } else {
                    finalResults = wrapResultInList(result);
                }
            } else {
                if (result instanceof SelectResults) {
                    SelectResults selectResults = (SelectResults) result;
                    finalResults = applyProjections(selectResults.asList(), projectionList);
                } else {
                    finalResults = wrapResultInList(result);
                }

            }

            finalResults = ordering.applyOrder(finalResults, getOrderBy());

            if (offset > 0) {

                final int resultSize = finalResults.size();
                if (offset > resultSize) {
                    finalResults = Collections.emptyList();
                } else {
                    int end = resultSize;
                    if (max > -1) {
                        end = offset + max;
                        if (end > resultSize) {
                            end = resultSize;
                        }
                    }
                    finalResults = finalResults.subList(offset, end);
                }
            }

            return finalResults;
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

private Object generateIdentifier(final PersistentEntity persistentEntity, final EntityAccess access) {
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);
    return template.execute(new GemfireCallback() {

        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {

            KeyValue mf = (KeyValue) gemfireDatastore.getMappingContext().getMappingFactory()
                    .createMappedForm(persistentEntity.getIdentity());
            if ("uuid".equals(mf.getGenerator())) {
                String uuid = UUID.randomUUID().toString();
                access.setIdentifier(uuid);
                return uuid;
            }//from w ww .  ja  va 2  s .  c  o m

            Cache cache = CacheFactory.getAnyInstance();
            final int uuid = PartitionedRegion
                    .generatePRId((InternalDistributedSystem) cache.getDistributedSystem(), cache);
            if (uuid == 0) {
                throw new DataAccessResourceFailureException("Unable to generate Gemfire UUID");
            }
            long finalId = identifierGenerator.getAndIncrement() + uuid;
            access.setIdentifier(finalId);
            return finalId;
        }
    });
}

From source file:org.grails.datastore.mapping.gemfire.engine.GemfireEntityPersister.java

@Override
protected void deleteEntity(final PersistentEntity persistentEntity, final Object obj) {
    final EntityAccess access = createEntityAccess(persistentEntity, obj);

    final Object identifier = access.getIdentifier();
    final GemfireTemplate template = gemfireDatastore.getTemplate(persistentEntity);

    template.execute(new GemfireCallback() {

        public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
            PreDeleteEvent event = new PreDeleteEvent(session.getDatastore(), persistentEntity, access);
            publisher.publishEvent(event);
            if (event.isCancelled()) {
                return null;
            }//from   w  w w.  j av  a  2s  .  c  om

            region.remove(identifier);
            if (!persistentEntity.isRoot()) {
                doWithParents(persistentEntity, new GemfireCallback() {
                    @SuppressWarnings("hiding")
                    public Object doInGemfire(Region region) throws GemFireCheckedException, GemFireException {
                        region.remove(identifier);
                        return null;
                    }
                });
            }
            cascadeDelete(persistentEntity, obj, access);
            firePostDeleteEvent(persistentEntity, access);
            return null;
        }
    });
}