@Override public boolean hasAffinity(K key) { DistributionManager dist = this.cache.getAdvancedCache().getDistributionManager(); if (dist != null) { DataLocality locality = dist.getLocality(key); return locality.isLocal() || locality.isUncertain(); } return true; }
/** * Encodes the cases for an asyncGet operation in which it makes sense to actually perform the * operation in sync. * * @param flags * @param key * @return true if we skip the thread (performing it in sync) */ private boolean asyncSkipsThread(EnumSet<Flag> flags, K key) { boolean isSkipLoader = isSkipLoader(flags); if (!isSkipLoader) { // if we can't skip the cacheloader, we really want a thread for async. return false; } CacheMode cacheMode = config.getCacheMode(); if (!cacheMode.isDistributed()) { // in these cluster modes we won't RPC for a get, so no need to fork a thread. return true; } else if (flags != null && (flags.contains(Flag.SKIP_REMOTE_LOOKUP) || flags.contains(Flag.CACHE_MODE_LOCAL))) { // with these flags we won't RPC either return true; } // finally, we will skip the thread if the key maps to the local node return distributionManager.getLocality(key).isLocal(); }
/** * This method retrieves an entry from a remote cache and optionally stores it in L1 (if L1 is * enabled). * * <p>This method only works if a) this is a locally originating invocation and b) the entry in * question is not local to the current cache instance and c) the entry is not in L1. If either of * a, b or c does not hold true, this method returns a null and doesn't do anything. * * @param ctx invocation context * @param key key to retrieve * @return value of a remote get, or null * @throws Throwable if there are problems */ private Object remoteGetAndStoreInL1(InvocationContext ctx, Object key, boolean isWrite) throws Throwable { DataLocality locality = dm.getLocality(key); if (ctx.isOriginLocal() && !locality.isLocal() && isNotInL1(key)) { return realRemoteGet(ctx, key, true, isWrite); } else { // maybe we are still rehashing as a joiner? ISPN-258 if (locality.isUncertain()) { if (trace) log.tracef( "Key %s is mapped to local node %s, but a rehash is in progress so may need to look elsewhere", key, rpcManager.getAddress()); // try a remote lookup all the same return realRemoteGet(ctx, key, false, isWrite); } else { if (trace) log.tracef( "Not doing a remote get for key %s since entry is mapped to current node (%s), or is in L1. Owners are %s", key, rpcManager.getAddress(), dm.locate(key)); } } return null; }
private boolean isRemote(Object key) { return distributionManager != null && !distributionManager.getLocality(key).isLocal(); }
@Override public boolean localNodeIsOwner(Object key) { return dm.getLocality(key).isLocal(); }
private boolean getMightGoRemote(InvocationContext ctx, Object key) { return ctx.isOriginLocal() && configuration.getCacheMode().isDistributed() && !ctx.hasFlag(Flag.SKIP_REMOTE_LOOKUP) && !distManager.getLocality(key).isLocal(); }