/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
* Copyright 2014 ForgeRock AS
|
*/
|
package org.opends.server.backends.persistit;
|
|
import java.io.File;
|
import java.util.Map;
|
import java.util.Properties;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import org.forgerock.i18n.slf4j.LocalizedLogger;
|
import org.forgerock.opendj.config.server.ConfigException;
|
import org.opends.server.admin.std.server.LocalDBBackendCfg;
|
import org.opends.server.backends.pluggable.NotImplementedException;
|
import org.opends.server.backends.pluggable.RootContainer;
|
import org.opends.server.backends.pluggable.SuffixContainer;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.DirectoryException;
|
import org.opends.server.types.FilePermission;
|
import org.opends.server.types.InitializationException;
|
|
import com.persistit.Persistit;
|
import com.persistit.Volume;
|
import com.persistit.exception.PersistitException;
|
|
import static org.opends.messages.ConfigMessages.*;
|
import static org.opends.messages.JebMessages.*;
|
import static org.opends.server.util.StaticUtils.*;
|
|
/**
|
* Persistit implementation of a {@link RootContainer}.
|
*/
|
class PersistitRootContainer implements RootContainer<PersistitSuffixContainer>
|
{
|
private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();
|
|
private final PersistitBackend backend;
|
private final LocalDBBackendCfg cfg;
|
private Persistit db;
|
|
/** The base DNs contained in this root container. */
|
private final ConcurrentHashMap<DN, PersistitSuffixContainer> suffixContainers =
|
new ConcurrentHashMap<DN, PersistitSuffixContainer>();
|
|
/**
|
* Constructor for this class.
|
*
|
* @param backend
|
* the persistit backend
|
* @param config
|
* the configuration object
|
*/
|
PersistitRootContainer(PersistitBackend backend, LocalDBBackendCfg config)
|
{
|
this.backend = backend;
|
this.cfg = config;
|
}
|
|
/**
|
* Returns the persistit backend.
|
*
|
* @return the persistit backend
|
*/
|
public final PersistitBackend getBackend()
|
{
|
return backend;
|
}
|
|
/** {@inheritDoc} */
|
@Override
|
public Map<DN, PersistitSuffixContainer> getSuffixContainers()
|
{
|
return suffixContainers;
|
}
|
|
/**
|
* Code copied from
|
* {@link org.opends.server.backends.jeb. RootContainer#open(com.sleepycat.je.EnvironmentConfig)}
|
*
|
* @throws ConfigException
|
* If an configuration error occurs while creating the environment.
|
*/
|
void open() throws ConfigException
|
{
|
// Determine the backend database directory.
|
File parentDirectory = getFileForPath(cfg.getDBDirectory());
|
File backendDirectory = new File(parentDirectory, cfg.getBackendId());
|
|
// Create the directory if it doesn't exist.
|
if (!backendDirectory.exists())
|
{
|
if (!backendDirectory.mkdirs())
|
{
|
throw new ConfigException(ERR_JEB_CREATE_FAIL.get(backendDirectory.getPath()));
|
}
|
}
|
// Make sure the directory is valid.
|
else if (!backendDirectory.isDirectory())
|
{
|
throw new ConfigException(ERR_JEB_DIRECTORY_INVALID.get(backendDirectory.getPath()));
|
}
|
|
FilePermission backendPermission;
|
try
|
{
|
backendPermission = FilePermission.decodeUNIXMode(cfg.getDBDirectoryPermissions());
|
}
|
catch (Exception e)
|
{
|
throw new ConfigException(ERR_CONFIG_BACKEND_MODE_INVALID.get(cfg.dn()));
|
}
|
|
// Make sure the mode will allow the server itself access to the database
|
if (!backendPermission.isOwnerWritable()
|
|| !backendPermission.isOwnerReadable()
|
|| !backendPermission.isOwnerExecutable())
|
{
|
throw new ConfigException(ERR_CONFIG_BACKEND_INSANE_MODE.get(cfg.getDBDirectoryPermissions()));
|
}
|
|
// Get the backend database backendDirectory permissions and apply
|
if (FilePermission.canSetPermissions())
|
{
|
try
|
{
|
if (!FilePermission.setPermissions(backendDirectory, backendPermission))
|
{
|
logger.warn(WARN_JEB_UNABLE_SET_PERMISSIONS, backendPermission, backendDirectory);
|
}
|
}
|
catch (Exception e)
|
{
|
// Log an warning that the permissions were not set.
|
logger.warn(WARN_JEB_SET_PERMISSIONS_FAILED, backendDirectory, e);
|
}
|
}
|
|
openAndRegisterSuffixContainers(backendDirectory);
|
}
|
|
private void openAndRegisterSuffixContainers(File backendDirectory)
|
{
|
DN[] baseDNs = backend.getBaseDNs();
|
final Properties properties = new Properties();
|
properties.setProperty("datapath", backendDirectory.toString());
|
properties.setProperty("logpath", backendDirectory + "/log");
|
properties.setProperty("logfile", "${logpath}/dj_${timestamp}.log");
|
properties.setProperty("buffer.count.16384", "64K");
|
for (int i = 0; i < baseDNs.length; i++)
|
{
|
// TODO JNR in the replace() down below,
|
// persistit does not like commas and does not know how to escape them
|
final String baseDN = toVolumeName(baseDNs[i]);
|
properties.setProperty("volume." + (i + 1), "${datapath}/" + baseDN + ",create,pageSize:16K,"
|
+ "initialSize:50M,extensionSize:1M,maximumSize:10G");
|
}
|
properties.setProperty("journalpath", "${datapath}/dj_journal");
|
try
|
{
|
db = new Persistit(properties);
|
db.initialize();
|
|
openAndRegisterSuffixContainers(baseDNs);
|
|
if (logger.isTraceEnabled())
|
{
|
logger.trace("Persistit (%s) environment opened with the following config: %n%s",
|
Persistit.VERSION, properties);
|
|
// Get current size of heap in bytes
|
long heapSize = Runtime.getRuntime().totalMemory();
|
|
// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
|
// Any attempt will result in an OutOfMemoryException.
|
long heapMaxSize = Runtime.getRuntime().maxMemory();
|
|
// Get amount of free memory within the heap in bytes. This size will increase
|
// after garbage collection and decrease as new objects are created.
|
long heapFreeSize = Runtime.getRuntime().freeMemory();
|
|
logger.trace("Current size of heap: %d bytes", heapSize);
|
logger.trace("Max size of heap: %d bytes", heapMaxSize);
|
logger.trace("Free memory in heap: %d bytes", heapFreeSize);
|
}
|
}
|
catch (Exception e)
|
{
|
throw new NotImplementedException(e);
|
}
|
}
|
|
private void openAndRegisterSuffixContainers(DN[] baseDNs) throws PersistitException, InitializationException,
|
ConfigException, DirectoryException
|
{
|
for (DN baseDN : baseDNs)
|
{
|
PersistitSuffixContainer sc = openSuffixContainer(baseDN, null);
|
registerSuffixContainer(baseDN, sc);
|
}
|
}
|
|
private PersistitSuffixContainer openSuffixContainer(DN baseDN, String name) throws PersistitException,
|
DirectoryException
|
{
|
String databasePrefix;
|
if (name == null || name.equals(""))
|
{
|
databasePrefix = baseDN.toNormalizedString();
|
}
|
else
|
{
|
databasePrefix = name;
|
}
|
|
final Volume volume = db.loadVolume(toVolumeName(baseDN));
|
final PersistitSuffixContainer suffixContainer =
|
new PersistitSuffixContainer(baseDN, databasePrefix, this, db, volume);
|
suffixContainer.open();
|
return suffixContainer;
|
}
|
|
private String toVolumeName(DN dn)
|
{
|
return dn.toString().replace(",", "_");
|
}
|
|
private void registerSuffixContainer(DN baseDN, PersistitSuffixContainer suffixContainer)
|
throws InitializationException
|
{
|
PersistitSuffixContainer sc = suffixContainers.get(baseDN);
|
if (sc != null)
|
{
|
// If an entry container for this baseDN is already opened we do not allow
|
// another to be opened.
|
throw new InitializationException(ERR_JEB_ENTRY_CONTAINER_ALREADY_REGISTERED.get(sc.getIndexPrefix(), baseDN));
|
}
|
|
suffixContainers.put(baseDN, suffixContainer);
|
}
|
|
/** {@inheritDoc} */
|
@Override
|
public void close()
|
{
|
for (PersistitSuffixContainer sc : suffixContainers.values())
|
{
|
sc.close();
|
}
|
}
|
|
/** {@inheritDoc} */
|
@Override
|
public long getEntryCount()
|
{
|
boolean couldDetermineAllCounts = true;
|
long result = 0;
|
for (SuffixContainer suffixContainer : getSuffixContainers().values())
|
{
|
final long suffixCount = suffixContainer.getEntryCount();
|
if (suffixCount != -1)
|
{
|
result += suffixCount;
|
}
|
else
|
{
|
couldDetermineAllCounts = false;
|
}
|
}
|
return couldDetermineAllCounts ? result : -1;
|
}
|
|
/**
|
* Return the suffix container holding a specific DN.
|
*
|
* @param entryDN
|
* The DN for which to return the suffix container.
|
* @return The suffix container holding the DN
|
*/
|
PersistitSuffixContainer getSuffixContainer(DN entryDN)
|
{
|
PersistitSuffixContainer sc = null;
|
DN nodeDN = entryDN;
|
|
while (sc == null && nodeDN != null)
|
{
|
sc = suffixContainers.get(nodeDN);
|
if (sc == null)
|
{
|
nodeDN = nodeDN.getParentDNInSuffix();
|
}
|
}
|
|
return sc;
|
}
|
}
|
