if (baseOperation.isUpdate()) { this.eventUpdateCount++; this.updates.add(key); } else if (baseOperation.isCreate()) { this.eventCreateCount++; this.creates.add(key); } else if (baseOperation.isDestroy()) { this.eventDeleteCount++; this.destroys.add(key); } else if (baseOperation.isInvalidate()) { this.eventDeleteCount++; this.invalidates.add(key); if (queryOperation.isUpdate()) { this.eventQueryUpdateCount++; } else if (queryOperation.isCreate()) { this.eventQueryInsertCount++; } else if (queryOperation.isDestroy()) { this.eventQueryDeleteCount++; } else if (queryOperation.isInvalidate()) { this.eventQueryInvalidateCount++; } else if (queryOperation.isClear()) { this.eventRegionClear = true; } else if (queryOperation.isRegionInvalidate()) { this.eventRegionInvalidate = true;
private void verifyMirrorRegionEventsMatch(EntryEvent<String, String> event, Region region, String expectedValue) { assertThat(event.getRegion()).isSameAs(region); assertThat(event.getKey()).isEqualTo("key"); assertThat(event.getNewValue()).isEqualTo(expectedValue); assertThat(event.getOldValue()).isNull(); assertThat(event.getOperation().isLocalLoad()).isFalse(); assertThat(event.getOperation().isNetLoad()).isFalse(); assertThat(event.getOperation().isLoad()).isFalse(); assertThat(event.getOperation().isNetSearch()).isFalse(); assertThat(event.getOperation().isExpiration()).isFalse(); assertThat(event.getCallbackArgument()).isNull(); assertThat(event.isCallbackArgumentAvailable()).isTrue(); assertThat(event.isOriginRemote()).isTrue(); assertThat(event.getOperation().isDistributed()).isTrue(); }
public void afterRegionDestroy2(RegionEvent<K, V> event) { if (!event.getOperation().isClose()) { String s = "Unexpected callback invocation"; throw new UnsupportedOperationException(s); } }
/** * Return true if this operation needs to check for reliable delivery. Return false if not. * Currently the only case it doesn't need to be is a DestroyRegionOperation doing a "local" * destroy. * * @since GemFire 5.0 */ boolean isOperationReliable() { Operation op = this.event.getOperation(); if (!op.isRegionDestroy()) { return true; } if (op.isDistributed()) { return true; } // must be a region destroy that is "local" which means // Region.localDestroyRegion or Region.close or Cache.clsoe // none of these should do reliability checks return false; }
public void toData(DataOutput out) throws IOException { out.writeByte(this.op.ordinal); DataSerializer.writeObject(this.cbArg, out); if (this.op.isEntry()) { DataSerializer.writeObject(this.key, out); if (this.op.isUpdate() || this.op.isCreate()) { out.writeByte(this.deserializationPolicy); DataSerializer.writeByteArray(this.value, out); } } } }
/** * Check NET_LOAD_CREATE Operation. */ @Test public void testNET_LOAD_CREATE() { Operation op = Operation.NET_LOAD_CREATE; assertTrue(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertFalse(op.isDestroy()); assertFalse(op.isPutAll()); assertFalse(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertFalse(op.isRegion()); assertFalse(op.isLocal()); assertTrue(op.isDistributed()); assertTrue(op.isEntry()); assertFalse(op.isExpiration()); assertFalse(op.isLocalLoad()); assertTrue(op.isNetLoad()); assertTrue(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }
public void process(LocalRegion lr, DistributedMember src, long lastMod) { if (this.op.isRegion()) { if (this.op.isRegionInvalidate()) { lr.basicInvalidateRegion(re); } else if (this.op == Operation.REGION_CLEAR) { try { if (this.op.isCreate() || this.op.isUpdate()) { UpdateOperation.UpdateMessage.setNewValueInEvent(this.value, this.valueObj, ee, this.deserializationPolicy); } else if (this.op.isDestroy()) { ee.setOldValueFromRegion(); try { throw new Error("DistributedLock should not be acquired", e); } else if (this.op.isInvalidate()) { ee.setOldValueFromRegion(); boolean forceNewEntry = lr.getDataPolicy().withReplication() && !lr.isInitialized();
FilterRoutingInfo routing) { Operation op = event.getOperation(); if (op.isUpdate() || op.isCreate() || op.isDestroy() || op.isInvalidate()) {
if (event.getOperation().isLocal() || numBS == 0) { return; if (event.getOperation().isEntry()) { EntryEventImpl e = (EntryEventImpl) event; if (e.getEventType() == null) { if (op.isCreate()) { e.setEventType(EnumListenerEvent.AFTER_CREATE); } else if (op.isUpdate()) { e.setEventType(EnumListenerEvent.AFTER_UPDATE); } else if (op.isDestroy()) { e.setEventType(EnumListenerEvent.AFTER_DESTROY); } else if (op.isInvalidate()) { e.setEventType(EnumListenerEvent.AFTER_INVALIDATE); } else {
private String getSqlString(TableMetaDataView tableMetaData, EntryColumnData entryColumnData, Operation operation) { SqlStatementFactory statementFactory = new SqlStatementFactory(tableMetaData.getIdentifierQuoteString()); String tableName = tableMetaData.getQuotedTablePath(); if (operation.isCreate()) { return statementFactory.createInsertSqlString(tableName, entryColumnData); } else if (operation.isUpdate()) { return statementFactory.createUpdateSqlString(tableName, entryColumnData); } else if (operation.isDestroy()) { return statementFactory.createDestroySqlString(tableName, entryColumnData); } else if (operation.isGet()) { return statementFactory.createSelectQueryString(tableName, entryColumnData); } else { throw new InternalGemFireException("unsupported operation " + operation); } }
public static QueuedOperation createFromData(DataInput in) throws IOException, ClassNotFoundException { Operation op = Operation.fromOrdinal(in.readByte()); Object key = null; byte[] value = null; Object valueObj = null; byte deserializationPolicy = DistributedCacheOperation.DESERIALIZATION_POLICY_NONE; Object cbArg = DataSerializer.readObject(in); if (op.isEntry()) { key = DataSerializer.readObject(in); if (op.isUpdate() || op.isCreate()) { deserializationPolicy = in.readByte(); value = DataSerializer.readByteArray(in); } } return new QueuedOperation(op, key, value, valueObj, deserializationPolicy, cbArg); }
private void firePendingCallbacks(List<EntryEventImpl> callbacks) { Iterator<EntryEventImpl> ci = callbacks.iterator(); while (ci.hasNext()) { EntryEventImpl ee = ci.next(); try { if (ee.getOperation().isDestroy()) { ee.getRegion().invokeTXCallbacks(EnumListenerEvent.AFTER_DESTROY, ee, true); } else if (ee.getOperation().isInvalidate()) { ee.getRegion().invokeTXCallbacks(EnumListenerEvent.AFTER_INVALIDATE, ee, true); } else if (ee.getOperation().isCreate()) { ee.getRegion().invokeTXCallbacks(EnumListenerEvent.AFTER_CREATE, ee, true); } else { ee.getRegion().invokeTXCallbacks(EnumListenerEvent.AFTER_UPDATE, ee, true); } } finally { ee.release(); } } }
/** * Removing the existing indexed value requires the current value in the cache, that is the one * prior to applying the operation. * * @param entry the RegionEntry that contains the value prior to applying the op */ @Override public void txRemoveOldIndexEntry(Operation op, RegionEntry entry) { if ((op.isUpdate() && !entry.isInvalid()) || op.isInvalidate() || op.isDestroy()) { IndexManager idxManager = _getOwner().getIndexManager(); if (idxManager != null) { try { idxManager.updateIndexes(entry, IndexManager.REMOVE_ENTRY, op.isUpdate() ? IndexProtocol.BEFORE_UPDATE_OP : IndexProtocol.OTHER_OP); } catch (QueryException e) { throw new IndexMaintenanceException(e); } } } }
<K> EntryColumnData getEntryColumnData(TableMetaDataView tableMetaData, RegionMapping regionMapping, K key, PdxInstance value, Operation operation) { List<ColumnData> keyColumnData = createKeyColumnDataList(tableMetaData, regionMapping, key); List<ColumnData> valueColumnData = null; if (operation.isCreate() || operation.isUpdate()) { valueColumnData = createValueColumnDataList(tableMetaData, regionMapping, value); } return new EntryColumnData(keyColumnData, valueColumnData); }
private Integer generateCqRegionEvent(CacheEvent event) { Integer cqEvent = null; if (event.getOperation().isRegionDestroy()) { cqEvent = MessageType.DESTROY_REGION; } else if (event.getOperation().isRegionInvalidate()) { cqEvent = MessageType.INVALIDATE_REGION; } else if (event.getOperation().isClear()) { cqEvent = MessageType.CLEAR_REGION; } return cqEvent; }
private Operation getOppositeOperation(Operation operation) { return operation.isUpdate() ? Operation.CREATE : Operation.UPDATE; }
throws IOException, ClassNotFoundException { this.key = DataSerializer.readObject(in); this.op = Operation.fromOrdinal(in.readByte()); if (largeModCount) { this.modSerialNum = in.readInt(); if (!this.op.isDestroy()) { this.didDestroy = in.readBoolean(); if (!this.op.isInvalidate()) { boolean isTokenOrByteArray = in.readBoolean(); if (isTokenOrByteArray) {
if (!this.op.isDestroy()) { out.writeBoolean(this.didDestroy); if (!this.op.isInvalidate()) { boolean sendObject = Token.isInvalidOrRemoved(this.value); sendObject = sendObject || this.value instanceof byte[];
private boolean isPutOpCreate() { return getPutOp().isCreate(); }