public MethodInvoker getMethod(Class<?> clazz, String name, Class<?>[] parameters) {
MethodDescriptor mDescriptor = new MethodDescriptor(name, clazz, parameters);
MethodInvoker mInvoker = null;
List<Method> acceptableMethods = null;
LRUCache<MethodDescriptor, MethodInvoker> cache = cacheHolder.get();
mInvoker = cache.get(mDescriptor);
if (mInvoker == null) {
acceptableMethods = getMethodsByNameAndLength(clazz, name, parameters.length);
if (acceptableMethods.size() == 1) {
mInvoker = MethodInvoker.buildInvoker(acceptableMethods.get(0), parameters);
} else {
mInvoker = getBestMethod(acceptableMethods, parameters);
}
if (mInvoker != null && mInvoker.getCost() != -1) {
cache.put(mDescriptor, mInvoker);
} else {
String errorMessage =
"Method " + name + "(" + Arrays.toString(parameters) + ") does not exist";
logger.log(Level.WARNING, errorMessage);
throw new Py4JException(errorMessage);
}
}
return mInvoker;
}
/**
* Method to remove the user profile from cache.
*
* @param userId
*/
protected void removeProfileDataFromCache(String userId) throws ProfileServiceException {
if (logger.isLoggable(Level.FINEST)) {
logger.entering(sourceClass, "removeProfileDataFromCache", userId);
}
if (isEmail(userId)) {
String key;
Set<String> keys = lruCache.getKeySet();
Iterator<String> itr = keys.iterator();
while (itr.hasNext()) {
key = itr.next();
Document data = lruCache.get(key);
// check if email in profile object is same as input userId
String email = "";
try {
email = DOMUtil.value(data, Profile.xpathMap.get("email"));
} catch (XMLException e) {
continue;
}
// cache hit
if (StringUtil.equalsIgnoreCase(email, userId)) {
lruCache.remove(key);
}
}
// Cache miss
} else {
lruCache.remove(userId);
}
if (logger.isLoggable(Level.FINEST)) {
logger.exiting(sourceClass, "removeProfileDataFromCache");
}
}
private void waitForBlockStored(Sha256Hash hash) {
if (hash.toString().equals("0000000000000000000000000000000000000000000000000000000000000000"))
return;
try {
if (file_db.getBlockMap().containsKey(hash)) return;
} finally {
}
Semaphore block_wait_sem = null;
synchronized (in_progress) {
block_wait_sem = in_progress.get(hash);
if (block_wait_sem == null) {
block_wait_sem = new Semaphore(0);
in_progress.put(hash, block_wait_sem);
}
}
try {
// System.out.println("Waiting for " + hash);
block_wait_sem.acquire(1);
} catch (java.lang.InterruptedException e) {
throw new RuntimeException(e);
}
}
public Pattern getPatternForRegex(String regex) {
Pattern pattern = cache.get(regex);
if (pattern == null) {
pattern = Pattern.compile(regex);
cache.put(regex, pattern);
}
return pattern;
}
@Test
public void shouldReturnValueWhenCallGetWithKeyTest() {
LRUCache cacheOneElement = new LRUCache(5);
cacheOneElement.set(1, 1);
int expected = 1;
int actual = cacheOneElement.get(1);
assertEquals(expected, actual);
}
/** @throws Exception On test failure. */
@AfterClass(groups = {"cache"})
public void clear() throws Exception {
fillCache();
AssertJUnit.assertEquals(5, cache.size());
cache.clear();
AssertJUnit.assertEquals(0, cache.size());
cache.close();
}
@Test
public void shouldReturnMinusOneWhenNotFoundTest() {
LRUCache cache = new LRUCache(5);
cache.set(1, 1);
int expected = -1;
int actual = cache.get(2);
assertEquals(expected, actual);
}
@Test
public void smoke() {
LRUCache<String, String> cache = new LRUCache<String, String>(2);
cache.put("a", "a");
cache.put("b", "b");
cache.put("c", "c");
List<String> witness = new LinkedList<String>();
witness.add("b");
witness.add("c");
assertEquals(witness, cache.keyList());
}
public void testLRUCache() {
MyService service1 = new MyService();
MyService service2 = new MyService();
cache.put("A", service1);
cache.put("B", service2);
assertEquals(2, cache.size());
assertSame(service1, cache.get("A"));
assertSame(service2, cache.get("B"));
}
/*
* Method to check if the Profile is cached. Calls findInCache to find for the profile in Cache.
*
* @param userId
* @return Document
*/
private Document getProfileDataFromCache(String userId) {
// this should return just the content ..xmldoc
// should a have a common caching framework for all services
Document data = null;
if (isEmail(userId)) {
data = findInCache(userId);
} else {
if (lruCache.hasKey(userId)) {
data = lruCache.get(userId);
}
}
return data;
}
private String getNamespace(int id) throws IOException {
Integer cacheID = new Integer(id);
String namespace = namespaceCache.get(cacheID);
if (namespace == null) {
byte[] namespaceData = dataStore.getData(id);
namespace = data2namespace(namespaceData);
namespaceCache.put(cacheID, namespace);
}
return namespace;
}
@Test
public void shouldReturnMinusOneAfterLatestKeyGetTest() {
LRUCache cache = new LRUCache(5);
cache.set(1, 1);
cache.set(2, 2);
cache.set(3, 3);
cache.set(4, 4);
cache.set(5, 5);
cache.set(6, 6);
int expected = -1;
int actual = cache.get(1);
assertEquals(expected, actual);
}
/**
* Stores the supplied value and returns the ID that has been assigned to it. In case the value
* was already present, the value will not be stored again and the ID of the existing value is
* returned.
*
* @param value The Value to store.
* @return The ID that has been assigned to the value.
* @exception IOException If an I/O error occurred.
*/
public int storeValue(Value value) throws IOException {
// Try to get the internal ID from the value itself
boolean isOwnValue = isOwnValue(value);
if (isOwnValue) {
NativeValue nativeValue = (NativeValue) value;
if (revisionIsCurrent(nativeValue)) {
// Value's ID is still current
int id = nativeValue.getInternalID();
if (id != NativeValue.UNKNOWN_ID) {
return id;
}
}
}
// ID not stored in value itself, try the ID cache
Integer cachedID = valueIDCache.get(value);
if (cachedID != null) {
int id = cachedID.intValue();
if (isOwnValue) {
// Store id in value for fast access in any consecutive calls
((NativeValue) value).setInternalID(id, revision);
}
return id;
}
// Unable to get internal ID in a cheap way, just store it in the data
// store which will handle duplicates
byte[] valueData = value2data(value, true);
int id = dataStore.storeData(valueData);
NativeValue nv = isOwnValue ? (NativeValue) value : getNativeValue(value);
// Store id in value for fast access in any consecutive calls
nv.setInternalID(id, revision);
// Update cache
valueIDCache.put(nv, new Integer(id));
return id;
}
/** Gets the lock on a document. */
public Lock getLock(final Serializable id) throws StorageException {
serializationLock.lock();
try {
Lock lock;
if (caching && (lock = lockCache.get(id)) != null) {
return lock == NULL_LOCK ? null : lock;
}
// no transaction needed, single operation
lock = mapper.getLock(id);
if (caching) {
lockCache.put(id, lock == null ? NULL_LOCK : lock);
}
return lock;
} finally {
serializationLock.unlock();
}
}
public void testLRUCacheStop() throws Exception {
MyService service1 = new MyService();
MyService service2 = new MyService();
cache.put("A", service1);
cache.put("B", service2);
assertEquals(false, service1.isStopped());
assertEquals(false, service2.isStopped());
cache.stop();
assertEquals(0, cache.size());
assertEquals(true, service1.isStopped());
assertEquals(true, service2.isStopped());
}
/** @throws Exception On test failure. */
@Test(
groups = {"cache"},
threadPoolSize = 5,
invocationCount = 100,
timeOut = 60000)
public void get() throws Exception {
SearchResult result =
cache.get(new SearchRequest("dc=ldaptive,dc=org", new SearchFilter("uid=3")));
AssertJUnit.assertEquals(
new SearchResult(new LdapEntry("uid=3,ou=test,dc=ldaptive,dc=org")), result);
result = cache.get(new SearchRequest("dc=ldaptive,dc=org", new SearchFilter("uid=4")));
AssertJUnit.assertEquals(
new SearchResult(new LdapEntry("uid=4,ou=test,dc=ldaptive,dc=org")), result);
result = cache.get(new SearchRequest("dc=ldaptive,dc=org", new SearchFilter("uid=5")));
AssertJUnit.assertEquals(
new SearchResult(new LdapEntry("uid=5,ou=test,dc=ldaptive,dc=org")), result);
}
private RecentLabelList(int paramInt) {
int i;
mRecentLabelsLRU = new LRUCache(i);
this$1 = paramInt.iterator();
while (hasNext()) {
paramInt = (String) next();
mRecentLabelsLRU.addElement(paramInt, null);
}
}
public String format(double value) {
String f = cache.get(value);
if (f == null) {
f = String.format(format, value);
cache.put(value, f);
// if ( cache.usedEntries() < maxCacheSize ) {
// System.out.printf("CACHE size %d%n", cache.usedEntries());
// } else {
// System.out.printf("CACHE is full %f%n", value);
// }
// }
// } else {
// System.out.printf("CACHE hit %f%n", value);
// }
}
return f;
}
public Transaction getTransaction(Sha256Hash hash) {
Transaction tx = null;
synchronized (transaction_cache) {
tx = transaction_cache.get(hash);
}
if (tx == null) {
SerializedTransaction s_tx = file_db.getTransactionMap().get(hash);
if (s_tx != null) {
tx = s_tx.getTx(params);
synchronized (transaction_cache) {
transaction_cache.put(hash, SerializedTransaction.scrubTransaction(params, tx));
}
}
}
return tx;
}
/**
* Gets the value for the specified ID.
*
* @param id A value ID.
* @return The value for the ID, or <tt>null</tt> no such value could be found.
* @exception IOException If an I/O error occurred.
*/
public NativeValue getValue(int id) throws IOException {
// Check value cache
Integer cacheID = new Integer(id);
NativeValue resultValue = valueCache.get(cacheID);
if (resultValue == null) {
// Value not in cache, fetch it from file
byte[] data = dataStore.getData(id);
if (data != null) {
resultValue = data2value(id, data);
// Store value in cache
valueCache.put(cacheID, resultValue);
}
}
return resultValue;
}
@Test
@Ignore // slow test that is known to pass
public void multiThreadedScenario() throws InterruptedException {
int cacheSize = 100;
int worldSize = cacheSize * 2;
LRUCache<String, String> lruCache = new LRUCache<String, String>(cacheSize);
T_LRUCache<String> tlruCache = new T_LRUCache<String>(cacheSize);
SimulatorRunnable[] simulatorArray = new SimulatorRunnable[5];
for (int i = 0; i < simulatorArray.length; i++) {
simulatorArray[i] = new SimulatorRunnable(lruCache, tlruCache, worldSize);
}
for (int i = 0; i < simulatorArray.length; i++) {
simulatorArray[i].start();
}
for (int i = 0; i < simulatorArray.length; i++) {
simulatorArray[i].join();
}
assertEquals(tlruCache.keyList(), lruCache.keyList());
}
/**
* Clear the whole cache.
*/
public synchronized void clear() {
synchronized(cache){
for(String key : keys){
super.remove(key);
File fileForKey = getFileForKey(key);
fileForKey.delete();
}
keys.clear();
}
}
public void clearCaches() {
serializationLock.lock();
try {
if (caching) {
lockCache.clear();
}
} finally {
serializationLock.unlock();
}
}
/**
* Removes both: from the memory and from the disk
*/
public synchronized void remove(String key) {
synchronized(cache){
if(DEBUG){
System.out.println("Disk cache - Removing: "+key);
}
super.remove(key);
File fileForKey = getFileForKey(key);
fileForKey.delete();
keys.remove(key);
}
}
/**
* Adds to both: the memory and the disk
*/
public synchronized void add(String key, Serializable n) {
synchronized(cache){
super.add(key, n);
File fileForKey = getFileForKey(key);
if(DEBUG){
System.out.println("Disk cache - Adding: "+key+" file: "+fileForKey);
}
REF.writeToFile(n, fileForKey);
keys.add(key);
}
}
private int getNamespaceID(String namespace, boolean create) throws IOException {
Integer cacheID = namespaceIDCache.get(namespace);
if (cacheID != null) {
return cacheID.intValue();
}
byte[] namespaceData = namespace.getBytes("UTF-8");
int id;
if (create) {
id = dataStore.storeData(namespaceData);
} else {
id = dataStore.getID(namespaceData);
}
if (id != -1) {
namespaceIDCache.put(namespace, new Integer(id));
}
return id;
}
/**
* Fetch cache value
*
* @param id ItemId
* @return cached value or null when not in cache
*/
public Boolean get(ItemId id) {
if (maxCacheSize < 1) {
return null;
}
accesses++;
Boolean obj = readAccessCache.get(id);
if (obj == null) {
misses++;
} else {
hits++;
}
return obj;
}
/*
* Method to search the cache
*
* @param userId
* @return Document
*/
private Document findInCache(String userId) {
String key;
Set<String> keys = lruCache.getKeySet();
Iterator<String> itr = keys.iterator();
while (itr.hasNext()) {
key = itr.next();
Document data = lruCache.get(key);
// check if email in profile object is same as input userId
String email = "";
try {
email = DOMUtil.value(data, Profile.xpathMap.get("email"), Profile.nameSpaceCtx);
} catch (XMLException e) {
continue;
}
// cache hit
if (StringUtil.equalsIgnoreCase(email, userId)) {
return data;
}
}
// Cache miss
return null;
}
/** Unlocks a document. */
public Lock removeLock(final Serializable id, final String owner) throws StorageException {
serializationLock.lock();
try {
Lock oldLock = null;
if (caching && (oldLock = lockCache.get(id)) == NULL_LOCK) {
return null;
}
if (oldLock != null && !canLockBeRemoved(oldLock, owner)) {
// existing mismatched lock, flag failure
oldLock = new Lock(oldLock, true);
} else {
if (oldLock == null) {
oldLock =
callInTransaction(
new Callable<Lock>() {
@Override
public Lock call() throws Exception {
return mapper.removeLock(id, owner, false);
}
});
} else {
// we know the previous lock, we can force
// no transaction needed, single operation
mapper.removeLock(id, owner, true);
}
}
if (caching) {
if (oldLock != null && oldLock.getFailed()) {
// failed, but we now know the existing lock
lockCache.put(id, new Lock(oldLock, false));
} else {
lockCache.put(id, NULL_LOCK);
}
}
return oldLock;
} finally {
serializationLock.unlock();
}
}
protected Lock setLockInternal(final Serializable id, final Lock lock) throws StorageException {
serializationLock.lock();
try {
Lock oldLock;
if (caching && (oldLock = lockCache.get(id)) != null && oldLock != NULL_LOCK) {
return oldLock;
}
oldLock =
callInTransaction(
new Callable<Lock>() {
@Override
public Lock call() throws Exception {
return mapper.setLock(id, lock);
}
});
if (caching && oldLock == null) {
lockCache.put(id, lock == null ? NULL_LOCK : lock);
}
return oldLock;
} finally {
serializationLock.unlock();
}
}