@Override protected void finalize() throws Throwable { super.finalize(); if (_environment != null) { _environment.close(); cleanDirectory(); } }
@Override public <K, V> BerkeleyDbMap<K, V> createMap(final Class<K> keyType, final Class<V> valueType) throws IllegalStateException { try { final EntryBinding keyBinding = createBinding(keyType); final EntryBinding valueBinding = createBinding(valueType); final Database database = createDatabase(); final StoredMap map = new StoredMap(database, keyBinding, valueBinding, true); return new BerkeleyDbMap<>(getEnvironment(), database, map); } catch (final DatabaseException e) { throw new IllegalStateException(e); } }
@Override public <E> BerkeleyDbList<E> createList(final Class<E> valueType) throws IllegalStateException { final BerkeleyDbMap<Integer, E> map = createMap(Integer.class, valueType); // Berkeley StoredLists are non-functional! // return new StoredList<E>(createDatabase(), valueBinding, true); return new BerkeleyDbList<>(map); }
public Object createProvidedCollection(final ProvidedPropertyDescriptor providedDescriptor) { final Type typeArgument = providedDescriptor.getTypeArgument(0); final Class<?> clazz1 = (Class<?>) typeArgument; if (providedDescriptor.isList()) { return createList(clazz1); } else if (providedDescriptor.isSet()) { return createSet(clazz1); } else if (providedDescriptor.isMap()) { final Class<?> clazz2 = (Class<?>) providedDescriptor.getTypeArgument(1); return createMap(clazz1, clazz2); } else { // This should never happen (is checked by the // ProvidedDescriptor) throw new IllegalStateException(); } }
if (berkeleyDbStorageProvider != null) { final File parentDirectory = new File(_interceptor.getTemporaryStorageDirectory()); final BerkeleyDbStorageProvider storageProvider = new BerkeleyDbStorageProvider(parentDirectory); final Boolean cleanDirectoryOnStartup = berkeleyDbStorageProvider.isCleanDirectoryOnStartup(); if (cleanDirectoryOnStartup != null && cleanDirectoryOnStartup) { storageProvider.cleanDirectory();
/** * Cleans the parent directory of this storage provider. This action will * delete all previous collection storages made in this directory, and thus * it should only be invoked either before any collections has been made or * when all collections are ensured to be unused. */ public void cleanDirectory() { final File[] directories = _parentDirectory.listFiles((dir, name) -> name.startsWith(DIRECTORY_PREFIX)); for (final File directory : directories) { delete(directory); } }
private Database createDatabase() throws DatabaseException { final DatabaseConfig databaseConfig = new DatabaseConfig(); databaseConfig.setAllowCreate(true); final String databaseName = UUID.randomUUID().toString(); return getEnvironment().openDatabase(null, databaseName, databaseConfig); }
protected Environment getEnvironment() throws DatabaseException { if (_environment == null) { final EnvironmentConfig config = new EnvironmentConfig(); config.setAllowCreate(true); final File targetDir = getTargetDir(); _environment = new Environment(targetDir, config); } return _environment; }
/** * Recursively deletes a directory and all it's files * * @param file */ private void delete(final File file) { if (file.isDirectory()) { final File[] children = file.listFiles(); for (final File child : children) { delete(child); } } if (!file.delete()) { if (!file.isDirectory()) { logger.warn("Unable to clean/delete file: {}", file); } else { logger.debug("Unable to clean/delete directory: {}", file); } } }
@Override public <E> BerkeleyDbSet<E> createSet(final Class<E> valueType) throws IllegalStateException { try { final Database database = createDatabase(); final StoredKeySet set = new StoredKeySet(database, createBinding(valueType), true); return new BerkeleyDbSet<>(getEnvironment(), database, set); } catch (final DatabaseException e) { throw new IllegalStateException(e); } }