/** {@inheritDoc} */
@Override()
public void initializeBackend() throws ConfigException, InitializationException {
// Checksum this db environment and register its offline state id/checksum.
DirectoryServer.registerOfflineBackendStateID(this.getBackendID(), checksumDbEnv());
if (rootContainer == null) {
EnvironmentConfig envConfig = ConfigurableEnvironment.parseConfigEntry(cfg);
rootContainer = initializeRootContainer(envConfig);
}
// Preload the database cache.
rootContainer.preload(cfg.getPreloadTimeLimit());
try {
// Log an informational message about the number of entries.
Message message =
NOTE_JEB_BACKEND_STARTED.get(cfg.getBackendId(), rootContainer.getEntryCount());
logError(message);
} catch (DatabaseException databaseException) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, databaseException);
}
Message message = WARN_JEB_GET_ENTRY_COUNT_FAILED.get(databaseException.getMessage());
throw new InitializationException(message, databaseException);
}
for (DN dn : cfg.getBaseDN()) {
try {
DirectoryServer.registerBaseDN(dn, this, false);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
Message message =
ERR_BACKEND_CANNOT_REGISTER_BASEDN.get(String.valueOf(dn), String.valueOf(e));
throw new InitializationException(message, e);
}
}
// Register a monitor provider for the environment.
rootContainerMonitor = rootContainer.getMonitorProvider();
DirectoryServer.registerMonitorProvider(rootContainerMonitor);
// Register as disk space monitor handler
File parentDirectory = getFileForPath(cfg.getDBDirectory());
File backendDirectory = new File(parentDirectory, cfg.getBackendId());
diskMonitor =
new DiskSpaceMonitor(
getBackendID() + " backend",
backendDirectory,
cfg.getDiskLowThreshold(),
cfg.getDiskFullThreshold(),
5,
TimeUnit.SECONDS,
this);
diskMonitor.initializeMonitorProvider(null);
DirectoryServer.registerMonitorProvider(diskMonitor);
// Register as an AlertGenerator.
DirectoryServer.registerAlertGenerator(this);
// Register this backend as a change listener.
cfg.addLocalDBChangeListener(this);
}
/** {@inheritDoc} */
@Override()
public LDIFImportResult importLDIF(LDIFImportConfig importConfig) throws DirectoryException {
RuntimeInformation.logInfo();
// If the backend already has the root container open, we must use the same
// underlying root container
boolean openRootContainer = rootContainer == null;
// If the rootContainer is open, the backend is initialized by something
// else.
// We can't do import while the backend is online.
if (!openRootContainer) {
Message message = ERR_JEB_IMPORT_BACKEND_ONLINE.get();
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
try {
EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
envConfig.setTransactional(false);
envConfig.setDurability(Durability.COMMIT_NO_SYNC);
envConfig.setLockTimeout(0, TimeUnit.SECONDS);
envConfig.setTxnTimeout(0, TimeUnit.SECONDS);
envConfig.setConfigParam(
EnvironmentConfig.CLEANER_MIN_FILE_UTILIZATION,
String.valueOf(cfg.getDBCleanerMinUtilization()));
envConfig.setConfigParam(
EnvironmentConfig.LOG_FILE_MAX, String.valueOf(cfg.getDBLogFileMax()));
if (!importConfig.appendToExistingData()) {
if (importConfig.clearBackend() || cfg.getBaseDN().size() <= 1) {
// We have the writer lock on the environment, now delete the
// environment and re-open it. Only do this when we are
// importing to all the base DNs in the backend or if the backend only
// have one base DN.
File parentDirectory = getFileForPath(cfg.getDBDirectory());
File backendDirectory = new File(parentDirectory, cfg.getBackendId());
// If the backend does not exist the import will create it.
if (backendDirectory.exists()) {
EnvManager.removeFiles(backendDirectory.getPath());
}
}
}
Importer importer = new Importer(importConfig, cfg, envConfig);
rootContainer = initializeRootContainer(envConfig);
return importer.processImport(rootContainer);
} catch (ExecutionException execEx) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, execEx);
}
if (execEx.getCause() instanceof DirectoryException) {
throw ((DirectoryException) execEx.getCause());
} else {
Message message = ERR_EXECUTION_ERROR.get(execEx.getMessage());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
}
} catch (InterruptedException intEx) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, intEx);
}
Message message = ERR_INTERRUPTED_ERROR.get(intEx.getMessage());
throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message);
} catch (JebException je) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, je);
}
throw new DirectoryException(
DirectoryServer.getServerErrorResultCode(), je.getMessageObject());
} catch (InitializationException ie) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, ie);
}
throw new DirectoryException(
DirectoryServer.getServerErrorResultCode(), ie.getMessageObject());
} catch (ConfigException ce) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, ce);
}
throw new DirectoryException(
DirectoryServer.getServerErrorResultCode(), ce.getMessageObject());
} finally {
// leave the backend in the same state.
try {
if (rootContainer != null) {
long startTime = System.currentTimeMillis();
rootContainer.close();
long finishTime = System.currentTimeMillis();
long closeTime = (finishTime - startTime) / 1000;
Message msg = NOTE_JEB_IMPORT_LDIF_ROOTCONTAINER_CLOSE.get(closeTime);
logError(msg);
rootContainer = null;
}
// Sync the environment to disk.
if (debugEnabled()) {
Message message = NOTE_JEB_IMPORT_CLOSING_DATABASE.get();
TRACER.debugInfo(message.toString());
}
} catch (DatabaseException de) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, de);
}
}
}
}
/** {@inheritDoc} */
public ConfigChangeResult applyConfigurationChange(LocalDBBackendCfg newCfg) {
ConfigChangeResult ccr;
ResultCode resultCode = ResultCode.SUCCESS;
ArrayList<Message> messages = new ArrayList<Message>();
try {
if (rootContainer != null) {
DN[] newBaseDNs = new DN[newCfg.getBaseDN().size()];
newBaseDNs = newCfg.getBaseDN().toArray(newBaseDNs);
// Check for changes to the base DNs.
for (DN baseDN : cfg.getBaseDN()) {
boolean found = false;
for (DN dn : newBaseDNs) {
if (dn.equals(baseDN)) {
found = true;
}
}
if (!found) {
// The base DN was deleted.
DirectoryServer.deregisterBaseDN(baseDN);
EntryContainer ec = rootContainer.unregisterEntryContainer(baseDN);
ec.close();
ec.delete();
}
}
for (DN baseDN : newBaseDNs) {
if (!rootContainer.getBaseDNs().contains(baseDN)) {
try {
// The base DN was added.
EntryContainer ec = rootContainer.openEntryContainer(baseDN, null);
rootContainer.registerEntryContainer(baseDN, ec);
DirectoryServer.registerBaseDN(baseDN, this, false);
} catch (Exception e) {
if (debugEnabled()) {
TRACER.debugCaught(DebugLogLevel.ERROR, e);
}
resultCode = DirectoryServer.getServerErrorResultCode();
messages.add(
ERR_BACKEND_CANNOT_REGISTER_BASEDN.get(
String.valueOf(baseDN), String.valueOf(e)));
ccr = new ConfigChangeResult(resultCode, false, messages);
return ccr;
}
}
}
baseDNs = newBaseDNs;
}
if (cfg.getDiskFullThreshold() != newCfg.getDiskFullThreshold()
|| cfg.getDiskLowThreshold() != newCfg.getDiskLowThreshold()) {
diskMonitor.setFullThreshold(newCfg.getDiskFullThreshold());
diskMonitor.setLowThreshold(newCfg.getDiskLowThreshold());
}
// Put the new configuration in place.
this.cfg = newCfg;
} catch (Exception e) {
messages.add(Message.raw(stackTraceToSingleLineString(e)));
ccr = new ConfigChangeResult(DirectoryServer.getServerErrorResultCode(), false, messages);
return ccr;
}
ccr = new ConfigChangeResult(resultCode, false, messages);
return ccr;
}