/** * Returns the value of the EntryEventImpl field. * This is for internal use only. Customers should always call * {@link #getCallbackArgument} * @since 5.5 */ public Object getRawCallbackArgument() { return this.keyInfo.getCallbackArg(); }
public void setCallbackArgument(Object newCallbackArgument) { if (this.keyInfo.getCallbackArg() instanceof WrappedCallbackArgument) { ((WrappedCallbackArgument)this.keyInfo.getCallbackArg()) .setOriginalCallbackArgument(newCallbackArgument); } else { this.keyInfo.setCallbackArg(newCallbackArgument); } }
public Object findObject(KeyInfo keyInfo, boolean isCreate, boolean generateCallbacks, Object value, boolean preferCD, ClientProxyMembershipID requestingClient, EntryEventImpl event, boolean allowReadFromHDFS) { return proxy.get(keyInfo.getKey(), keyInfo.getCallbackArg(), event); }
/** * @see com.gemstone.gemfire.cache.CacheEvent#getCallbackArgument() */ public Object getCallbackArgument() { Object result = this.keyInfo.getCallbackArg(); while (result instanceof WrappedCallbackArgument) { WrappedCallbackArgument wca = (WrappedCallbackArgument)result; result = wca.getOriginalCallbackArg(); } if (result == Token.NOT_AVAILABLE) { result = AbstractRegion.handleNotAvailable(result); } return result; } public boolean isCallbackArgumentAvailable() {
/** * Search for the value in a server (if one exists), * then try a loader. * * If we find a value, we put it in the cache. * @param preferCD return the CacheDeserializable, if that's what the value is. * @param requestingClient the client making the request, if any * @param clientEvent the client's event, if any. If not null, we set the version tag * @param returnTombstones TODO * @return the deserialized value * @see DistributedRegion#findObjectInSystem(KeyInfo, boolean, * TXStateInterface, boolean, Object, boolean, boolean, * ClientProxyMembershipID, EntryEventImpl, boolean, boolean) */ protected Object findObjectInSystem(KeyInfo keyInfo, boolean isCreate, final TXStateInterface lockState, boolean generateCallbacks, Object localValue, boolean disableCopyOnRead, boolean preferCD, ClientProxyMembershipID requestingClient, EntryEventImpl clientEvent, boolean returnTombstones, boolean allowReadFromHDFS) throws CacheLoaderException, TimeoutException { return findObjectInLocalSystem(keyInfo.getKey(), keyInfo.getCallbackArg(), isCreate, lockState, generateCallbacks, localValue, clientEvent); }
protected final InternalDistributedMember getOrCreateNodeForBucketRead( final KeyInfo keyInfo, final boolean noCreateNode) { final Object key = keyInfo.getKey(); int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, Operation.GET_ENTRY, key, keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } if (noCreateNode) { return getNodeForBucketRead(bucketId); } return getOrCreateNodeForBucketRead(bucketId); }
protected final InternalDistributedMember getOrCreateNodeForInitializedBucketRead( final KeyInfo keyInfo, final boolean noCreateNode) { final Object key = keyInfo.getKey(); int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, Operation.GET_ENTRY, key, keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } if (noCreateNode) { return getNodeForInitializedBucketRead(bucketId, false); } return getOrCreateNodeForInitializedBucketRead(bucketId, false); }
/** * Now only used for tests. TODO: method should be removed. */ public DistributedMember getOwnerForKey(KeyInfo keyInfo) { if (keyInfo == null) { return getMyId(); } int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } return createBucket(bucketId, 0, null); }
@Override public DistributedMember getOwnerForKey(KeyInfo keyInfo) { if (keyInfo == null) { return super.getOwnerForKey(null); } // TODO provide appropriate Operation and arg int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } return createBucket(bucketId, 0, null); } @Override
@Override protected boolean nonTXContainsValueForKey(KeyInfo keyInfo) { boolean containsValueForKey = false; int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, Operation.CONTAINS_VALUE_FOR_KEY, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } InternalDistributedMember targetNode = getOrCreateNodeForBucketRead(bucketId); // targetNode null means that this key is not in the system. if (targetNode != null) { containsValueForKey = containsKeyInBucket(targetNode, bucketId, keyInfo.getKey(), true); } return containsValueForKey; }
public Object findObject(KeyInfo keyInfo, boolean isCreate, boolean generateCallbacks, Object value, boolean preferCD, ClientProxyMembershipID requestingClient, EntryEventImpl clientEvent, boolean allowReadFromHDFS) { Object retVal = null; final Object key = keyInfo.getKey(); final Object callbackArgument = keyInfo.getCallbackArg(); try { RemoteGetMessage.RemoteGetResponse response = RemoteGetMessage.send((InternalDistributedMember)state.getTarget(), region, key, callbackArgument, requestingClient); retVal = response.waitForResponse(preferCD); } catch (RegionDestroyedException rde) { throw new TransactionDataNotColocatedException(LocalizedStrings.RemoteMessage_REGION_0_NOT_COLOCATED_WITH_TRANSACTION .toLocalizedString(rde.getRegionFullPath()), rde); } catch(RemoteOperationException roe) { throw new TransactionDataNodeHasDepartedException(roe); } return retVal; }
/** * @param keyInfo * @return TODO */ @Override protected boolean nonTXContainsKey(KeyInfo keyInfo) { final long startTime = PartitionedRegionStats.startTime(); boolean contains = false; try { int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, Operation.CONTAINS_KEY, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } Integer bucketIdInt = Integer.valueOf(bucketId); InternalDistributedMember targetNode = getOrCreateNodeForBucketRead(bucketId); // targetNode null means that this key is not in the system. if (targetNode != null) { contains = containsKeyInBucket(targetNode, bucketIdInt, keyInfo.getKey(), false); } } finally { this.prStats.endContainsKey(startTime); } return contains; }
final Object aCallbackArgument = keyInfo.getCallbackArg(); final long startTime = PartitionedRegionStats.startTime(); try {
@Override protected RegionEntry basicGetTXEntry(KeyInfo keyInfo) { int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, keyInfo.getKey(), keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } if (keyInfo.isCheckPrimary()) { DistributedMember primary = getRegionAdvisor().getPrimaryMemberForBucket( bucketId); if (!primary.equals(getMyId())) { throw new PrimaryBucketException("Bucket " + bucketId + " is not primary. Current primary holder is " + primary); } } BucketRegion br = this.dataStore.getLocalBucketById(bucketId); RegionEntry re = br.basicGetEntry(keyInfo.getKey()); if (re != null && re.isRemoved()) { re = null; } return re; }
/** * * @param keyInfo * @param access * true if caller wants last accessed time updated * @param allowTombstones - whether a tombstone can be returned * @return TODO */ @Override protected final Region.Entry<?, ?> txGetEntry(KeyInfo keyInfo, boolean access, final TXStateInterface tx, boolean allowTombstones) { final long startTime = PartitionedRegionStats.startTime(); final Object key = keyInfo.getKey(); try { int bucketId = keyInfo.getBucketId(); if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, Operation.GET_ENTRY, key, keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId); } InternalDistributedMember targetNode = getOrCreateNodeForBucketRead(bucketId); return getEntryInBucket(targetNode, bucketId, key, access, tx, allowTombstones); } finally { this.prStats.endGetEntry(startTime); } }
Object obj = null; final Object key = keyInfo.getKey(); final Object aCallbackArgument = keyInfo.getCallbackArg(); final long startTime = PartitionedRegionStats.startTime(); try {
public Object findObject(KeyInfo keyInfo, boolean isCreate, boolean generateCallbacks, Object value, boolean peferCD, ClientProxyMembershipID requestingClient, EntryEventImpl clientEvent, boolean allowReadFromHDFS) { Object retVal = null; final Object key = keyInfo.getKey(); final Object callbackArgument = keyInfo.getCallbackArg(); PartitionedRegion pr = (PartitionedRegion)region; try { retVal = pr.getRemotely((InternalDistributedMember)state.getTarget(), keyInfo.getBucketId(), key, callbackArgument, peferCD, requestingClient, clientEvent, false, allowReadFromHDFS); } catch (TransactionException e) { RuntimeException re = getTransactionException(keyInfo, e); re.initCause(e.getCause()); throw re; } catch (PrimaryBucketException e) { RuntimeException re = getTransactionException(keyInfo, e); re.initCause(e); throw re; } catch (ForceReattemptException e) { if (isBucketNotFoundException(e)) { return null; } waitToRetry(); RuntimeException re = getTransactionException(keyInfo, e); re.initCause(e); throw re; } trackBucketForTx(keyInfo); return retVal; }
public Object getEntryForIterator(KeyInfo curr, LocalRegion currRgn, boolean rememberReads, boolean allowTombstones) { if (currRgn instanceof PartitionedRegion) { PartitionedRegion pr = (PartitionedRegion)currRgn; if (!pr.getBucketPrimary(curr.getBucketId()).equals(pr.cache.getMyId())) { // to fix bug 47893 suspend the tx before calling nonTXGetEntry final TXManagerImpl txmgr = pr.getGemFireCache().getTXMgr(); TransactionId tid = txmgr.suspend(); try { return pr.nonTXGetEntry(curr, false, allowTombstones); } finally { txmgr.resume(tid); } } } if (! readEntryAndCheckIfDestroyed(curr, currRgn, rememberReads)) { // need to create KeyInfo since higher level iterator may reuse KeyInfo return new TXEntry(currRgn, new KeyInfo(curr.getKey(), curr.getCallbackArg(), curr.getBucketId()), proxy, rememberReads); } else { return null; } }
if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, entryKey, keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId);
if (bucketId == KeyInfo.UNKNOWN_BUCKET) { bucketId = PartitionedRegionHelper.getHashKey(this, null, entryKey, keyInfo.getValue(), keyInfo.getCallbackArg()); keyInfo.setBucketId(bucketId);