Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.loaders.leveldb;
  
  import java.io.File;
  import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 @CacheLoaderMetadata(configurationClass = LevelDBCacheStoreConfig.class)
 public class LevelDBCacheStore extends LockSupportCacheStore<Integer> {
 	private static final Log log = LogFactory.getLog(LevelDBCacheStore.classLog.class);
 
 	private DB db;
 	private DB expiredDb;
 
 	public Class<? extends CacheLoaderConfiggetConfigurationClass() {
 		return LevelDBCacheStoreConfig.class;
 	}
 
 	public void init(CacheLoaderConfig configCache<?, ?> cache,
 		super.init(configcachem);
 
 		this. = (LevelDBCacheStoreConfigconfig;
 	}
 
 	public void start() throws CacheLoaderException {
 
 		try {
 		} catch (IOException e) {
 			throw new ConfigurationException("Unable to open database"e);
 		}
 
 		super.start();
 	}

Creates database if it doesn't exist.

Returns:
database at location
Throws:
java.io.IOException
 
 	protected DB openDatabase(String locationOptions options)
 			throws IOException {
 		return ..open(new File(location), options);
 	}
 
 	protected void destroyDatabase(String locationthrows IOException {
 		File dir = new File(location);
 
 	}
 
 	protected DB reinitDatabase(String locationOptions options)
 			throws IOException {
 		destroyDatabase(location);
 		return openDatabase(locationoptions);
 	}
 
 	protected void reinitAllDatabases() throws IOException {
	}
	public void stop() throws CacheLoaderException {
	   try {
	      .close();
	   } catch (IOException e) {
	      .warnUnableToCloseDb(e);
	   }
	   
	   try {
         .close();
      } catch (IOException e) {
         .warnUnableToCloseExpiredDb(e);
      }
		super.stop();
	}
	protected void clearLockSafe() throws CacheLoaderException {
		long count = 0;
		DBIterator it = .iterator(new ReadOptions().fillCache(false));
		boolean destroyDatabase = false;
		if (.getClearThreshold() <= 0) {
			try {
				for (it.seekToFirst(); it.hasNext();) {
					Map.Entry<byte[], byte[]> entry = it.next();
					.delete(entry.getKey());
					count++;
					if (count > .) {
						destroyDatabase = true;
						break;
					}
				}
finally {
				try {
               it.close();
            } catch (IOException e) {
               .warnUnableToCloseDbIterator(e);
            }
			}
else {
			destroyDatabase = true;
		}
		if (destroyDatabase) {
			try {
catch (IOException e) {
				throw new CacheLoaderException(e);
			}
		}
	}
		DBIterator it = .iterator(new ReadOptions().fillCache(false));
		try {
			for (it.seekToFirst(); it.hasNext();) {
				Map.Entry<byte[], byte[]> entry = it.next();
				entries.add(unmarshall(entry));
			}
catch (Exception e) {
			throw new CacheLoaderException(e);
finally {
			try {
            it.close();
         } catch (IOException e) {
            .warnUnableToCloseDbIterator(e);
         }
		}
		return entries;
	}
	protected Set<InternalCacheEntryloadLockSafe(int maxEntries)
		if (maxEntries <= 0)
			return Collections.emptySet();
		DBIterator it = .iterator(new ReadOptions().fillCache(false));
		try {
			for (int i = 0; it.hasNext() && i < maxEntriesi++) {
				Map.Entry<byte[], byte[]> entry = it.next();
				entries.add(unmarshall(entry));
			}
catch (Exception e) {
			throw new CacheLoaderException(e);
finally {
			try {
            it.close();
         } catch (IOException e) {
            .warnUnableToCloseDbIterator(e);
         }
		}
		return entries;
	}
	protected Set<ObjectloadAllKeysLockSafe(Set<ObjectkeysToExclude)
		Set<Objectkeys = new HashSet<Object>();
		DBIterator it = .iterator(new ReadOptions().fillCache(false));
		try {
			for (it.seekToFirst(); it.hasNext();) {
				Map.Entry<byte[], byte[]> entry = it.next();
				Object key = unmarshall(entry.getKey());
				if (keysToExclude == null || keysToExclude.isEmpty()
						|| !keysToExclude.contains(key))
					keys.add(key);
			}
			return keys;
catch (Exception e) {
			throw new CacheLoaderException(e);
finally {
			try {
            it.close();
         } catch (IOException e) {
            .warnUnableToCloseDbIterator(e);
         }
		}
	}
	protected void toStreamLockSafe(ObjectOutput oos)
		DBIterator it = .iterator(new ReadOptions().fillCache(false));
		try {
			for (it.seekToFirst(); it.hasNext();) {
				Map.Entry<byte[], byte[]> entry = it.next();
			}
catch (Exception e) {
			throw new CacheLoaderException(e);
finally {
			try {
            it.close();
         } catch (IOException e) {
            .warnUnableToCloseDbIterator(e);
         }
		}
	}
	protected void fromStreamLockSafe(ObjectInput ois)
		try {
			while (true) {
				if (entry == null)
					break;
				.put(marshall(entry.getKey()), marshall(entry));
			}
catch (InterruptedException ie) {
catch (Exception e) {
			throw new CacheLoaderException(e);
		}
	}
	protected boolean removeLockSafe(Object keyInteger lockingKey)
		try {
			byte[] keyBytes = marshall(key);
			if (.get(keyBytes) == null) {
				return false;
			}
			.delete(keyBytes);
			return true;
catch (Exception e) {
			throw new CacheLoaderException(e);
		}
	}
	protected void storeLockSafe(InternalCacheEntry edInteger lockingKey)
		try {
			if (ed.canExpire()) {
			}
catch (Exception e) {
			throw new DBException(e);
		}
	}
	protected InternalCacheEntry loadLockSafe(Object keyInteger lockingKey)
		try {
					.get(marshall(key)), key);
			if (ice != null && ice.isExpired(System.currentTimeMillis())) {
				removeLockSafe(keylockingKey);
				return null;
			}
			return ice;
catch (Exception e) {
			throw new CacheLoaderException(e);
		}
	}
	protected Integer getLockFromKey(Object keythrows CacheLoaderException {
		return key.hashCode();
	}
	@SuppressWarnings("unchecked")
	protected void purgeInternal() throws CacheLoaderException {
		try {
			// Drain queue and update expiry tree
			List<ExpiryEntryentries = new ArrayList<ExpiryEntry>();
			for (ExpiryEntry entry : entries) {
				final byte[] expiryBytes = marshall(entry.expiry);
				final byte[] keyBytes = marshall(entry.key);
				final byte[] existingBytes = .get(expiryBytes);
				if (existingBytes != null) {
					// in the case of collision make the key a List ...
					final Object existing = unmarshall(existingBytes);
					if (existing instanceof List) {
						((List<Object>) existing).add(entry.key);
						.put(expiryBytesmarshall(existing));
else {
						List<Objectal = new ArrayList<Object>(2);
						al.add(existing);
						al.add(entry.key);
						.put(expiryBytesmarshall(al));
					}
else {
					.put(marshall(expiryBytes), keyBytes);
				}
			}
			List<Longtimes = new ArrayList<Long>();
			List<Objectkeys = new ArrayList<Object>();
					.fillCache(false));
			try {
				for (it.seekToFirst(); it.hasNext();) {
					Map.Entry<byte[], byte[]> entry = it.next();
					Long time = (Longunmarshall(entry.getKey());
					if (time > System.currentTimeMillis())
						break;
					times.add(time);
					Object key = unmarshall(entry.getValue());
					if (key instanceof List)
						keys.addAll((List<?>) key);
					else
						keys.add(key);
				}
				for (Long time : times) {
				}
				if (!keys.isEmpty())
					.debugf("purge (up to) %d entries"keys.size());
				int count = 0;
				long currentTimeMillis = System.currentTimeMillis();
				for (Object key : keys) {
					byte[] keyBytes = marshall(key);
					byte[] b = .get(keyBytes);
					if (b == null)
						continue;
					if (ice.isExpired(currentTimeMillis)) {
						// somewhat inefficient to FIND then REMOVE...
						.delete(keyBytes);
						count++;
					}
				}
				if (count != 0)
					.debugf("purged %d entries"count);
catch (Exception e) {
				throw new CacheLoaderException(e);
finally {
			   try {
			      it.close();
			   } catch (IOException e) {
			   }
			}
catch (Exception e) {
			throw new CacheLoaderException(e);
		}
	}
	private byte[] marshall(InternalCacheEntry entrythrows IOException,
	}
	private byte[] marshall(Object entrythrows IOException,
	}
	private Object unmarshall(byte[] bytesthrows IOException,
		if (bytes == null)
			return null;
	}
	private InternalCacheEntry unmarshall(Map.Entry<byte[], byte[]> entry)
		if (entry == null || entry.getValue() == null)
			return null;
		Object k = unmarshall(entry.getKey());
	}
	private InternalCacheEntry unmarshall(byte[] valueObject key)
		if (value == null)
			return null;
		return v.toInternalCacheEntry(key);
	}
	private void addNewExpiry(InternalCacheEntry entrythrows IOException {
		long expiry = entry.getExpiryTime();
		if (entry.getMaxIdle() > 0) {
			// Coding getExpiryTime() for transient entries has the risk of
			// being a moving target
			// which could lead to unexpected results, hence, InternalCacheEntry
			// calls are required
			expiry = entry.getMaxIdle() + System.currentTimeMillis();
		}
		Long at = expiry;
		Object key = entry.getKey();
		try {
catch (InterruptedException e) {
			Thread.currentThread().interrupt(); // Restore interruption status
		}
	}
	private static final class ExpiryEntry {
		private final Long expiry;
		private final Object key;
		private ExpiryEntry(long expiryObject key) {
			this. = expiry;
			this. = key;
		}
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + (( == null) ? 0 : .hashCode());
			return result;
		}
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			ExpiryEntry other = (ExpiryEntryobj;
			if ( == null) {
				if (other.key != null)
					return false;
else if (!.equals(other.key))
				return false;
			return true;
		}
	}
New to GrepCode? Check out our FAQ X