@Test
public void testFailedIndexUpdateOnCommitForPut() throws Exception {
Person.THROW_ON_INDEX = true;
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.REPLICATE);
SimpleListener sl = new SimpleListener();
af.setCacheListener(sl);
Region region = cache.createRegion("sample", af.create());
qs.createIndex("foo", IndexType.FUNCTIONAL, "index", "/sample");
Context ctx = cache.getJNDIContext();
Integer x = new Integer(0);
region.getCache().getCacheTransactionManager().begin();
region.create(x, new Person("xyz", 45));
try {
region.getCache().getCacheTransactionManager().commit();
fail("commit should have thrown an exception because the index maintenance threw");
} catch (com.gemstone.gemfire.cache.query.IndexMaintenanceException ie) {
// this is the desired case
}
Person p = (Person) region.get(x);
assertEquals("object shouldn't have made it into region", null, p);
assertEquals(0, sl.creates);
assertEquals(0, sl.updates);
}
/** perform put operation */
public static void doPuts(String key) throws Exception {
Region region1 = cache.getRegion(Region.SEPARATOR + REGION_NAME);
// first create
for (int i = 1; i < 200; i++) {
Object obj = "sup" + i;
cache.getLogger().info("put happened value : " + obj);
region1.getCache().getCacheTransactionManager().begin();
region1.put(key, obj);
region1.getCache().getCacheTransactionManager().commit();
}
cache.getLogger().info("put happened for key : " + key);
}
@Override
public void execute(FunctionContext context) {
try {
Region<K, V> local =
PartitionRegionHelper.getLocalDataForContext((RegionFunctionContext) context);
ParallelArgs<K, V> args = (ParallelArgs<K, V>) context.getArguments();
File[] files =
args.getOptions()
.getMapper()
.mapImportPath(
local.getCache().getDistributedSystem().getDistributedMember(), args.getFile());
if (files != null) {
for (File f : files) {
if (f.isDirectory() || !f.exists()) {
throw new IOException(
LocalizedStrings.Snapshot_INVALID_IMPORT_FILE.toLocalizedString(f));
}
local.getSnapshotService().load(f, args.getFormat(), args.getOptions());
}
}
context.getResultSender().lastResult(Boolean.TRUE);
} catch (Exception e) {
context.getResultSender().sendException(e);
}
}
public void destroy() throws Exception {
Region<K, V> region = getObject();
// unregister interests
try {
if (region != null && !ObjectUtils.isEmpty(interests)) {
for (Interest<K> interest : interests) {
if (interest instanceof RegexInterest) {
region.unregisterInterestRegex((String) interest.getKey());
} else {
region.unregisterInterest(interest.getKey());
}
}
}
// should not really happen since interests are validated at start/registration
} catch (UnsupportedOperationException ex) {
log.warn("Cannot unregister cache interests", ex);
}
if (region != null) {
if (close) {
if (!region.getCache().isClosed()) {
try {
region.close();
} catch (CacheClosedException cce) {
// nothing to see folks, move on.
}
}
} else if (destroy) {
region.destroyRegion();
}
}
region = null;
}
@Override
public void save(File snapshot, SnapshotFormat format, SnapshotOptions<K, V> options)
throws IOException {
// we can't be in a transaction since that will inline the function execution
if (region.getCache().getCacheTransactionManager().exists()) {
throw new IllegalStateException("Unable to save snapshot during a transaction");
}
if (shouldRunInParallel(options)) {
snapshotInParallel(
new ParallelArgs<K, V>(snapshot, format, options), new ParallelExportFunction<K, V>());
return;
} else {
exportOnMember(snapshot, format, options);
}
}
public NewLRUClockHand(Region region, EnableLRU ccHelper, NewLRUClockHand oldList) {
setBucketRegion(region);
this.lock = new HeadLock();
// behavior relies on a single evicted node in the pipe when the pipe is empty.
initHeadAndTail();
if (oldList.stats == null) {
// see bug 41388
StatisticsFactory sf = region.getCache().getDistributedSystem();
this.stats = ccHelper.initStats(region, sf);
} else {
this.stats = oldList.stats;
if (this.bucketRegion != null) {
this.stats.decrementCounter(this.bucketRegion.getCounter());
this.bucketRegion.resetCounter();
} else {
this.stats.resetCounter();
}
}
}
public Index createIndex(
String indexName,
IndexType indexType,
String indexedExpression,
String fromClause,
String imports,
boolean loadEntries,
Region region)
throws IndexNameConflictException, IndexExistsException, RegionNotFoundException {
if (pool != null) {
throw new UnsupportedOperationException(
"Index creation on the server is not supported from the client.");
}
PartitionedIndex parIndex = null;
if (region == null) {
region = getRegionFromPath(imports, fromClause);
}
RegionAttributes ra = region.getAttributes();
// Asif: If the evistion action is Overflow to disk then do not allow index creation
// It is Ok to have index creation if it is persist only mode as data will always
// exist in memory
// if(ra.getEvictionAttributes().getAction().isOverflowToDisk() ) {
// throw new
// UnsupportedOperationException(LocalizedStrings.DefaultQueryService_INDEX_CREATION_IS_NOT_SUPPORTED_FOR_REGIONS_WHICH_OVERFLOW_TO_DISK_THE_REGION_INVOLVED_IS_0.toLocalizedString(regionPath));
// }
// if its a pr the create index on all of the local buckets.
if (((LocalRegion) region).heapThresholdReached.get()
&& !InternalResourceManager.isLowMemoryExceptionDisabled()) {
LocalRegion lr = (LocalRegion) region;
throw new LowMemoryException(
LocalizedStrings.ResourceManager_LOW_MEMORY_FOR_INDEX.toLocalizedString(region.getName()),
lr.getHeapThresholdReachedMembers());
}
if (region instanceof PartitionedRegion) {
try {
parIndex =
(PartitionedIndex)
((PartitionedRegion) region)
.createIndex(
false,
indexType,
indexName,
indexedExpression,
fromClause,
imports,
loadEntries);
} catch (ForceReattemptException ex) {
region
.getCache()
.getLoggerI18n()
.info(
LocalizedStrings
.DefaultQueryService_EXCEPTION_WHILE_CREATING_INDEX_ON_PR_DEFAULT_QUERY_PROCESSOR,
ex);
} catch (IndexCreationException exx) {
region
.getCache()
.getLoggerI18n()
.info(
LocalizedStrings
.DefaultQueryService_EXCEPTION_WHILE_CREATING_INDEX_ON_PR_DEFAULT_QUERY_PROCESSOR,
exx);
}
return parIndex;
} else {
IndexManager indexManager = IndexUtils.getIndexManager(region, true);
Index index =
indexManager.createIndex(
indexName,
indexType,
indexedExpression,
fromClause,
imports,
null,
null,
loadEntries);
return index;
}
}