Checkpoint commit for OPENDJ-1288 :
Migrate I18n and logging support to i18n framework and SLF4J
* Replace all ErrorLogger.logError calls by LocalizedLogger calls
** Use same logger than for debug logging if already used in class
** No more direct call to ErrorLogger
** All logging made through #error, #warn, #info or #debug methods
of LocalizedLogger
** Logging method used corresponds to message severity (eg, warn
is used when there is a WARN_XXX message), although some
occurences may not match (automatic conversion)
* Delete OpenDJLoggerAdapter and OpenDJLoggerFactory classes
as they have been ported to opendj-slf4j-adapter module
* Update dependencies to use opendj-slf4j-adapter and
exclude slf4j-jdk14
2 files deleted
262 files modified
| | |
| | | <!-- subsequent versions are not compatible with java 6, so force to use this version only --> |
| | | <dependency org="javax.servlet" name="javax.servlet-api" rev="[3.1-b02]" /> |
| | | <dependency org="com.sleepycat" name="je" rev="5.0.97" /> |
| | | <dependency org="org.forgerock.opendj" name="opendj-rest2ldap-servlet" rev="&opendj.sdk.version;" conf="default->master,compile"/> |
| | | <dependency org="org.forgerock.opendj" name="opendj-rest2ldap-servlet" rev="&opendj.sdk.version;" conf="default->master,compile"> |
| | | <exclude module="slf4j-jdk14"/> |
| | | </dependency> |
| | | <dependency org="org.forgerock.opendj" name="opendj-slf4j-adapter" rev="&opendj.sdk.version;"> |
| | | <exclude module="opendj3-server-dev"/> |
| | | </dependency> |
| | | <dependency org="org.forgerock.commons" name="i18n-slf4j" rev="&i18n.version;" /> |
| | | <dependency org="org.forgerock.opendj" name="opendj-server2x-adapter" rev="&opendj.sdk.version;"> |
| | | <!-- This is the OpenDJ server module :) --> |
| | | <exclude module="opendj-server"/> |
| | | <exclude module="slf4j-jdk14"/> |
| | | </dependency> |
| | | <dependency org="org.glassfish.grizzly" name="grizzly-http-servlet" rev="&grizzly.version;"> |
| | | <exclude module="javax.servlet-api" /> |
| | |
| | | if name.nil? then '' else name end |
| | | end |
| | | |
| | | # Process provided directories |
| | | # Expects a processing block accepting a file as argument and returning a count of changes dones |
| | | def process_dirs(dirs, stopwords, extensions) |
| | | count_files = 0 |
| | | count_total = 0 |
| | | dirs.each { |directory| |
| | | files = files_under_directory(directory, extensions) |
| | | files.each { |file| |
| | | #puts file.to_s |
| | | exclude_file = stopwords.any? { |stopword| file.include?(stopword) } |
| | | next if exclude_file |
| | | count = yield file # call the block |
| | | if count > 0 |
| | | count_files += 1 |
| | | count_total += count |
| | | end |
| | | } |
| | | } |
| | | puts "Replaced in #{count_files} files, for a total of #{count_total} replacements" |
| | | end |
| | | |
| | | # Process provided file |
| | | # Expects a processing block accepting a source string as argument and returning a count of changes + a new |
| | | # content |
| | | def process_file(file) |
| | | count = 0 |
| | | File.open(file) { |source| |
| | | contents = source.read |
| | | count, new_contents = yield contents |
| | | File.open(file + ".copy", "w+") { |f| f.write(new_contents) } |
| | | } |
| | | FileUtils.mv(file + ".copy", file, :verbose => false) |
| | | count |
| | | end |
| | | |
| | | |
| | | # Return all files with provided extensions under the provided directory |
| | | # and all its subdirectories recursively |
| | | def files_under_directory(directory, extensions) |
| | | Dir[directory + '/**/*.{' + extensions.join(",") + '}'] |
| | | end |
| | | |
| | | def run_messages |
| | | prepare_messages |
| | | process_dirs(JAVA_DIRS, ["--nostopword--"], ['java']) { |file| |
| | | process_file(file) { |content| |
| | | count, new_content = process_message(content) |
| | | next count, new_content |
| | | } |
| | | } |
| | | end |
| | | |
| | | def process_message(content) |
| | | has_logger = /LocalizedLogger\.getLoggerForThisClass/ =~ content |
| | | needs_logger = /logError/ =~ content |
| | | count = 0 |
| | | if needs_logger && has_logger.nil? |
| | | count = 1 |
| | | |
| | | content.sub!(/class ([^{]+){/, |
| | | "class \\1{\n\n " + |
| | | "private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();\n") |
| | | |
| | | content.sub!(/import (.*);/, |
| | | "import \\1;\nimport org.forgerock.i18n.slf4j.LocalizedLogger;") |
| | | end |
| | | |
| | | if needs_logger |
| | | count = 1 |
| | | pattern = /(final )?(LocalizableMessage )?message\s*=\s*(\w+)\s*.\s*get\(\s*([^;]*)\);\s+(ErrorLogger\.)?logError\(\w+\);/m |
| | | mdata = pattern.match(content) |
| | | while !mdata.nil? do |
| | | msg = mdata[3] |
| | | args = if mdata[4].nil? || mdata[4]=="" then "" else ", " + mdata[4] end |
| | | level = MESSAGES_MAP[msg] |
| | | puts "1... #{level} - #{msg}" |
| | | content.sub!(pattern, "logger.#{level}(#{msg}#{args});") |
| | | mdata = pattern.match(content) |
| | | end |
| | | |
| | | pattern = /logError\((\w+).get\s*\(\s*/m |
| | | mdata = pattern.match(content) |
| | | stop = {} |
| | | while !mdata.nil? do |
| | | msg = mdata[1] |
| | | break if !stop[msg].nil? |
| | | stop[msg] = msg |
| | | level = MESSAGES_MAP[msg] |
| | | puts "2... #{level} - #{msg}" |
| | | if !level.nil? |
| | | content.sub!(pattern, "logger.#{level}(#{msg}.get(") |
| | | end |
| | | mdata = pattern.match(content) |
| | | end |
| | | |
| | | # all remaining patterns |
| | | content.gsub!(/(ErrorLogger\.)?logError\(/, 'logger.error(') |
| | | |
| | | end |
| | | return count, content |
| | | end |
| | | |
| | | def prepare_messages |
| | | files = Dir['src/messages/messages/*.properties'] |
| | | files.each do |file| messages(file) end |
| | | end |
| | | |
| | | # Build a map of error messages and error level |
| | | def messages(message_file) |
| | | File.open(message_file).each { |line| |
| | |
| | | first, *rest = token[0].split "_" |
| | | level_label = if %w(INFO DEBUG NOTICE).include?(first) then first else first.to_s + "_" + rest[0].to_s end |
| | | level = LOG_LEVELS[level_label] |
| | | label = first + rest.join("_") |
| | | label = label.gsub("MILD", "").gsub("SEVERE", "").gsub("FATAL", "") |
| | | puts "level #{level}, label #{label}" |
| | | label = first + "_" + rest.join("_") |
| | | label = label.gsub("MILD_", '').gsub("SEVERE_", '').gsub("FATAL_", '').gsub("NOTICE_", 'NOTE_').gsub(/_\d+$/, '') |
| | | MESSAGES_MAP[label] = level |
| | | #puts "#{label}=#{level} #{token}" |
| | | } |
| | | end |
| | | |
| | | end |
| | | |
| | | # Launch all replacements defined in the REPLACEMENTS constant |
| | | Replace.new.messages("src/messages/messages/admin.properties") |
| | | #Replace.new.messages("src/messages/messages/admin.properties") |
| | | Replace.new.run_messages |
| | | #Replace.new.run |
| | |
| | | */ |
| | | package org.opends.server.admin; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.messages.AdminMessages.*; |
| | | import java.io.File; |
| | | import java.io.FileWriter; |
| | |
| | | import org.opends.server.util.SetupUtils; |
| | | import org.opends.server.admin.std.server.TrustManagerProviderCfg; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.DirectoryException; |
| | | import org.opends.server.types.FilePermission; |
| | |
| | | } |
| | | LocalizableMessage message = ERR_ADMIN_CERTIFICATE_GENERATION_MISSING_FILES |
| | | .get(err); |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new InitializationException(message); |
| | | } |
| | | |
| | |
| | | new FilePermission(0600))) |
| | | { |
| | | // Log a warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_ADMIN_SET_PERMISSIONS_FAILED |
| | | .get(pinFilePath); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_ADMIN_SET_PERMISSIONS_FAILED, pinFilePath); |
| | | } |
| | | } |
| | | catch (DirectoryException e) |
| | | { |
| | | // Log a warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_ADMIN_SET_PERMISSIONS_FAILED.get(pinFilePath); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_ADMIN_SET_PERMISSIONS_FAILED, pinFilePath); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = ERR_ADMIN_CERTIFICATE_GENERATION.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new InitializationException(message); |
| | | } |
| | | } |
| | |
| | | import org.opends.server.admin.server.ServerManagementContext; |
| | | import org.opends.server.admin.std.meta.RootCfgDefn; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.ConfigChangeResult; |
| | | import org.opends.server.types.DN; |
| | |
| | | // The condition could not be evaluated. |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_REFINT_UNABLE_TO_EVALUATE_TARGET_CONDITION.get(mo |
| | | logger.error(ERR_REFINT_UNABLE_TO_EVALUATE_TARGET_CONDITION, mo |
| | | .getManagedObjectDefinition().getUserFriendlyName(), String |
| | | .valueOf(mo.getDN()), StaticUtils.getExceptionMessage(e)); |
| | | ErrorLogger.logError(message); |
| | | unacceptableReasons.add(message); |
| | | return false; |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.AdminMessages.*; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.util.ServerConstants.EOL; |
| | | |
| | |
| | | if (!extensionsPath.exists()) { |
| | | // The extensions directory does not exist. This is not a |
| | | // critical problem. |
| | | LocalizableMessage message = ERR_ADMIN_NO_EXTENSIONS_DIR.get( |
| | | String.valueOf(extensionsPath)); |
| | | logError(message); |
| | | logger.error(ERR_ADMIN_NO_EXTENSIONS_DIR, String.valueOf(extensionsPath)); |
| | | return; |
| | | } |
| | | |
| | |
| | | try { |
| | | // Log build information of extensions in the error log |
| | | String[] information = getBuildInformation(jarFile); |
| | | logError( |
| | | logger.error( |
| | | NOTE_LOG_EXTENSION_INFORMATION. |
| | | get(jarFile.getName(), |
| | | information[1], |
| | |
| | | import org.opends.server.config.ConfigEntry; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.ConfigChangeResult; |
| | | import org.opends.server.types.DN; |
| | |
| | | } else { |
| | | LocalizableMessage message = AdminMessages.ERR_ADMIN_MANAGED_OBJECT_DOES_NOT_EXIST |
| | | .get(String.valueOf(dn)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | } catch (ConfigException e) { |
| | | // The dependent entry could not be retrieved. |
| | |
| | | |
| | | LocalizableMessage message = AdminMessages.ERR_ADMIN_CANNOT_GET_MANAGED_OBJECT.get( |
| | | String.valueOf(dn), StaticUtils.getExceptionMessage(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | return null; |
| | |
| | | package org.opends.server.api; |
| | | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.Collection; |
| | | import java.util.Collections; |
| | | import java.util.List; |
| | |
| | | <T extends ConnectionHandlerCfg> |
| | | extends DirectoryThread |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** The monitor associated with this connection handler. */ |
| | | private ConnectionHandlerMonitor monitor; |
| | | |
| | |
| | | int cpus = Runtime.getRuntime().availableProcessors(); |
| | | int value = Math.max(2, cpus / 2); |
| | | |
| | | LocalizableMessage message = |
| | | INFO_ERGONOMIC_SIZING_OF_REQUEST_HANDLER_THREADS.get(friendlyName, |
| | | logger.debug(INFO_ERGONOMIC_SIZING_OF_REQUEST_HANDLER_THREADS, friendlyName, |
| | | value); |
| | | logError(message); |
| | | |
| | | return value; |
| | | } |
| | |
| | | } |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_UNCAUGHT_THREAD_EXCEPTION.get( |
| | | t.getName(), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_UNCAUGHT_THREAD_EXCEPTION.get(t.getName(), stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_UNCAUGHT_EXCEPTION, message); |
| | | } |
| | |
| | | package org.opends.server.api; |
| | | |
| | | import java.util.HashMap; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.HashSet; |
| | | import java.util.List; |
| | | import java.util.Map; |
| | |
| | | public abstract class ErrorLogPublisher<T extends ErrorLogPublisherCfg> |
| | | implements LogPublisher<T> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The hash map that will be used to define specific log severities |
| | | * for the various categories. |
| | |
| | | package org.opends.server.api; |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.admin.std.server.WorkQueueCfg; |
| | | import org.opends.server.config.ConfigException; |
| | |
| | | mayInvoke=true) |
| | | public abstract class WorkQueue<T extends WorkQueueCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Initializes this work queue based on the information in the |
| | | * provided configuration entry. |
| | |
| | | int cpus = Runtime.getRuntime().availableProcessors(); |
| | | int value = Math.max(24, cpus * 2); |
| | | |
| | | LocalizableMessage message = INFO_ERGONOMIC_SIZING_OF_WORKER_THREAD_POOL.get(value); |
| | | logError(message); |
| | | logger.debug(INFO_ERGONOMIC_SIZING_OF_WORKER_THREAD_POOL, value); |
| | | |
| | | return value; |
| | | } |
| | |
| | | import static org.opends.server.authorization.dseecompat.Aci.*; |
| | | import static org.opends.server.authorization.dseecompat.EnumEvalReason.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | catch (DirectoryException ex) |
| | | { |
| | | // Log a message and keep going. |
| | | LocalizableMessage message = WARN_ACI_NOT_VALID_DN.get(DNString); |
| | | logError(message); |
| | | logger.warn(WARN_ACI_NOT_VALID_DN, DNString); |
| | | } |
| | | } |
| | | |
| | |
| | | && !operation.getClientConnection().hasPrivilege( |
| | | Privilege.MODIFY_ACL, operation)) |
| | | { |
| | | LocalizableMessage message = |
| | | INFO_ACI_MODIFY_FAILED_PRIVILEGE.get(String.valueOf(container |
| | | logger.debug(INFO_ACI_MODIFY_FAILED_PRIVILEGE, String.valueOf(container |
| | | .getResourceDN()), String.valueOf(container.getClientDN())); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | // This access check handles the case where all attributes of this |
| | |
| | | final Lock entryLock = LockManager.lockRead(superiorDN); |
| | | if (entryLock == null) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_ACI_HANDLER_CANNOT_LOCK_NEW_SUPERIOR_USER.get(String |
| | | logger.warn(WARN_ACI_HANDLER_CANNOT_LOCK_NEW_SUPERIOR_USER, String |
| | | .valueOf(superiorDN)); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | |
| | |
| | | { |
| | | aciListenerMgr.logMsgsSetLockDownMode(failedACIMsgs); |
| | | } |
| | | LocalizableMessage message = |
| | | INFO_ACI_ADD_LIST_ACIS.get(Integer.toString(validAcis), |
| | | logger.debug(INFO_ACI_ADD_LIST_ACIS, Integer.toString(validAcis), |
| | | String.valueOf(baseDN)); |
| | | logError(message); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | if (globalAcis != null) |
| | | { |
| | | aciList.addAci(DN.rootDN(), globalAcis); |
| | | logError(INFO_ACI_ADD_LIST_GLOBAL_ACIS.get( |
| | | Integer.toString(globalAcis.size()))); |
| | | logger.debug(INFO_ACI_ADD_LIST_GLOBAL_ACIS.get(Integer.toString(globalAcis.size()))); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | if (!operation.getClientConnection().hasPrivilege( |
| | | Privilege.MODIFY_ACL, operation)) |
| | | { |
| | | LocalizableMessage message = INFO_ACI_ADD_FAILED_PRIVILEGE.get( |
| | | String.valueOf(entry.getName()), String.valueOf(clientDN)); |
| | | logError(message); |
| | | logger.debug(INFO_ACI_ADD_FAILED_PRIVILEGE, String.valueOf(entry.getName()), String.valueOf(clientDN)); |
| | | return false; |
| | | } |
| | | List<Attribute> attributeList = |
| | |
| | | package org.opends.server.authorization.dseecompat; |
| | | |
| | | import static org.opends.messages.AccessControlMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.authorization.dseecompat.AciHandler.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import java.util.*; |
| | | import java.util.concurrent.locks.ReentrantReadWriteLock; |
| | | |
| | |
| | | */ |
| | | public class AciList { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * A map containing all the ACIs. |
| | | * We use the copy-on-write technique to avoid locking when reading. |
| | |
| | | //This should never happen since only a copy of the |
| | | //ACI with a new DN is being made. Log a message if it does and |
| | | //keep going. |
| | | LocalizableMessage message = WARN_ACI_ADD_LIST_FAILED_DECODE.get( |
| | | aci.toString(), String.valueOf(relocateDN), ex.getMessage()); |
| | | logError(message); |
| | | logger.warn(WARN_ACI_ADD_LIST_FAILED_DECODE, aci.toString(), String.valueOf(relocateDN), ex.getMessage()); |
| | | } |
| | | } |
| | | tempAciList.put(relocateDN, acis); |
| | |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.internal.InternalSearchOperation; |
| | | import org.opends.server.protocols.ldap.LDAPControl; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.AccessControlMessages.*; |
| | |
| | | if (backend.getEntryCount() > 0 |
| | | && !backend.isIndexed(aciType, IndexType.PRESENCE)) |
| | | { |
| | | logError(WARN_ACI_ATTRIBUTE_NOT_INDEXED.get(backend |
| | | logger.warn(WARN_ACI_ATTRIBUTE_NOT_INDEXED.get(backend |
| | | .getBackendID(), "aci")); |
| | | } |
| | | |
| | |
| | | failedACIMsgs); |
| | | if (!failedACIMsgs.isEmpty()) |
| | | logMsgsSetLockDownMode(failedACIMsgs); |
| | | LocalizableMessage message = |
| | | INFO_ACI_ADD_LIST_ACIS.get(Integer.toString(validAcis), |
| | | logger.debug(INFO_ACI_ADD_LIST_ACIS, Integer.toString(validAcis), |
| | | String.valueOf(baseDN)); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | for (LocalizableMessage msg : failedACIMsgs) |
| | | { |
| | | LocalizableMessage message = WARN_ACI_SERVER_DECODE_FAILED.get(msg); |
| | | logError(message); |
| | | logger.warn(WARN_ACI_SERVER_DECODE_FAILED, msg); |
| | | } |
| | | if (!inLockDownMode) |
| | | setLockDownMode(); |
| | |
| | | */ |
| | | package org.opends.server.authorization.dseecompat; |
| | | import static org.opends.messages.AccessControlMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.core.DirectoryServer; |
| | | |
| | |
| | | */ |
| | | public class AuthMethod implements KeywordBindRule { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * Enumeration representing the authentication method. |
| | | */ |
| | |
| | | { |
| | | String saslMech = expr.substring(5); |
| | | if (DirectoryServer.getSASLMechanismHandler(saslMech) == null) { |
| | | logError(NOTE_ACI_SYNTAX_DUBIOUS_AUTHMETHOD_SASL_MECHANISM. |
| | | logger.error(NOTE_ACI_SYNTAX_DUBIOUS_AUTHMETHOD_SASL_MECHANISM. |
| | | get(saslMech)); |
| | | } |
| | | return new AuthMethod(EnumAuthMethod.AUTHMETHOD_SASL, saslMech, type); |
| | |
| | | |
| | | import static org.opends.messages.AccessControlMessages.*; |
| | | import static org.opends.server.authorization.dseecompat.Aci.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | import java.net.InetAddress; |
| | |
| | | { |
| | | dns.add(canonicalName); |
| | | |
| | | LocalizableMessage message = |
| | | WARN_ACI_LOCALHOST_DOESNT_MATCH_CANONICAL_VALUE. |
| | | get(expr, hn, canonicalName); |
| | | logError(message); |
| | | logger.warn(WARN_ACI_LOCALHOST_DOESNT_MATCH_CANONICAL_VALUE, expr, hn, canonicalName); |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_ACI_HOSTNAME_DOESNT_MATCH_CANONICAL_VALUE. |
| | | get(expr, hn, addr.getHostAddress(), |
| | | logger.warn(WARN_ACI_HOSTNAME_DOESNT_MATCH_CANONICAL_VALUE, expr, hn, addr.getHostAddress(), |
| | | addr.getCanonicalHostName()); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_ACI_ERROR_CHECKING_CANONICAL_HOSTNAME. |
| | | get(hn, expr, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_ACI_ERROR_CHECKING_CANONICAL_HOSTNAME, hn, expr, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.forgerock.util.Reject; |
| | | |
| | | import static org.opends.messages.BackendMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_DUPLICATE_ENTRY.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | logError(m); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | | } |
| | |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ENTRY_OUT_OF_SCOPE.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | logError(m); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | | } |
| | |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MISSING_PARENT.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | logError(m); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | | } |
| | |
| | | import static org.opends.messages.ConfigMessages. |
| | | ERR_CONFIG_BACKEND_ERROR_INTERACTING_WITH_BACKEND_ENTRY; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | Backend backend = DirectoryServer.getBackend(baseDN); |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = WARN_ROOTDSE_NO_BACKEND_FOR_SUBORDINATE_BASE.get( |
| | | String.valueOf(baseDN)); |
| | | logError(message); |
| | | logger.warn(WARN_ROOTDSE_NO_BACKEND_FOR_SUBORDINATE_BASE, String.valueOf(baseDN)); |
| | | } |
| | | else |
| | | { |
| | |
| | | |
| | | // This method should never be used to get anything other than the root DSE. |
| | | // If we got here, then that appears to be the case, so log a message. |
| | | LocalizableMessage message = |
| | | WARN_ROOTDSE_GET_ENTRY_NONROOT.get(String.valueOf(entryDN)); |
| | | logError(message); |
| | | logger.warn(WARN_ROOTDSE_GET_ENTRY_NONROOT, String.valueOf(entryDN)); |
| | | |
| | | |
| | | // Go ahead and check the subordinate backends to see if we can find the |
| | |
| | | import org.opends.server.core.ModifyDNOperation; |
| | | import org.opends.server.core.SchemaConfigManager; |
| | | import org.opends.server.core.SearchOperation; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.schema.AttributeTypeSyntax; |
| | | import org.opends.server.schema.DITContentRuleSyntax; |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_ERROR_DETERMINING_SCHEMA_CHANGES.get( |
| | | getExceptionMessage(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_SCHEMA_ERROR_DETERMINING_SCHEMA_CHANGES, getExceptionMessage(e)); |
| | | } |
| | | |
| | | |
| | |
| | | // in the extraAttribute map. This in fact acts as a replace. |
| | | if (SchemaConfigManager.isSchemaAttribute(a)) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_INVALID_REPLACE_MODIFICATION.get( |
| | | a.getNameWithOptions()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_SCHEMA_INVALID_REPLACE_MODIFICATION, a.getNameWithOptions()); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_IMPORT_FAILED.get( |
| | | attrType.toString(), de.getMessage()); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_IMPORT_FAILED, attrType.toString(), de.getMessage()); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_IMPORT_FAILED.get( |
| | | attrType.toString(), e.getMessage()); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_IMPORT_FAILED, attrType.toString(), e.getMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_IMPORT_FAILED.get( |
| | | newObjectClass.toString(), de.getMessage()); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_IMPORT_FAILED, newObjectClass.toString(), de.getMessage()); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_IMPORT_FAILED.get( |
| | | newObjectClass.toString(), e.getMessage()); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_IMPORT_FAILED, newObjectClass.toString(), e.getMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | try |
| | | { |
| | | schemaBackupInstanceDir.renameTo(schemaInstanceDir); |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_RESTORE_RESTORED_OLD_SCHEMA.get( |
| | | schemaInstanceDirPath); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_RESTORE_RESTORED_OLD_SCHEMA, schemaInstanceDirPath); |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_CANNOT_RESTORE_OLD_SCHEMA.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_CANNOT_RESTORE_OLD_SCHEMA, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | } |
| | | |
| | |
| | | // Tell the user where the previous schema was archived. |
| | | if (schemaBackupInstanceDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_CANNOT_GET_ZIP_ENTRY.get( |
| | |
| | | // Tell the user where the previous schema was archived. |
| | | if (schemaBackupInstanceDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_CANNOT_CREATE_FILE.get( |
| | |
| | | // Tell the user where the previous schema was archived. |
| | | if (schemaBackupInstanceDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_CANNOT_PROCESS_ARCHIVE_FILE.get( |
| | |
| | | byte[] calculatedHash = digest.digest(); |
| | | if (Arrays.equals(calculatedHash, unsignedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_SCHEMA_RESTORE_UNSIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_RESTORE_UNSIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | | // Tell the user where the previous schema was archived. |
| | | if (schemaBackupInstanceDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = |
| | |
| | | byte[] calculatedSignature = mac.doFinal(); |
| | | if (Arrays.equals(calculatedSignature, signedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_SCHEMA_RESTORE_SIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_RESTORE_SIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | | // Tell the user where the previous schema was archived. |
| | | if (schemaBackupInstanceDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED.get( |
| | | schemaBackupInstanceDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_SCHEMA_RESTORE_OLD_SCHEMA_SAVED, schemaBackupInstanceDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_RESTORE_SIGNED_HASH_INVALID.get(backupID); |
| | |
| | | // If we are just verifying the archive, then we're done. |
| | | if (verifyOnly) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_SCHEMA_RESTORE_VERIFY_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_RESTORE_VERIFY_SUCCESSFUL, backupID, backupPath); |
| | | return; |
| | | } |
| | | |
| | |
| | | recursiveDelete(schemaBackupInstanceDir); |
| | | } |
| | | |
| | | LocalizableMessage message = NOTE_SCHEMA_RESTORE_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_SCHEMA_RESTORE_SUCCESSFUL, backupID, backupPath); |
| | | } |
| | | |
| | | |
| | |
| | | import org.opends.server.core.ModifyDNOperation; |
| | | import org.opends.server.core.ModifyOperation; |
| | | import org.opends.server.core.SearchOperation; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | new FilePermission(0600))) |
| | | { |
| | | // Log a warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_TRUSTSTORE_SET_PERMISSIONS_FAILED.get(path); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_TRUSTSTORE_SET_PERMISSIONS_FAILED, path); |
| | | } |
| | | } catch(DirectoryException e) { |
| | | // Log a warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_TRUSTSTORE_SET_PERMISSIONS_FAILED.get(path); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_TRUSTSTORE_SET_PERMISSIONS_FAILED, path); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.opends.server.config.ConfigException; |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.toLowerCase; |
| | | |
| | | import org.opends.server.core.DirectoryServer; |
| | |
| | | toLowerCase(ruleName)); |
| | | if(rule == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_INDEX_TYPE_NEEDS_VALID_MATCHING_RULE.get( |
| | | String.valueOf(attrType),ruleName); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_INDEX_TYPE_NEEDS_VALID_MATCHING_RULE, String.valueOf(attrType),ruleName); |
| | | continue; |
| | | } |
| | | Map<String,Index> indexMap = new HashMap<String,Index>(); |
| | |
| | | toLowerCase(ruleName)); |
| | | if(rule == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_INDEX_TYPE_NEEDS_VALID_MATCHING_RULE.get( |
| | | String.valueOf(attrType),ruleName); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_INDEX_TYPE_NEEDS_VALID_MATCHING_RULE, String.valueOf(attrType),ruleName); |
| | | continue; |
| | | } |
| | | validRules.add(rule); |
| | |
| | | try |
| | | { |
| | | // Log an informational message about the number of entries. |
| | | LocalizableMessage message = NOTE_JEB_BACKEND_STARTED.get( |
| | | cfg.getBackendId(), rootContainer.getEntryCount()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKEND_STARTED, cfg.getBackendId(), rootContainer.getEntryCount()); |
| | | } |
| | | catch(DatabaseException databaseException) |
| | | { |
| | |
| | | catch (DatabaseException e) |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = ERR_JEB_DATABASE_EXCEPTION.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_JEB_DATABASE_EXCEPTION, e.getMessage()); |
| | | } |
| | | |
| | | // Checksum this db environment and register its offline state id/checksum. |
| | |
| | | threadWriteCount.set(0); |
| | | |
| | | // Log an informational message. |
| | | LocalizableMessage message = NOTE_BACKEND_OFFLINE.get(cfg.getBackendId()); |
| | | logError(message); |
| | | logger.info(NOTE_BACKEND_OFFLINE, cfg.getBackendId()); |
| | | } |
| | | |
| | | /** {@inheritDoc} */ |
| | |
| | | long closeTime = (finishTime - startTime) / 1000; |
| | | LocalizableMessage msg = |
| | | NOTE_JEB_IMPORT_LDIF_ROOTCONTAINER_CLOSE.get(closeTime); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | rootContainer = null; |
| | | } |
| | | |
| | |
| | | DirectoryException createDirectoryException(DatabaseException e) { |
| | | if (e instanceof EnvironmentFailureException && !rootContainer.isValid()) { |
| | | LocalizableMessage message = NOTE_BACKEND_ENVIRONMENT_UNUSABLE.get(getBackendID()); |
| | | logError(message); |
| | | logger.info(message); |
| | | DirectoryServer.sendAlertNotification(DirectoryServer.getInstance(), |
| | | ALERT_TYPE_BACKEND_ENVIRONMENT_UNUSABLE, message); |
| | | } |
| | |
| | | LocalizableMessage msg = NOTE_JEB_DISK_SPACE_RESTORED.get(monitor.getFreeSpace(), |
| | | monitor.getDirectory().getPath(), cfg.getBackendId(), |
| | | Math.max(monitor.getLowThreshold(), monitor.getFullThreshold())); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | |
| | | private void checkDiskSpace(Operation operation) throws DirectoryException |
| | |
| | | import java.util.zip.ZipOutputStream; |
| | | |
| | | import org.opends.server.types.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | |
| | | // No incremental backup ID: log a message informing that a backup |
| | | // could not be found and that a normal backup will be done. |
| | | incremental = false; |
| | | LocalizableMessage message = WARN_BACKUPDB_INCREMENTAL_NOT_FOUND_DOING_NORMAL.get( |
| | | backupDir.getPath()); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_INCREMENTAL_NOT_FOUND_DOING_NORMAL, backupDir.getPath()); |
| | | } |
| | | else |
| | | { |
| | |
| | | break; |
| | | } |
| | | |
| | | message = NOTE_JEB_BACKUP_FILE_UNCHANGED.get(logFileName); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKUP_FILE_UNCHANGED, logFileName); |
| | | |
| | | unchangedList.add(logFileName); |
| | | |
| | |
| | | |
| | | Arrays.sort(logFiles); |
| | | |
| | | message = NOTE_JEB_BACKUP_CLEANER_ACTIVITY.get( |
| | | String.valueOf(logFiles.length)); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKUP_CLEANER_ACTIVITY, String.valueOf(logFiles.length)); |
| | | } |
| | | else |
| | | { |
| | |
| | | { |
| | | if (verifyOnly) |
| | | { |
| | | LocalizableMessage message = NOTE_JEB_BACKUP_VERIFY_FILE.get(zipEntry.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKUP_VERIFY_FILE, zipEntry.getName()); |
| | | } |
| | | |
| | | // The file name is part of the hash. |
| | |
| | | { |
| | | outputStream.close(); |
| | | |
| | | LocalizableMessage message = NOTE_JEB_BACKUP_RESTORED_FILE.get( |
| | | zipEntry.getName(), totalBytesRead); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKUP_RESTORED_FILE, zipEntry.getName(), totalBytesRead); |
| | | } |
| | | } |
| | | |
| | |
| | | // Finish the zip entry. |
| | | zipStream.closeEntry(); |
| | | |
| | | LocalizableMessage message = NOTE_JEB_BACKUP_ARCHIVED_FILE.get(zipEntry.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_BACKUP_ARCHIVED_FILE, zipEntry.getName()); |
| | | |
| | | return totalBytesRead; |
| | | } |
| | |
| | | import static org.opends.messages.BackendMessages.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * This class maps JE properties to configuration attributes. |
| | |
| | | int cpus = Runtime.getRuntime().availableProcessors(); |
| | | value = Integer.valueOf(Math.max(24, cpus * 2)); |
| | | |
| | | LocalizableMessage message = |
| | | INFO_ERGONOMIC_SIZING_OF_JE_CLEANER_THREADS.get(String |
| | | logger.debug(INFO_ERGONOMIC_SIZING_OF_JE_CLEANER_THREADS, String |
| | | .valueOf(cfg.dn().rdn().getAttributeValue(0)), |
| | | (Number) value); |
| | | logError(message); |
| | | } |
| | | else if (attrName.equals(ATTR_NUM_LOCK_TABLES) |
| | | && value == null) |
| | |
| | | BigInteger tmp = BigInteger.valueOf((cleaners + workers) * 2); |
| | | value = tmp.nextProbablePrime(); |
| | | |
| | | LocalizableMessage message = |
| | | INFO_ERGONOMIC_SIZING_OF_JE_LOCK_TABLES.get(String |
| | | logger.debug(INFO_ERGONOMIC_SIZING_OF_JE_LOCK_TABLES, String |
| | | .valueOf(cfg.dn().rdn().getAttributeValue(0)), |
| | | (Number) value); |
| | | logError(message); |
| | | } |
| | | |
| | | return String.valueOf(value); |
| | |
| | | import com.sleepycat.je.LockMode; |
| | | import com.sleepycat.je.OperationStatus; |
| | | import java.util.Collection; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | import java.util.Collections; |
| | | import java.util.Iterator; |
| | | import java.util.LinkedList; |
| | |
| | | import org.opends.server.types.Entry; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | |
| | | /** |
| | |
| | | */ |
| | | protected void preload() |
| | | { |
| | | logError(NOTE_CACHE_PRELOAD_PROGRESS_START.get(jeb.getBackendID())); |
| | | logger.info(NOTE_CACHE_PRELOAD_PROGRESS_START.get(jeb.getBackendID())); |
| | | // Start collector thread first. |
| | | collector.start(); |
| | | // Kick off a single worker. |
| | |
| | | if (processedEntries.get() > 0) { |
| | | long freeMemory = |
| | | Runtime.getRuntime().freeMemory() / bytesPerMegabyte; |
| | | LocalizableMessage message = NOTE_CACHE_PRELOAD_PROGRESS_REPORT.get( |
| | | jeb.getBackendID(), processedEntries.get(), freeMemory); |
| | | logError(message); |
| | | logger.info(NOTE_CACHE_PRELOAD_PROGRESS_REPORT, jeb.getBackendID(), processedEntries.get(), freeMemory); |
| | | } |
| | | } |
| | | }; |
| | |
| | | } |
| | | // Cancel progress report task and report done. |
| | | timer.cancel(); |
| | | LocalizableMessage message = NOTE_CACHE_PRELOAD_PROGRESS_DONE.get( |
| | | jeb.getBackendID(), processedEntries.get()); |
| | | logError(message); |
| | | logger.info(NOTE_CACHE_PRELOAD_PROGRESS_DONE, jeb.getBackendID(), processedEntries.get()); |
| | | } catch (InterruptedException ex) { |
| | | logger.traceException(ex); |
| | | // Interrupt the collector. |
| | |
| | | for (Thread thread : preloadThreads) { |
| | | thread.interrupt(); |
| | | } |
| | | logError(WARN_CACHE_PRELOAD_INTERRUPTED.get( |
| | | jeb.getBackendID())); |
| | | logger.warn(WARN_CACHE_PRELOAD_INTERRUPTED.get(jeb.getBackendID())); |
| | | } finally { |
| | | // Kill the timer task. |
| | | timer.cancel(); |
| | |
| | | processedEntries.getAndIncrement(); |
| | | } catch (Exception ex) { |
| | | logger.traceException(ex); |
| | | LocalizableMessage message = ERR_CACHE_PRELOAD_ENTRY_FAILED.get( |
| | | entry.getName().toNormalizedString(), |
| | | logger.error(ERR_CACHE_PRELOAD_ENTRY_FAILED, entry.getName().toNormalizedString(), |
| | | (ex.getCause() != null ? ex.getCause().getMessage() : |
| | | stackTraceToSingleLineString(ex))); |
| | | logError(message); |
| | | } |
| | | } catch (Exception ex) { |
| | | break; |
| | |
| | | package org.opends.server.backends.jeb; |
| | | |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | import com.sleepycat.je.*; |
| | |
| | | } |
| | | id2subtree.open(); // No-op |
| | | |
| | | logError(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED.get(backend |
| | | logger.info(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED.get(backend |
| | | .getBackendID())); |
| | | } |
| | | |
| | |
| | | index.open(); |
| | | if(!index.isTrusted()) |
| | | { |
| | | logError(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get( |
| | | index.getName())); |
| | | logger.info(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(index.getName())); |
| | | } |
| | | attrIndexMap.put(indexCfg.getAttribute(), index); |
| | | } |
| | |
| | | |
| | | if(!vlvIndex.isTrusted()) |
| | | { |
| | | logError(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get( |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get( |
| | | vlvIndex.getName())); |
| | | } |
| | | |
| | |
| | | state.putIndexTrustState(null, id2subtree, false); |
| | | id2subtree.open(); // No-op |
| | | |
| | | logError(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED |
| | | logger.error(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED |
| | | .get(cfg.getBackendId())); |
| | | } |
| | | } |
| | |
| | | id2children.open(); |
| | | if (!id2children.isTrusted()) |
| | | { |
| | | logError(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2children |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2children |
| | | .getName())); |
| | | } |
| | | id2subtree = new Index(databasePrefix + "_" + ID2SUBTREE_DATABASE_NAME, |
| | |
| | | id2subtree.open(); |
| | | if (!id2subtree.isTrusted()) |
| | | { |
| | | logError(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2subtree.getName())); |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2subtree.getName())); |
| | | } |
| | | } |
| | | |
| | |
| | | * Portions Copyright 2012-2014 ForgeRock AS. |
| | | */ |
| | | package org.opends.server.backends.jeb; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | import com.sleepycat.je.Cursor; |
| | | import com.sleepycat.je.CursorConfig; |
| | | import com.sleepycat.je.DatabaseEntry; |
| | |
| | | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.JebMessages.*; |
| | | |
| | |
| | | rate = 1000f*exportedCount / totalTime; |
| | | } |
| | | |
| | | LocalizableMessage message = NOTE_JEB_EXPORT_FINAL_STATUS.get( |
| | | exportedCount, skippedCount, totalTime/1000, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_EXPORT_FINAL_STATUS, exportedCount, skippedCount, totalTime/1000, rate); |
| | | |
| | | } |
| | | |
| | |
| | | |
| | | float rate = 1000f*deltaCount / deltaTime; |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_EXPORT_PROGRESS_REPORT.get(latestCount, skippedCount, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_EXPORT_PROGRESS_REPORT, latestCount, skippedCount, rate); |
| | | |
| | | previousCount = latestCount; |
| | | previousTime = latestTime; |
| | |
| | | package org.opends.server.backends.jeb; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import com.sleepycat.je.*; |
| | | |
| | | import org.opends.server.types.*; |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logError(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | } |
| | | |
| | | if((rebuildRunning || trusted) && addedIDs != null && |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logError(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | } |
| | | |
| | | if((rebuildRunning || trusted) && addedIDs != null && addedIDs.size() > 0) |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logError(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logError(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logError(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.config.ConfigException; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.InitializationException; |
| | | import static org.opends.messages.JebMessages.*; |
| | |
| | | { |
| | | if(!FilePermission.setPermissions(backendDirectory, backendPermission)) |
| | | { |
| | | LocalizableMessage message = WARN_JEB_UNABLE_SET_PERMISSIONS.get( |
| | | backendPermission.toString(), backendDirectory.toString()); |
| | | logError(message); |
| | | logger.warn(WARN_JEB_UNABLE_SET_PERMISSIONS, backendPermission.toString(), backendDirectory.toString()); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | // Log an warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_JEB_SET_PERMISSIONS_FAILED.get( |
| | | backendDirectory.toString(), e.toString()); |
| | | logError(message); |
| | | logger.warn(WARN_JEB_SET_PERMISSIONS_FAILED, backendDirectory.toString(), e.toString()); |
| | | } |
| | | } |
| | | |
| | |
| | | PreloadConfig preloadConfig = new PreloadConfig(); |
| | | preloadConfig.setLoadLNs(true); |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_CACHE_PRELOAD_STARTED.get(backend.getBackendID()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_PRELOAD_STARTED, backend.getBackendID()); |
| | | |
| | | boolean isInterrupted = false; |
| | | |
| | |
| | | if (preloadStatus != PreloadStatus.SUCCESS) |
| | | { |
| | | if (preloadStatus == PreloadStatus.EXCEEDED_TIME) { |
| | | message = |
| | | NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_BY_TIME.get( |
| | | backend.getBackendID(), db.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_BY_TIME, backend.getBackendID(), db.getName()); |
| | | } else if (preloadStatus == PreloadStatus.FILLED_CACHE) { |
| | | message = |
| | | NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_BY_SIZE.get( |
| | | backend.getBackendID(), db.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_BY_SIZE, backend.getBackendID(), db.getName()); |
| | | } else { |
| | | message = |
| | | NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_UNKNOWN.get( |
| | | backend.getBackendID(), db.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_PRELOAD_INTERRUPTED_UNKNOWN, backend.getBackendID(), db.getName()); |
| | | } |
| | | |
| | | isInterrupted = true; |
| | | break; |
| | | } |
| | | |
| | | message = NOTE_JEB_CACHE_DB_PRELOADED.get(db.getName()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_DB_PRELOADED, db.getName()); |
| | | } |
| | | |
| | | if (!isInterrupted) { |
| | | message = NOTE_JEB_CACHE_PRELOAD_DONE.get(backend.getBackendID()); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_PRELOAD_DONE, backend.getBackendID()); |
| | | } |
| | | |
| | | // Log an informational message about the size of the cache. |
| | | EnvironmentStats stats = env.getStats(new StatsConfig()); |
| | | long total = stats.getCacheTotalBytes(); |
| | | |
| | | message = |
| | | NOTE_JEB_CACHE_SIZE_AFTER_PRELOAD.get(total / (1024 * 1024)); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_CACHE_SIZE_AFTER_PRELOAD, total / (1024 * 1024)); |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_JEB_CACHE_PRELOAD.get(backend.getBackendID(), |
| | | logger.error(ERR_JEB_CACHE_PRELOAD, backend.getBackendID(), |
| | | (e.getCause() != null ? e.getCause().getMessage() : |
| | | stackTraceToSingleLineString(e))); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | if(!FilePermission.setPermissions(backendDirectory, |
| | | backendPermission)) |
| | | { |
| | | LocalizableMessage message = WARN_JEB_UNABLE_SET_PERMISSIONS.get( |
| | | backendPermission.toString(), backendDirectory.toString()); |
| | | logError(message); |
| | | logger.warn(WARN_JEB_UNABLE_SET_PERMISSIONS, backendPermission.toString(), backendDirectory.toString()); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | // Log an warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_JEB_SET_PERMISSIONS_FAILED.get( |
| | | backendDirectory.toString(), e.toString()); |
| | | logError(message); |
| | | logger.warn(WARN_JEB_SET_PERMISSIONS_FAILED, backendDirectory.toString(), e.toString()); |
| | | } |
| | | } |
| | | } |
| | |
| | | import com.sleepycat.je.*; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | |
| | | String.valueOf(keyCount)); |
| | | if (cleanMode) |
| | | { |
| | | LocalizableMessage message = NOTE_JEB_VERIFY_CLEAN_FINAL_STATUS.get( |
| | | keyCount, errorCount, totalTime/1000, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_VERIFY_CLEAN_FINAL_STATUS, keyCount, errorCount, totalTime/1000, rate); |
| | | |
| | | if (multiReferenceCount > 0) |
| | | { |
| | |
| | | averageEntryReferences = (float)entryReferencesCount/keyCount; |
| | | } |
| | | |
| | | message = |
| | | INFO_JEB_VERIFY_MULTIPLE_REFERENCE_COUNT.get(multiReferenceCount); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_MULTIPLE_REFERENCE_COUNT, multiReferenceCount); |
| | | addStatEntry(statEntry, "verify-multiple-reference-count", |
| | | String.valueOf(multiReferenceCount)); |
| | | |
| | | message = INFO_JEB_VERIFY_ENTRY_LIMIT_EXCEEDED_COUNT.get( |
| | | entryLimitExceededCount); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_ENTRY_LIMIT_EXCEEDED_COUNT, entryLimitExceededCount); |
| | | addStatEntry(statEntry, "verify-entry-limit-exceeded-count", |
| | | String.valueOf(entryLimitExceededCount)); |
| | | |
| | | message = INFO_JEB_VERIFY_AVERAGE_REFERENCE_COUNT.get( |
| | | averageEntryReferences); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_AVERAGE_REFERENCE_COUNT, averageEntryReferences); |
| | | addStatEntry(statEntry, "verify-average-reference-count", |
| | | String.valueOf(averageEntryReferences)); |
| | | |
| | | message = |
| | | INFO_JEB_VERIFY_MAX_REFERENCE_COUNT.get(maxEntryPerValue); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_MAX_REFERENCE_COUNT, maxEntryPerValue); |
| | | addStatEntry(statEntry, "verify-max-reference-count", |
| | | String.valueOf(maxEntryPerValue)); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = NOTE_JEB_VERIFY_FINAL_STATUS.get( |
| | | keyCount, errorCount, totalTime/1000, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_VERIFY_FINAL_STATUS, keyCount, errorCount, totalTime/1000, rate); |
| | | //TODO add entry-limit-stats to the statEntry |
| | | if (entryLimitMap.size() > 0) |
| | | { |
| | | message = INFO_JEB_VERIFY_ENTRY_LIMIT_STATS_HEADER.get(); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_ENTRY_LIMIT_STATS_HEADER); |
| | | |
| | | for (Map.Entry<Index,HashMap<ByteString,Long>> mapEntry : |
| | | entryLimitMap.entrySet()) |
| | |
| | | medianValue = values[x]; |
| | | } |
| | | |
| | | message = INFO_JEB_VERIFY_ENTRY_LIMIT_STATS_ROW. |
| | | get(index.toString(), values.length, values[0], |
| | | logger.debug(INFO_JEB_VERIFY_ENTRY_LIMIT_STATS_ROW, index.toString(), values.length, values[0], |
| | | values[values.length-1], medianValue); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | float rate = 1000f*deltaCount / deltaTime; |
| | | |
| | | LocalizableMessage message = NOTE_JEB_VERIFY_PROGRESS_REPORT.get( |
| | | latestCount, totalCount, errorCount, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_VERIFY_PROGRESS_REPORT, latestCount, totalCount, errorCount, rate); |
| | | |
| | | try |
| | | { |
| | |
| | | cacheMissRate = nCacheMiss/(float)deltaCount; |
| | | } |
| | | |
| | | message = INFO_JEB_VERIFY_CACHE_AND_MEMORY_REPORT.get( |
| | | freeMemory, cacheMissRate); |
| | | logError(message); |
| | | logger.debug(INFO_JEB_VERIFY_CACHE_AND_MEMORY_REPORT, freeMemory, cacheMissRate); |
| | | |
| | | prevEnvStats = envStats; |
| | | } |
| | |
| | | import static com.sleepycat.je.EnvironmentConfig.*; |
| | | |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.DynamicConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | |
| | | if (oldThreadCount != threadCount) |
| | | { |
| | | logError( |
| | | logger.error( |
| | | NOTE_JEB_IMPORT_ADJUST_THREAD_COUNT.get(oldThreadCount, threadCount)); |
| | | } |
| | | |
| | | logError(NOTE_JEB_IMPORT_LDIF_TOT_MEM_BUF.get( |
| | | availableMemory, phaseOneBufferCount)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TOT_MEM_BUF.get(availableMemory, phaseOneBufferCount)); |
| | | if (tmpEnvCacheSize > 0) |
| | | { |
| | | logError(NOTE_JEB_IMPORT_LDIF_TMP_ENV_MEM.get(tmpEnvCacheSize)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TMP_ENV_MEM.get(tmpEnvCacheSize)); |
| | | } |
| | | envConfig.setConfigParam(MAX_MEMORY, Long.toString(dbCacheSize)); |
| | | logError(NOTE_JEB_IMPORT_LDIF_DB_MEM_BUF_INFO.get(dbCacheSize, bufferSize)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_DB_MEM_BUF_INFO.get(dbCacheSize, bufferSize)); |
| | | } |
| | | |
| | | /** |
| | |
| | | dbMonitor.initializeMonitorProvider(null); |
| | | DirectoryServer.registerMonitorProvider(dbMonitor); |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_STARTING.get(DirectoryServer.getVersionString(), |
| | | logger.info(NOTE_JEB_IMPORT_STARTING, DirectoryServer.getVersionString(), |
| | | BUILD_ID, REVISION_NUMBER); |
| | | logError(message); |
| | | message = NOTE_JEB_IMPORT_THREAD_COUNT.get(threadCount); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_IMPORT_THREAD_COUNT, threadCount); |
| | | initializeSuffixes(); |
| | | setIndexesTrusted(false); |
| | | long startTime = System.currentTimeMillis(); |
| | |
| | | long finishTime = System.currentTimeMillis(); |
| | | long importTime = (finishTime - startTime); |
| | | float rate = 0; |
| | | message = |
| | | NOTE_JEB_IMPORT_PHASE_STATS.get(importTime / 1000, |
| | | logger.info(NOTE_JEB_IMPORT_PHASE_STATS, importTime / 1000, |
| | | (phaseOneFinishTime - startTime) / 1000, |
| | | (phaseTwoFinishTime - phaseTwoTime) / 1000); |
| | | logError(message); |
| | | if (importTime > 0) |
| | | rate = 1000f * reader.getEntriesRead() / importTime; |
| | | message = |
| | | NOTE_JEB_IMPORT_FINAL_STATUS.get(reader.getEntriesRead(), importCount |
| | | logger.info(NOTE_JEB_IMPORT_FINAL_STATUS, reader.getEntriesRead(), importCount |
| | | .get(), reader.getEntriesIgnored(), reader.getEntriesRejected(), |
| | | migratedCount, importTime / 1000, rate); |
| | | logError(message); |
| | | return new LDIFImportResult(reader.getEntriesRead(), reader |
| | | .getEntriesRejected(), reader.getEntriesIgnored()); |
| | | } |
| | |
| | | readAheadSize = MIN_READ_AHEAD_CACHE_SIZE; |
| | | buffers = (int) (usableMemory / readAheadSize); |
| | | |
| | | LocalizableMessage message = WARN_IMPORT_LDIF_LACK_MEM_PHASE_TWO.get(usableMemory); |
| | | logError(message); |
| | | logger.warn(WARN_IMPORT_LDIF_LACK_MEM_PHASE_TWO, usableMemory); |
| | | break; |
| | | } |
| | | } |
| | |
| | | // processing of smaller indexes. |
| | | dbThreads = Math.max(2, dbThreads); |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_LDIF_PHASE_TWO_MEM_REPORT.get(availableMemory, |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_PHASE_TWO_MEM_REPORT, availableMemory, |
| | | readAheadSize, buffers); |
| | | logError(message); |
| | | |
| | | // Start indexing tasks. |
| | | List<Future<Void>> futures = new LinkedList<Future<Void>>(); |
| | |
| | | DatabaseEntry data = new DatabaseEntry(); |
| | | LockMode lockMode = LockMode.DEFAULT; |
| | | OperationStatus status; |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_MIGRATION_START.get("excluded", String |
| | | logger.info(NOTE_JEB_IMPORT_MIGRATION_START, "excluded", String |
| | | .valueOf(suffix.getBaseDN())); |
| | | logError(message); |
| | | Cursor cursor = |
| | | entryContainer.getDN2ID().openCursor(null, |
| | | CursorConfig.READ_COMMITTED); |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = |
| | | ERR_JEB_IMPORT_LDIF_MIGRATE_EXCLUDED_TASK_ERR.get(e |
| | | logger.error(ERR_JEB_IMPORT_LDIF_MIGRATE_EXCLUDED_TASK_ERR, e |
| | | .getMessage()); |
| | | logError(message); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | DatabaseEntry data = new DatabaseEntry(); |
| | | LockMode lockMode = LockMode.DEFAULT; |
| | | OperationStatus status; |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_MIGRATION_START.get("existing", String |
| | | logger.info(NOTE_JEB_IMPORT_MIGRATION_START, "existing", String |
| | | .valueOf(suffix.getBaseDN())); |
| | | logError(message); |
| | | Cursor cursor = entryContainer.getDN2ID().openCursor(null, null); |
| | | try |
| | | { |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = |
| | | ERR_JEB_IMPORT_LDIF_MIGRATE_EXISTING_TASK_ERR.get(e |
| | | logger.error(ERR_JEB_IMPORT_LDIF_MIGRATE_EXISTING_TASK_ERR, e |
| | | .getMessage()); |
| | | logError(message); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_JEB_IMPORT_LDIF_APPEND_REPLACE_TASK_ERR.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_JEB_IMPORT_LDIF_APPEND_REPLACE_TASK_ERR, e.getMessage()); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_JEB_IMPORT_LDIF_IMPORT_TASK_ERR.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_JEB_IMPORT_LDIF_IMPORT_TASK_ERR, e.getMessage()); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | nextBufferID = 0; |
| | | ownedPermits = 0; |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_LDIF_INDEX_STARTED.get(indexMgr.getBufferFileName(), |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_INDEX_STARTED, indexMgr.getBufferFileName(), |
| | | remainingBuffers, totalBatches); |
| | | logError(message); |
| | | |
| | | indexMgr.setIndexDBWriteTask(this); |
| | | isRunning = true; |
| | |
| | | { |
| | | LocalizableMessage msg = |
| | | NOTE_JEB_IMPORT_LDIF_DN_CLOSE.get(indexMgr.getDNCount()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | if (!isCanceled) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_LDIF_INDEX_CLOSE.get(indexMgr |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_INDEX_CLOSE, indexMgr |
| | | .getBufferFileName()); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | final long kiloBytesRate = bytesReadInterval / deltaTime; |
| | | final long kiloBytesRemaining = (bufferFileSize - tmpBytesRead) / 1024; |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_IMPORT_LDIF_PHASE_TWO_REPORT.get(indexMgr |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_PHASE_TWO_REPORT, indexMgr |
| | | .getBufferFileName(), bytesReadPercent, kiloBytesRemaining, |
| | | kiloBytesRate, currentBatch, totalBatches); |
| | | logError(message); |
| | | |
| | | lastBytesRead = tmpBytesRead; |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_JEB_IMPORT_LDIF_INDEX_WRITE_DB_ERR.get(indexMgr |
| | | logger.error(ERR_JEB_IMPORT_LDIF_INDEX_WRITE_DB_ERR, indexMgr |
| | | .getBufferFileName(), e.getMessage()); |
| | | logError(message); |
| | | throw e; |
| | | } |
| | | finally |
| | |
| | | } |
| | | catch (IOException e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_JEB_IMPORT_LDIF_INDEX_FILEWRITER_ERR.get(indexMgr |
| | | logger.error(ERR_JEB_IMPORT_LDIF_INDEX_FILEWRITER_ERR, indexMgr |
| | | .getBufferFile().getAbsolutePath(), e.getMessage()); |
| | | logError(message); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | } |
| | | if ( message != null ) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (!rebuildConfig.isClearDegradedState()) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_JEB_REBUILD_FINAL_STATUS.get(entriesProcessed.get(), |
| | | logger.info(NOTE_JEB_REBUILD_FINAL_STATUS, entriesProcessed.get(), |
| | | totalTime / 1000, rate); |
| | | logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = ERR_JEB_IMPORT_LDIF_REBUILD_INDEX_TASK_ERR.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_JEB_IMPORT_LDIF_REBUILD_INDEX_TASK_ERR, stackTraceToSingleLineString(e)); |
| | | isCanceled = true; |
| | | throw e; |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_JEB_REBUILD_CLEARDEGRADEDSTATE_FINAL_STATUS.get(rebuildConfig |
| | | logger.info(NOTE_JEB_REBUILD_CLEARDEGRADEDSTATE_FINAL_STATUS, rebuildConfig |
| | | .getRebuildList().toString()); |
| | | logError(message); |
| | | } |
| | | |
| | | setRebuildListIndexesTrusted(true); |
| | |
| | | LocalizableMessage msg = |
| | | ERR_REBUILD_INDEX_LACK_DISK.get(monitor.getDirectory().getPath(), |
| | | monitor.getFreeSpace(), monitor.getLowThreshold()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | |
| | | @Override |
| | |
| | | { |
| | | completed = 100f * entriesProcessed / rebuildManager.getTotEntries(); |
| | | } |
| | | LocalizableMessage message = |
| | | NOTE_JEB_REBUILD_PROGRESS_REPORT.get(completed, entriesProcessed, |
| | | logger.info(NOTE_JEB_REBUILD_PROGRESS_REPORT, completed, entriesProcessed, |
| | | rebuildManager.getTotEntries(), rate); |
| | | logError(message); |
| | | try |
| | | { |
| | | Runtime runtime = Runtime.getRuntime(); |
| | |
| | | { |
| | | cacheMissRate = nCacheMiss / (float) deltaCount; |
| | | } |
| | | message = |
| | | NOTE_JEB_REBUILD_CACHE_AND_MEMORY_REPORT.get(freeMemory, |
| | | logger.info(NOTE_JEB_REBUILD_CACHE_AND_MEMORY_REPORT, freeMemory, |
| | | cacheMissRate); |
| | | logError(message); |
| | | prevEnvStats = envStats; |
| | | } |
| | | catch (DatabaseException e) |
| | |
| | | long entriesIgnored = reader.getEntriesIgnored(); |
| | | long entriesRejected = reader.getEntriesRejected(); |
| | | float rate = 1000f * deltaCount / deltaTime; |
| | | message = |
| | | NOTE_JEB_IMPORT_PROGRESS_REPORT.get(entriesRead, entriesIgnored, |
| | | logger.info(NOTE_JEB_IMPORT_PROGRESS_REPORT, entriesRead, entriesIgnored, |
| | | entriesRejected, 0, rate); |
| | | logError(message); |
| | | try |
| | | { |
| | | Runtime runTime = Runtime.getRuntime(); |
| | |
| | | { |
| | | cacheMissRate = nCacheMiss / (float) deltaCount; |
| | | } |
| | | message = |
| | | NOTE_JEB_IMPORT_CACHE_AND_MEMORY_REPORT.get(freeMemory, |
| | | logger.info(NOTE_JEB_IMPORT_CACHE_AND_MEMORY_REPORT, freeMemory, |
| | | cacheMissRate); |
| | | logError(message); |
| | | long evictPasses = environmentStats.getNEvictPasses(); |
| | | long evictNodes = environmentStats.getNNodesExplicitlyEvicted(); |
| | | long evictBinsStrip = environmentStats.getNBINsStripped(); |
| | |
| | | { |
| | | evicting = true; |
| | | evictionEntryCount = reader.getEntriesRead(); |
| | | message = |
| | | NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED.get(evictionEntryCount); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED, evictionEntryCount); |
| | | } |
| | | message = |
| | | NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED_STATS.get(evictPasses, |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED_STATS, evictPasses, |
| | | evictNodes, evictBinsStrip); |
| | | logError(message); |
| | | } |
| | | if (cleanerRuns != 0) |
| | | { |
| | | message = |
| | | NOTE_JEB_IMPORT_LDIF_CLEANER_STATS.get(cleanerRuns, |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_CLEANER_STATS, cleanerRuns, |
| | | cleanerDeletions, cleanerEntriesRead, cleanerINCleaned); |
| | | logError(message); |
| | | } |
| | | if (checkPoints > 1) |
| | | { |
| | | message = NOTE_JEB_IMPORT_LDIF_BUFFER_CHECKPOINTS.get(checkPoints); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_BUFFER_CHECKPOINTS, checkPoints); |
| | | } |
| | | previousStats = environmentStats; |
| | | } |
| | |
| | | { |
| | | cacheMissRate = nCacheMiss / (float) deltaCount; |
| | | } |
| | | message = |
| | | NOTE_JEB_IMPORT_CACHE_AND_MEMORY_REPORT.get(freeMemory, |
| | | logger.info(NOTE_JEB_IMPORT_CACHE_AND_MEMORY_REPORT, freeMemory, |
| | | cacheMissRate); |
| | | logError(message); |
| | | long evictPasses = environmentStats.getNEvictPasses(); |
| | | long evictNodes = environmentStats.getNNodesExplicitlyEvicted(); |
| | | long evictBinsStrip = environmentStats.getNBINsStripped(); |
| | |
| | | { |
| | | evicting = true; |
| | | } |
| | | message = |
| | | NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED_STATS.get(evictPasses, |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_EVICTION_DETECTED_STATS, evictPasses, |
| | | evictNodes, evictBinsStrip); |
| | | logError(message); |
| | | } |
| | | if (cleanerRuns != 0) |
| | | { |
| | | message = |
| | | NOTE_JEB_IMPORT_LDIF_CLEANER_STATS.get(cleanerRuns, |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_CLEANER_STATS, cleanerRuns, |
| | | cleanerDeletions, cleanerEntriesRead, cleanerINCleaned); |
| | | logError(message); |
| | | } |
| | | if (checkPoints > 1) |
| | | { |
| | | message = NOTE_JEB_IMPORT_LDIF_BUFFER_CHECKPOINTS.get(checkPoints); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_BUFFER_CHECKPOINTS, checkPoints); |
| | | } |
| | | previousStats = environmentStats; |
| | | } |
| | |
| | | ERR_IMPORT_LDIF_LACK_DISK_PHASE_TWO.get(monitor.getDirectory() |
| | | .getPath(), monitor.getFreeSpace(), monitor.getLowThreshold()); |
| | | } |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | |
| | | /** |
| | |
| | | |
| | | |
| | | import static org.opends.messages.JebMessages.ERR_JEB_IMPORT_BUFFER_IO_ERROR; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.io.IOException; |
| | | import java.nio.ByteBuffer; |
| | | import java.nio.channels.FileChannel; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.backends.jeb.importLDIF.Importer.IndexManager; |
| | | |
| | | import com.sleepycat.util.PackedInteger; |
| | |
| | | */ |
| | | public final class IndexInputBuffer implements Comparable<IndexInputBuffer> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private final IndexManager indexMgr; |
| | | private final FileChannel channel; |
| | | private final long begin; |
| | |
| | | } |
| | | catch (IOException ex) |
| | | { |
| | | LocalizableMessage message = ERR_JEB_IMPORT_BUFFER_IO_ERROR.get(indexMgr |
| | | logger.error(ERR_JEB_IMPORT_BUFFER_IO_ERROR, indexMgr |
| | | .getBufferFileName()); |
| | | logError(message); |
| | | throw new RuntimeException(ex); |
| | | } |
| | | } |
| | |
| | | package org.opends.server.backends.jeb.importLDIF; |
| | | |
| | | import java.util.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.concurrent.ConcurrentHashMap; |
| | | import java.util.concurrent.CountDownLatch; |
| | | import org.opends.server.backends.jeb.*; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.backends.jeb.importLDIF.Importer.*; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import com.sleepycat.je.DatabaseException; |
| | | import com.sleepycat.je.LockMode; |
| | | import static org.opends.messages.JebMessages.*; |
| | |
| | | */ |
| | | public class Suffix |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private final List<DN> includeBranches, excludeBranches; |
| | | private final DN baseDN; |
| | | private final EntryContainer srcEntryContainer; |
| | |
| | | try { |
| | | assureNotPending(dn); |
| | | } catch (InterruptedException e) { |
| | | LocalizableMessage message = ERR_JEB_IMPORT_LDIF_PENDING_ERR.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_JEB_IMPORT_LDIF_PENDING_ERR, e.getMessage()); |
| | | throw e; |
| | | } |
| | | //Check the DN cache. |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.messages.Severity; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.opends.server.util.EMailMessage; |
| | |
| | | { |
| | | // Simply pass this on to the server error logger, and it will call back |
| | | // to the addLogMessage method for this task. |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | /** |
| | |
| | | |
| | | taskState = TaskState.STOPPED_BY_ERROR; |
| | | |
| | | LocalizableMessage message = ERR_TASK_EXECUTE_FAILED.get( |
| | | String.valueOf(taskEntry.getName()), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_TASK_EXECUTE_FAILED, String.valueOf(taskEntry.getName()), stackTraceToSingleLineString(e)); |
| | | } |
| | | |
| | | return taskState; |
| | |
| | | |
| | | import static org.opends.messages.BackendMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | byte[] calculatedHash = digest.digest(); |
| | | if (Arrays.equals(calculatedHash, unsignedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_TASKS_RESTORE_UNSIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_TASKS_RESTORE_UNSIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | |
| | | byte[] calculatedSignature = mac.doFinal(); |
| | | if (Arrays.equals(calculatedSignature, signedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_TASKS_RESTORE_SIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_TASKS_RESTORE_SIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | |
| | | // If we are just verifying the archive, then we're done. |
| | | if (verifyOnly) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_TASKS_RESTORE_VERIFY_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_TASKS_RESTORE_VERIFY_SUCCESSFUL, backupID, backupPath); |
| | | return; |
| | | } |
| | | |
| | | // If we've gotten here, then the archive was restored successfully. |
| | | LocalizableMessage message = NOTE_TASKS_RESTORE_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_TASKS_RESTORE_SUCCESSFUL, backupID, backupPath); |
| | | } |
| | | |
| | | |
| | |
| | | try { |
| | | task = recurringTask.scheduleNextIteration(new GregorianCalendar()); |
| | | } catch (DirectoryException de) { |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | } |
| | | if (task != null) { |
| | | try { |
| | |
| | | // and thus got initialized from backing file, otherwise |
| | | // log error and continue. |
| | | if (de.getResultCode() != ResultCode.ENTRY_ALREADY_EXISTS) { |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | } |
| | | } |
| | | } |
| | |
| | | try { |
| | | newIteration = recurringTask.scheduleNextIteration(calendar); |
| | | } catch (DirectoryException de) { |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | } |
| | | if (newIteration != null) |
| | | { |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_ERROR_SCHEDULING_RECURRING_ITERATION. |
| | | get(recurringTaskID, de.getMessageObject()); |
| | | logError(message); |
| | | ERR_TASKSCHED_ERROR_SCHEDULING_RECURRING_ITERATION.get( |
| | | recurringTaskID, de.getMessageObject()); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_SCHEDULE_RECURRING_ITERATION, |
| | |
| | | |
| | | if (le.canContinueReading()) |
| | | { |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_PARSE_ENTRY_RECOVERABLE.get( |
| | | logger.error(ERR_TASKSCHED_CANNOT_PARSE_ENTRY_RECOVERABLE, |
| | | backingFilePath, le.getLineNumber(), le.getMessage()); |
| | | logError(message); |
| | | |
| | | continue; |
| | | } |
| | |
| | | DN parentDN = entryDN.getParentDNInSuffix(); |
| | | if (parentDN == null) |
| | | { |
| | | LocalizableMessage message = ERR_TASKSCHED_ENTRY_HAS_NO_PARENT. |
| | | get(String.valueOf(entryDN), |
| | | logger.error(ERR_TASKSCHED_ENTRY_HAS_NO_PARENT, String.valueOf(entryDN), |
| | | String.valueOf(taskBackend.getTaskRootDN())); |
| | | logError(message); |
| | | } |
| | | else if (parentDN.equals(taskBackend.getScheduledTasksParentDN())) |
| | | { |
| | |
| | | String id = task.getTaskID(); |
| | | if (tasks.containsKey(id)) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_TASKSCHED_DUPLICATE_TASK_ID.get( |
| | | String.valueOf(id)); |
| | | logError(message); |
| | | logger.warn(WARN_TASKSCHED_DUPLICATE_TASK_ID, String.valueOf(id)); |
| | | } |
| | | else |
| | | { |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_SCHEDULE_TASK_FROM_ENTRY. |
| | | get(String.valueOf(entryDN), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_TASKSCHED_CANNOT_SCHEDULE_TASK_FROM_ENTRY, |
| | | String.valueOf(entryDN), de.getMessageObject()); |
| | | } |
| | | } |
| | | else if (parentDN.equals(taskBackend.getRecurringTasksParentDN())) |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_CANNOT_SCHEDULE_RECURRING_TASK_FROM_ENTRY. |
| | | get(String.valueOf(entryDN), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error( |
| | | ERR_TASKSCHED_CANNOT_SCHEDULE_RECURRING_TASK_FROM_ENTRY, |
| | | String.valueOf(entryDN), de.getMessageObject()); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_TASKSCHED_INVALID_TASK_ENTRY_DN.get( |
| | | String.valueOf(entryDN), backingFilePath); |
| | | logError(message); |
| | | logger.error(ERR_TASKSCHED_INVALID_TASK_ENTRY_DN, String.valueOf(entryDN), backingFilePath); |
| | | } |
| | | } |
| | | } |
| | |
| | | catch (LDIFException le) |
| | | { |
| | | logger.traceException(le); |
| | | |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_CREATE_BACKING_FILE.get( |
| | | backingFile, le.getMessage()); |
| | | throw new InitializationException(message, le); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_TASKSCHED_CANNOT_RENAME_CURRENT_BACKING_FILE. |
| | | get(String.valueOf(backingFilePath), |
| | | String.valueOf(saveFile.getAbsolutePath()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | |
| | | LocalizableMessage message = |
| | | WARN_TASKSCHED_CANNOT_RENAME_CURRENT_BACKING_FILE.get(String |
| | | .valueOf(backingFilePath), String.valueOf(saveFile |
| | | .getAbsolutePath()), stackTraceToSingleLineString(e)); |
| | | logger.warn(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_RENAME_CURRENT_TASK_FILE, |
| | | message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_RENAME_NEW_BACKING_FILE. |
| | | get(String.valueOf(tmpFilePath), String.valueOf(backingFilePath), |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_CANNOT_RENAME_NEW_BACKING_FILE.get(String |
| | | .valueOf(tmpFilePath), String.valueOf(backingFilePath), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | |
| | | logger.error(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_RENAME_NEW_TASK_FILE, |
| | | message); |
| | |
| | | catch (IOException ioe) |
| | | { |
| | | logger.traceException(ioe); |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get( |
| | | tmpFilePath, stackTraceToSingleLineString(ioe)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get(tmpFilePath, |
| | | stackTraceToSingleLineString(ioe)); |
| | | logger.error(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_TASK_FILE, message); |
| | | } |
| | | catch (LDIFException le) |
| | | { |
| | | logger.traceException(le); |
| | | |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get( |
| | | tmpFilePath, le.getMessage()); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get(tmpFilePath, le |
| | | .getMessage()); |
| | | logger.error(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_TASK_FILE, message); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get( |
| | | tmpFilePath, stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_TASKSCHED_CANNOT_WRITE_BACKING_FILE.get(tmpFilePath, |
| | | stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_TASK_FILE, message); |
| | | } |
| | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import static org.opends.messages.BackendMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | { |
| | | Task task = getAssociatedTask(); |
| | | |
| | | LocalizableMessage message = NOTE_TASK_STARTED.get( |
| | | task.getDisplayName(), task.getTaskID()); |
| | | logError(message); |
| | | logger.info(NOTE_TASK_STARTED, task.getDisplayName(), task.getTaskID()); |
| | | |
| | | taskState = task.execute(); |
| | | |
| | | message = NOTE_TASK_FINISHED.get(task.getDisplayName(), |
| | | logger.info(NOTE_TASK_FINISHED, task.getDisplayName(), |
| | | task.getTaskID(), taskState.getDisplayName()); |
| | | logError(message); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | |
| | | Task task = getAssociatedTask(); |
| | | |
| | | LocalizableMessage message = ERR_TASK_EXECUTE_FAILED. |
| | | get(String.valueOf(task.getTaskEntry().getName()), |
| | | logger.error(ERR_TASK_EXECUTE_FAILED, String.valueOf(task.getTaskEntry().getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | task.setTaskState(TaskState.STOPPED_BY_ERROR); |
| | | } |
| | | |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | /** |
| | | * This class defines a DN configuration attribute, which can hold zero or more |
| | |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_DN_NULL.get(getName()); |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | /** |
| | | * This class defines an integer configuration attribute, which can hold zero or |
| | |
| | | |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | getName(), longValue, lowerBound); |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | /** |
| | | * This class defines a configuration attribute that stores both an integer |
| | |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_EMPTY_STRING_VALUE.get(getName()); |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_JMX_CANNOT_REGISTER_MBEAN.get( |
| | | configEntryDN.toString(), String.valueOf(e)); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_JMX_CANNOT_REGISTER_MBEAN, configEntryDN.toString(), String.valueOf(e)); |
| | | } |
| | | return nameStr ; |
| | | } |
| | |
| | | logger.traceException(e); |
| | | e.printStackTrace(); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_JMX_CANNOT_REGISTER_MBEAN.get( |
| | | configEntryDN.toString(), String.valueOf(e)); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_JMX_CANNOT_REGISTER_MBEAN, configEntryDN.toString(), String.valueOf(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_JMX_ATTR_NO_ATTR.get( |
| | | String.valueOf(configEntryDN), attributeName); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_CONFIG_JMX_ATTR_NO_ATTR.get(String.valueOf(configEntryDN), attributeName); |
| | | logger.error(message); |
| | | throw new AttributeNotFoundException(message.toString()); |
| | | } |
| | | } |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | /** |
| | | * This class defines a multi-choice configuration attribute, which can hold |
| | |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_EMPTY_STRING_VALUE.get(getName()); |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | valueString, getName()); |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | /** |
| | | * This class defines a string configuration attribute, which can hold zero or |
| | |
| | | |
| | | if (allowFailures) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | newHandler.initializeAccessControlHandler(null); |
| | | if(logMessage) { |
| | | LocalizableMessage message = WARN_CONFIG_AUTHZ_DISABLED.get(); |
| | | logError(message); |
| | | logger.warn(message); |
| | | if (currentConfiguration != null) { |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_ACCESS_CONTROL_DISABLED, message); |
| | |
| | | newHandler = loadHandler(handlerClassName, config, initHandler); |
| | | if(logMessage) { |
| | | LocalizableMessage message = NOTE_CONFIG_AUTHZ_ENABLED.get(handlerClassName); |
| | | logError(message); |
| | | logger.info(message); |
| | | if (currentConfiguration != null) { |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_ACCESS_CONTROL_ENABLED, message); |
| | |
| | | Class<? extends AccessControlHandler> providerClass = |
| | | propertyDefinition.loadClass(className, AccessControlHandler.class); |
| | | AccessControlHandler<? extends AccessControlHandlerCfg> provider = |
| | | (AccessControlHandler<? extends AccessControlHandlerCfg>) |
| | | providerClass.newInstance(); |
| | | |
| | | if (configuration != null) |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | |
| | | |
| | | /** |
| | |
| | | ConfigurationDeleteListener<AlertHandlerCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated alert |
| | | // handlers. |
| | | private ConcurrentHashMap<DN,AlertHandler> alertHandlers; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | ErrorLogger.logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import java.lang.reflect.Method; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.ArrayList; |
| | | import java.util.Iterator; |
| | | import java.util.List; |
| | |
| | | import org.opends.server.types.InitializationException; |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | ConfigurationDeleteListener<AttributeSyntaxCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated |
| | | // attribute syntaxes. |
| | | private ConcurrentHashMap<DN,AttributeSyntax> syntaxes; |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_SYNTAX_CONFLICTING_SYNTAX.get( |
| | | String.valueOf(syntaxConfiguration.dn()), de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_SYNTAX_CONFLICTING_SYNTAX, String |
| | | .valueOf(syntaxConfiguration.dn()), de.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | import org.opends.server.config.ConfigConstants; |
| | | |
| | | import org.opends.server.types.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | |
| | | // then log an error and skip it. |
| | | if (DirectoryServer.hasBackend(backendCfg.getBackendId())) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_DUPLICATE_BACKEND_ID.get( |
| | | backendID, String.valueOf(backendDN)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_DUPLICATE_BACKEND_ID, backendID, String.valueOf(backendDN)); |
| | | continue; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_INSTANTIATE. |
| | | get(String.valueOf(className), String.valueOf(backendDN), |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_INSTANTIATE, String.valueOf(className), String.valueOf(backendDN), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | continue; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK, backendID, String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | continue; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK, backendID, stackTraceToSingleLineString(e)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | continue; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_INITIALIZE. |
| | | get(String.valueOf(className), String.valueOf(backendDN), |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_INITIALIZE, String.valueOf(className), String.valueOf(backendDN), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | |
| | | try |
| | | { |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK. |
| | | get(backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK. |
| | | get(backendID, stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_REGISTER_BACKEND.get( |
| | | backendID, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_REGISTER_BACKEND, backendID, getExceptionMessage(e)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | { |
| | | // The backend is explicitly disabled. Log a mild warning and |
| | | // continue. |
| | | LocalizableMessage message = |
| | | INFO_CONFIG_BACKEND_DISABLED.get(String.valueOf(backendDN)); |
| | | logError(message); |
| | | logger.debug(INFO_CONFIG_BACKEND_DISABLED, String.valueOf(backendDN)); |
| | | } |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK. |
| | | get(backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK. |
| | | get(backend.getBackendID(), stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backend |
| | | .getBackendID(), stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get(backendID, |
| | | String.valueOf(failureReason)); |
| | | logger.error(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | resultCode = ResultCode.CONSTRAINT_VIOLATION; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get(backendID, |
| | | stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | resultCode = ResultCode.CONSTRAINT_VIOLATION; |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK. |
| | | get(backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get(backendID, |
| | | String.valueOf(failureReason)); |
| | | logger.warn(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get( |
| | | backendID, stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get(backendID, |
| | | stackTraceToSingleLineString(e2)); |
| | | logger.warn(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | |
| | | logError(message); |
| | | logger.warn(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, |
| | |
| | | { |
| | | // The backend is explicitly disabled. We will log a message to |
| | | // indicate that it won't be enabled and return. |
| | | LocalizableMessage message = |
| | | INFO_CONFIG_BACKEND_DISABLED.get(String.valueOf(backendDN)); |
| | | logError(message); |
| | | LocalizableMessage message = INFO_CONFIG_BACKEND_DISABLED.get(String.valueOf(backendDN)); |
| | | logger.debug(message); |
| | | messages.add(message); |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, |
| | | messages); |
| | |
| | | String backendID = cfg.getBackendId(); |
| | | if (DirectoryServer.hasBackend(backendID)) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_DUPLICATE_BACKEND_ID.get( |
| | | String.valueOf(backendDN), backendID); |
| | | logError(message); |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_DUPLICATE_BACKEND_ID.get(String.valueOf(backendDN), |
| | | backendID); |
| | | logger.warn(message); |
| | | messages.add(message); |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, |
| | | messages); |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get(backendID, String |
| | | .valueOf(failureReason)); |
| | | logger.error(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | resultCode = ResultCode.CONSTRAINT_VIOLATION; |
| | |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_BACKEND_CANNOT_ACQUIRE_SHARED_LOCK.get( |
| | | backendID, stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | resultCode = ResultCode.CONSTRAINT_VIOLATION; |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get( |
| | | backendID, String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get( |
| | | backendID, stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | |
| | | logError(message); |
| | | logger.error(message); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backend |
| | | .getBackendID(), String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get( |
| | | backend.getBackendID(), stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backend |
| | | .getBackendID(), stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | ConfigurationDeleteListener<CertificateMapperCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated |
| | | // certificate mappers. |
| | | private ConcurrentHashMap<DN,CertificateMapper> certificateMappers; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | initializeJMX(); |
| | | |
| | | |
| | | logError(INFO_DIRECTORY_BOOTSTRAPPING.get()); |
| | | logger.debug(INFO_DIRECTORY_BOOTSTRAPPING.get()); |
| | | |
| | | |
| | | // Perform all the bootstrapping that is shared with the client-side |
| | |
| | | } |
| | | |
| | | |
| | | logError(NOTE_DIRECTORY_SERVER_STARTING.get(getVersionString(), |
| | | logger.info(NOTE_DIRECTORY_SERVER_STARTING.get(getVersionString(), |
| | | BUILD_ID, REVISION_NUMBER)); |
| | | |
| | | // Acquire an exclusive lock for the Directory Server process. |
| | |
| | | isRunning = true; |
| | | |
| | | LocalizableMessage message = NOTE_DIRECTORY_SERVER_STARTED.get(); |
| | | logError(message); |
| | | logger.info(message); |
| | | sendAlertNotification(this, ALERT_TYPE_SERVER_STARTED, message); |
| | | |
| | | // Force the root connection to be initialized. |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CANNOT_BOOTSTRAP_MATCHING_RULE. |
| | | get(currentFactory.getClass().getName(), |
| | | logger.error(ERR_CANNOT_BOOTSTRAP_MATCHING_RULE, currentFactory.getClass().getName(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_CANNOT_BOOTSTRAP_SYNTAX.get(syntax.getClass().getName(), |
| | | logger.error(ERR_CANNOT_BOOTSTRAP_SYNTAX.get(syntax.getClass().getName(), |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | return syntax; |
| | |
| | | // rollback to auto mode is failing too!! |
| | | // well, just log an error message and suggest the admin |
| | | // to restart the server with the last valid config... |
| | | LocalizableMessage message = ERR_CONFIG_WORKFLOW_CANNOT_CONFIGURE_MANUAL.get(); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_WORKFLOW_CANNOT_CONFIGURE_MANUAL); |
| | | } |
| | | } |
| | | } |
| | |
| | | // rollback to auto mode is failing too!! |
| | | // well, just log an error message and suggest the admin |
| | | // to restart the server with the last valid config... |
| | | LocalizableMessage message = ERR_CONFIG_WORKFLOW_CANNOT_CONFIGURE_AUTO.get(); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_WORKFLOW_CANNOT_CONFIGURE_AUTO); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | |
| | | |
| | | LocalizableMessage message = NOTE_SENT_ALERT_NOTIFICATION.get( |
| | | generator.getClassName(), alertType, |
| | | logger.info(NOTE_SENT_ALERT_NOTIFICATION, generator.getClassName(), alertType, |
| | | alertMessage != null ? |
| | | alertMessage.resourceName()+"-"+alertMessage.ordinal(): |
| | | "-1", |
| | | alertMessage); |
| | | logError(message); |
| | | } |
| | | |
| | | |
| | |
| | | // that this registration has caused |
| | | if (warnings != null) { |
| | | for (LocalizableMessage warning : warnings) { |
| | | logError(warning); |
| | | logger.error(warning); |
| | | } |
| | | } |
| | | |
| | |
| | | // that this registration has caused |
| | | if (warnings != null) { |
| | | for (LocalizableMessage error : warnings) { |
| | | logError(error); |
| | | logger.error(error); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | // The port was already specified: this is a configuration error, |
| | | // log a message. |
| | | LocalizableMessage message = ERR_HOST_PORT_ALREADY_SPECIFIED.get( |
| | | c.getConnectionHandlerName(), listener.toString()); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_HOST_PORT_ALREADY_SPECIFIED.get(c.getConnectionHandlerName(), |
| | | listener.toString()); |
| | | logger.error(message); |
| | | errorMessages.add(message); |
| | | |
| | | } |
| | |
| | | // If there are no connection handlers log a message. |
| | | if (connectionHandlers.isEmpty()) |
| | | { |
| | | LocalizableMessage message = ERR_NOT_AVAILABLE_CONNECTION_HANDLERS.get(); |
| | | logError(message); |
| | | logger.error(ERR_NOT_AVAILABLE_CONNECTION_HANDLERS); |
| | | throw new ConfigException(ERR_ERROR_STARTING_CONNECTION_HANDLERS.get()); |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_SHUTDOWN_CANNOT_RELEASE_SHARED_BACKEND_LOCK. |
| | | get(backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_SHUTDOWN_CANNOT_RELEASE_SHARED_BACKEND_LOCK, |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | message = WARN_SHUTDOWN_CANNOT_RELEASE_SHARED_BACKEND_LOCK. |
| | | get(backend.getBackendID(), stackTraceToSingleLineString(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_SHUTDOWN_CANNOT_RELEASE_SHARED_BACKEND_LOCK, backend |
| | | .getBackendID(), stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | try { |
| | | if (!LockFileManager.releaseLock(serverLockFileName, |
| | | failureReason)) { |
| | | message = NOTE_SERVER_SHUTDOWN.get(className, failureReason); |
| | | logError(message); |
| | | logger.info(NOTE_SERVER_SHUTDOWN, className, failureReason); |
| | | } |
| | | } catch (Exception e) { |
| | | logger.traceException(e); |
| | |
| | | // Log a final message indicating that the server is stopped (which should |
| | | // be true for all practical purposes), and then shut down all the error |
| | | // loggers. |
| | | logError(NOTE_SERVER_STOPPED.get()); |
| | | logger.info(NOTE_SERVER_STOPPED.get()); |
| | | |
| | | removeAllAccessLogPublishers(); |
| | | removeAllErrorLogPublishers(); |
| | |
| | | if (lockdownMode) |
| | | { |
| | | LocalizableMessage message = WARN_DIRECTORY_SERVER_ENTERING_LOCKDOWN_MODE.get(); |
| | | logError(message); |
| | | logger.warn(message); |
| | | |
| | | sendAlertNotification(directoryServer, ALERT_TYPE_ENTERING_LOCKDOWN_MODE, |
| | | message); |
| | |
| | | else |
| | | { |
| | | LocalizableMessage message = NOTE_DIRECTORY_SERVER_LEAVING_LOCKDOWN_MODE.get(); |
| | | logError(message); |
| | | logger.info(message); |
| | | |
| | | sendAlertNotification(directoryServer, ALERT_TYPE_LEAVING_LOCKDOWN_MODE, |
| | | message); |
| | |
| | | import org.opends.server.monitors.EntryCacheMonitorProvider; |
| | | import org.opends.server.types.DN; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | } catch (Exception e) { |
| | | logger.traceException(e); |
| | | |
| | | logError(WARN_CONFIG_ENTRYCACHE_NO_CONFIG_ENTRY.get()); |
| | | logger.warn(WARN_CONFIG_ENTRYCACHE_NO_CONFIG_ENTRY.get()); |
| | | return; |
| | | } |
| | | |
| | |
| | | // no entry cache defined below it. |
| | | if (entryCacheBase == null) |
| | | { |
| | | logError(WARN_CONFIG_ENTRYCACHE_NO_CONFIG_ENTRY.get()); |
| | | logger.error(WARN_CONFIG_ENTRYCACHE_NO_CONFIG_ENTRY.get()); |
| | | return; |
| | | } |
| | | |
| | |
| | | if (!cacheOrderMap.isEmpty()) { |
| | | if (cacheOrderMap.containsKey(configuration.getCacheLevel())) { |
| | | // Log error and skip this cache. |
| | | logError(ERR_CONFIG_ENTRYCACHE_CONFIG_LEVEL_NOT_ACCEPTABLE.get( |
| | | logger.error(ERR_CONFIG_ENTRYCACHE_CONFIG_LEVEL_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), |
| | | configuration.getCacheLevel())); |
| | | continue; |
| | |
| | | try { |
| | | loadAndInstallEntryCache(className, configuration); |
| | | } catch (InitializationException ie) { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | } |
| | | } |
| | | } |
| | |
| | | } catch (UnsupportedOperationException ex) { |
| | | // Some backend implementations might not support entry |
| | | // cache preload. Log a warning and continue. |
| | | LocalizableMessage message = WARN_CACHE_PRELOAD_BACKEND_FAILED.get( |
| | | backend.getBackendID()); |
| | | logError(message); |
| | | logger.warn(WARN_CACHE_PRELOAD_BACKEND_FAILED, backend.getBackendID()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | ConfigurationDeleteListener<ExtensionCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated |
| | | // extensions. |
| | | private ConcurrentHashMap<DN,Extension> extensions; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.protocols.internal.InternalClientConnection.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | catch (InitializationException ie) |
| | | { |
| | | // Log error but keep going |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | } |
| | | } |
| | | } |
| | |
| | | filter = groupImplementation.getGroupDefinitionFilter(); |
| | | if (backend.getEntryCount() > 0 && ! backend.isIndexed(filter)) |
| | | { |
| | | logError(WARN_GROUP_FILTER_NOT_INDEXED.get(String.valueOf(filter), |
| | | logger.warn(WARN_GROUP_FILTER_NOT_INDEXED.get(String.valueOf(filter), |
| | | String.valueOf(configEntryDN), backend.getBackendID())); |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.InitializationException; |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | ConfigurationDeleteListener<IdentityMapperCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated identity |
| | | // mappers. |
| | | private ConcurrentHashMap<DN,IdentityMapper> identityMappers; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | DN mapperDN = DirectoryServer.getProxiedAuthorizationIdentityMapperDN(); |
| | | if (mapperDN == null) |
| | | { |
| | | logError(ERR_CONFIG_IDMAPPER_NO_PROXY_MAPPER_DN.get()); |
| | | logger.error(ERR_CONFIG_IDMAPPER_NO_PROXY_MAPPER_DN.get()); |
| | | } |
| | | else if (! identityMappers.containsKey(mapperDN)) |
| | | { |
| | | logError(ERR_CONFIG_IDMAPPER_INVALID_PROXY_MAPPER_DN.get( |
| | | String.valueOf(mapperDN))); |
| | | logger.error(ERR_CONFIG_IDMAPPER_INVALID_PROXY_MAPPER_DN.get(String.valueOf(mapperDN))); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.DisconnectReason; |
| | | |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_IDLETIME_DISCONNECT_ERROR.get( |
| | | c.getConnectionID(), |
| | | logger.error(ERR_IDLETIME_DISCONNECT_ERROR, c.getConnectionID(), |
| | | stackTraceToSingleLineString(e) |
| | | ); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_IDLETIME_UNEXPECTED_ERROR.get(stackTraceToSingleLineString(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_IDLETIME_UNEXPECTED_ERROR, stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | ConfigurationDeleteListener<KeyManagerProviderCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated key |
| | | // manager providers. |
| | | private ConcurrentHashMap<DN,KeyManagerProvider> providers; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | package org.opends.server.core; |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | | |
| | |
| | | ConfigurationDeleteListener<LogPublisherCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | private final ServerContext serverContext; |
| | | |
| | | /** |
| | |
| | | // disable all debug loggers. |
| | | if (accessPublisherCfgs.isEmpty()) |
| | | { |
| | | logError(WARN_CONFIG_LOGGER_NO_ACTIVE_ACCESS_LOGGERS.get()); |
| | | logger.warn(WARN_CONFIG_LOGGER_NO_ACTIVE_ACCESS_LOGGERS.get()); |
| | | } |
| | | if (errorPublisherCfgs.isEmpty()) |
| | | { |
| | | logError(WARN_CONFIG_LOGGER_NO_ACTIVE_ERROR_LOGGERS.get()); |
| | | logger.warn(WARN_CONFIG_LOGGER_NO_ACTIVE_ERROR_LOGGERS.get()); |
| | | } |
| | | |
| | | DebugLogger.getInstance().initializeLogger(debugPublisherCfgs, serverContext); |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | |
| | | |
| | | /** |
| | |
| | | ConfigurationDeleteListener<MatchingRuleCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated matching |
| | | // rule Factories. |
| | | private ConcurrentHashMap<DN,MatchingRuleFactory> matchingRuleFactories; |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_MR_CONFLICTING_MR.get( |
| | | String.valueOf(mrConfiguration.dn()), de.getMessageObject()); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_MR_CONFLICTING_MR, String |
| | | .valueOf(mrConfiguration.dn()), de.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | ErrorLogger.logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | ConfigurationDeleteListener<MonitorProviderCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated monitor |
| | | // providers. |
| | | private ConcurrentHashMap<DN,MonitorProvider<?>> monitors; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.stackTraceToSingleLineString; |
| | | |
| | | |
| | |
| | | ConfigurationChangeListener<PasswordGeneratorCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | // A mapping between the DNs of the config entries and the associated password |
| | | // generators. |
| | | private ConcurrentHashMap<DN,PasswordGenerator> passwordGenerators; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.server.util.StaticUtils.stackTraceToSingleLineString; |
| | | |
| | | import java.lang.reflect.InvocationTargetException; |
| | |
| | | { |
| | | // Just log a message instead of failing the server initialization. |
| | | // This will allow the administrator to fix any problems. |
| | | LocalizableMessage message = ERR_CONFIG_PWPOLICY_INVALID_POLICY_CONFIG.get( |
| | | String.valueOf(subentry.getDN()), |
| | | logger.error(ERR_CONFIG_PWPOLICY_INVALID_POLICY_CONFIG, String.valueOf(subentry.getDN()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import org.opends.server.admin.std.meta.PasswordPolicyCfgDefn; |
| | | import org.opends.server.api.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.ldap.LDAPAttribute; |
| | |
| | | (passwordPolicy.getStateUpdateFailurePolicy() == |
| | | PasswordPolicyCfgDefn.StateUpdateFailurePolicy.IGNORE))) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | else |
| | | { |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | ConfigurationDeleteListener<PasswordValidatorCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated |
| | | // password validators. |
| | | private ConcurrentHashMap<DN,PasswordValidator> passwordValidators; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.PluginMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_PLUGIN_EMPTY_ELEMENT_IN_ORDER.get( |
| | | pluginType.getName()); |
| | | logError(message); |
| | | logger.warn(message); |
| | | } |
| | | } |
| | | else if (token.equals("*")) |
| | |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_PLUGIN_MULTIPLE_WILDCARDS_IN_ORDER. |
| | | get(pluginType.getName()); |
| | | logError(message); |
| | | logger.warn(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get( |
| | | pluginType.getName(), token); |
| | | logError(message); |
| | | logger.warn(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_PLUGIN_LISTED_MULTIPLE_TIMES.get( |
| | | pluginType.getName(), token); |
| | | logError(message); |
| | | logger.warn(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_CONFIG_PLUGIN_ORDER_NO_WILDCARD.get(pluginType.getName()); |
| | | logError(message); |
| | | logger.warn(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage message = ERR_PLUGIN_STARTUP_PLUGIN_RETURNED_NULL.get( |
| | | String.valueOf(p.getPluginEntryDN())); |
| | | logError(message); |
| | | logger.error(message); |
| | | return PluginResult.Startup.stopStartup(message); |
| | | } |
| | | else if (! result.continueProcessing()) |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | result.getErrorMessage(), |
| | | result.getErrorMessage().ordinal()); |
| | | logError(message); |
| | | logger.error(message); |
| | | return result; |
| | | } |
| | | } |
| | |
| | | LocalizableMessage message = ERR_PLUGIN_SHUTDOWN_PLUGIN_EXCEPTION. |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | clientConnection.getConnectionID(), |
| | | clientConnection.getClientAddress(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.PostConnect.disconnectClient( |
| | | DisconnectReason.SERVER_ERROR, true, message); |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | clientConnection.getConnectionID(), |
| | | clientConnection.getClientAddress()); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.PostConnect.disconnectClient( |
| | | DisconnectReason.SERVER_ERROR, true, message); |
| | |
| | | clientConnection.getConnectionID(), |
| | | clientConnection.getClientAddress(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | |
| | | |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | clientConnection.getConnectionID(), |
| | | clientConnection.getClientAddress()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | else if (! result.continuePluginProcessing()) |
| | | { |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | String.valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.ImportLDIF.stopEntryProcessing(message); |
| | | } |
| | |
| | | LocalizableMessage message = ERR_PLUGIN_LDIF_IMPORT_PLUGIN_RETURNED_NULL. |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | String.valueOf(entry.getName())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.ImportLDIF.stopEntryProcessing(message); |
| | | } |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | String.valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.ImportLDIF.stopEntryProcessing(message); |
| | | } |
| | |
| | | LocalizableMessage message = ERR_PLUGIN_LDIF_EXPORT_PLUGIN_RETURNED_NULL. |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | String.valueOf(entry.getName())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.ImportLDIF.stopEntryProcessing(message); |
| | | } |
| | |
| | | .getOperationName(), String.valueOf(plugin.getPluginEntryDN()), |
| | | operation.getConnectionID(), operation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.PreParse.stopProcessing(DirectoryServer |
| | | .getServerErrorResultCode(), message); |
| | |
| | | .getOperationType().getOperationName(), String.valueOf(plugin |
| | | .getPluginEntryDN()), operation.getConnectionID(), String |
| | | .valueOf(operation.getOperationID())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.PreParse.stopProcessing(DirectoryServer |
| | | .getServerErrorResultCode(), message); |
| | |
| | | .getOperationType().getOperationName(), String.valueOf(plugin |
| | | .getPluginEntryDN()), operation.getConnectionID(), operation |
| | | .getOperationID(), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | registerSkippedPreOperationPlugins(i, plugins, operation); |
| | | |
| | |
| | | .getOperationType().getOperationName(), String.valueOf(plugin |
| | | .getPluginEntryDN()), operation.getConnectionID(), operation |
| | | .getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | registerSkippedPreOperationPlugins(i, plugins, operation); |
| | | |
| | |
| | | abandonOperation.getConnectionID(), |
| | | abandonOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | abandonOperation.getConnectionID(), |
| | | abandonOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | addOperation.getConnectionID(), addOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | get(addOperation.getOperationType().getOperationName(), |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | addOperation.getConnectionID(), addOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | bindOperation.getConnectionID(), bindOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | bindOperation.getConnectionID(), |
| | | bindOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | compareOperation.getConnectionID(), |
| | | compareOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | compareOperation.getConnectionID(), |
| | | compareOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | extendedOperation.getConnectionID(), |
| | | extendedOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | extendedOperation.getConnectionID(), |
| | | extendedOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | modifyOperation.getConnectionID(), |
| | | modifyOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | modifyOperation.getConnectionID(), |
| | | modifyOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | unbindOperation.getConnectionID(), |
| | | unbindOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | unbindOperation.getConnectionID(), |
| | | unbindOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continueProcessing()) |
| | | { |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | addOperation.getConnectionID(), addOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | get(addOperation.getOperationType().getOperationName(), |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | addOperation.getConnectionID(), addOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | bindOperation.getConnectionID(), bindOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | bindOperation.getConnectionID(), |
| | | bindOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | compareOperation.getConnectionID(), |
| | | compareOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | compareOperation.getConnectionID(), |
| | | compareOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | extendedOperation.getConnectionID(), |
| | | extendedOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | extendedOperation.getConnectionID(), |
| | | extendedOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | modifyOperation.getConnectionID(), |
| | | modifyOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | modifyOperation.getConnectionID(), |
| | | modifyOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | if (result == null) |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else if (!result.continuePluginProcessing()) |
| | | { |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | addOperation.getConnectionID(), addOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | modifyOperation.getConnectionID(), |
| | | modifyOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | searchOperation.getOperationID(), |
| | | String.valueOf(searchEntry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing(false, |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID(), |
| | | String.valueOf(searchEntry.getName())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing(false, |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | searchOperation.getOperationID(), |
| | | searchReference.getReferralURLString(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing(false, |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | searchOperation.getConnectionID(), |
| | | searchOperation.getOperationID(), |
| | | searchReference.getReferralURLString()); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing(false, |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | modifyDNOperation.getConnectionID(), |
| | | modifyDNOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.SubordinateModifyDN.stopProcessing( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | modifyDNOperation.getConnectionID(), |
| | | String.valueOf(modifyDNOperation.getOperationID())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.SubordinateModifyDN.stopProcessing( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | deleteOperation.getConnectionID(), |
| | | deleteOperation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.SubordinateDelete.stopProcessing( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | String.valueOf(p.getPluginEntryDN()), |
| | | deleteOperation.getConnectionID(), |
| | | String.valueOf(deleteOperation.getOperationID())); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.SubordinateDelete.stopProcessing( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | operation.getConnectionID(), operation.getOperationID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing |
| | | (false, DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | LocalizableMessage message = ERR_PLUGIN_INTERMEDIATE_RESPONSE_PLUGIN_RETURNED_NULL. |
| | | get(String.valueOf(p.getPluginEntryDN()), |
| | | operation.getConnectionID(), operation.getOperationID()); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | return PluginResult.IntermediateResponse.stopProcessing |
| | | (false, DirectoryServer.getServerErrorResultCode(), message); |
| | |
| | | if (result == null) |
| | | { |
| | | // This should only happen if there were no intermediate response plugins |
| | | // registered, which is fine. |
| | | // registered, which is fine.WARN |
| | | |
| | | result = |
| | | PluginResult.IntermediateResponse.continueOperationProcessing(true); |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | |
| | | |
| | | /** |
| | |
| | | ConfigurationDeleteListener<SASLMechanismHandlerCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the |
| | | // associated SASL |
| | | // mechanism handlers. |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | ErrorLogger.logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | return null; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | StaticUtils.close(reader); |
| | | return null; |
| | | } |
| | |
| | | Entry e = reader.readEntry(false); |
| | | if (e != null) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_MULTIPLE_ENTRIES_IN_FILE.get( |
| | | schemaFile, schemaDirPath); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_MULTIPLE_ENTRIES_IN_FILE, schemaFile, schemaDirPath); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_UNPARSEABLE_EXTRA_DATA_IN_FILE.get( |
| | | schemaFile, schemaDirPath, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_UNPARSEABLE_EXTRA_DATA_IN_FILE, schemaFile, schemaDirPath, getExceptionMessage(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_LDAP_SYNTAX.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_LDAP_SYNTAX, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_ATTR_TYPE.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_ATTR_TYPE, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_OC.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_OC, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_NAME_FORM.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_NAME_FORM, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_DCR.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_DCR, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_DSR.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_DSR, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CONFLICTING_MRU.get( |
| | | schemaFile, de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_CONFIG_SCHEMA_CONFLICTING_MRU, schemaFile, de.getMessageObject()); |
| | | |
| | | try |
| | | { |
| | |
| | | LocalBackendSearchOperation; |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | |
| | |
| | | ")"); |
| | | if (backend.getEntryCount() > 0 && ! backend.isIndexed(filter)) |
| | | { |
| | | logError(WARN_SUBENTRY_FILTER_NOT_INDEXED.get( |
| | | String.valueOf(filter), backend.getBackendID())); |
| | | logger.warn(WARN_SUBENTRY_FILTER_NOT_INDEXED.get(String.valueOf(filter), backend.getBackendID())); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | */ |
| | | package org.opends.server.core; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | |
| | | |
| | | /** |
| | |
| | | ConfigurationDeleteListener<TrustManagerProviderCfg> |
| | | |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // A mapping between the DNs of the config entries and the associated trust |
| | | // manager providers. |
| | | private ConcurrentHashMap<DN,TrustManagerProvider> providers; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | ErrorLogger.logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | import org.opends.server.admin.std.server.VirtualAttributeCfg; |
| | | import org.opends.server.api.VirtualAttributeProvider; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | ErrorLogger.logError(ie.getMessageObject()); |
| | | logger.error(ie.getMessageObject()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.forgerock.util.Reject.*; |
| | | |
| | |
| | | { |
| | | // The workflow does not exist, log an error message |
| | | // and skip the workflow. |
| | | LocalizableMessage message = |
| | | INFO_ERR_WORKFLOW_DOES_NOT_EXIST.get(workflowID, |
| | | logger.debug(INFO_ERR_WORKFLOW_DOES_NOT_EXIST, workflowID, |
| | | networkGroup.getID()); |
| | | logError(message); |
| | | } |
| | | else |
| | | { |
| | |
| | | import org.opends.server.api.ChangeNotificationListener; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.opends.server.types.*; |
| | | import org.opends.server.types.operation.PostResponseAddOperation; |
| | | import org.opends.server.types.operation.PostResponseDeleteOperation; |
| | |
| | | ResultCode resultCode = searchOperation.getResultCode(); |
| | | if (resultCode != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = |
| | | INFO_TRUSTSTORESYNC_ADMIN_SUFFIX_SEARCH_FAILED.get( |
| | | String.valueOf(adminSuffixDN), |
| | | logger.debug(INFO_TRUSTSTORESYNC_ADMIN_SUFFIX_SEARCH_FAILED, String.valueOf(adminSuffixDN), |
| | | searchOperation.getErrorMessage().toString()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | |
| | | for (SearchResultEntry searchEntry : searchOperation.getSearchEntries()) |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_TRUSTSTORESYNC_EXCEPTION.get( |
| | | stackTraceToSingleLineString(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_TRUSTSTORESYNC_EXCEPTION, stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (delOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = INFO_TRUSTSTORESYNC_DELETE_FAILED.get( |
| | | String.valueOf(dstDN), |
| | | logger.debug(INFO_TRUSTSTORESYNC_DELETE_FAILED, String.valueOf(dstDN), |
| | | String.valueOf(delOperation.getErrorMessage())); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | AddOperation addOperation = conn.processAdd(addEntry); |
| | | if (addOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = INFO_TRUSTSTORESYNC_ADD_FAILED.get( |
| | | String.valueOf(dstDN), |
| | | logger.debug(INFO_TRUSTSTORESYNC_ADD_FAILED, String.valueOf(dstDN), |
| | | String.valueOf(addOperation.getErrorMessage())); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage message = LocalizableMessage.raw("Failed to import key entry: %s", |
| | | e.getMessage()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | LocalizableMessage message = LocalizableMessage.raw("Failed to import modified key entry: %s", |
| | | e.getMessage()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AnonymousSASLMechanismHandlerCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.SASLMechanismHandler; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.BindOperation; |
| | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | |
| | | |
| | |
| | | public class AnonymousSASLMechanismHandler |
| | | extends SASLMechanismHandler<AnonymousSASLMechanismHandlerCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this SASL mechanism handler. No initialization |
| | | * should be done in this method, as it should all be performed in the |
| | |
| | | { |
| | | bindOperation.addAdditionalLogItem(AdditionalLogItem.quotedKeyValue( |
| | | getClass(), "trace", credString)); |
| | | logError(INFO_SASLANONYMOUS_TRACE. |
| | | logger.error(INFO_SASLANONYMOUS_TRACE. |
| | | get(bindOperation.getConnectionID(), bindOperation.getOperationID(), |
| | | credString)); |
| | | |
| | |
| | | f = new File(configFile + ".startok"); |
| | | if (! f.exists()) |
| | | { |
| | | logError(WARN_CONFIG_FILE_NO_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | logger.warn(WARN_CONFIG_FILE_NO_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | configFile)); |
| | | useLastKnownGoodConfig = false; |
| | | f = new File(configFile); |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_CONFIG_FILE_USING_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | logger.info(NOTE_CONFIG_FILE_USING_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | configFile)); |
| | | } |
| | | } |
| | |
| | | // FIXME -- Log each error message and throw an exception. |
| | | for (LocalizableMessage s : errorList) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ERROR_APPLYING_STARTUP_CHANGE.get(s); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_ERROR_APPLYING_STARTUP_CHANGE, s); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_UNABLE_TO_APPLY_CHANGES_FILE.get(); |
| | |
| | | |
| | | StaticUtils.close(inputStream, outputStream); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_MANUAL_CHANGES_DETECTED.get( |
| | | configFile, newConfigFile.getAbsolutePath()); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | WARN_CONFIG_MANUAL_CHANGES_DETECTED.get(configFile, newConfigFile |
| | | .getAbsolutePath()); |
| | | logger.warn(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_MANUAL_CONFIG_EDIT_HANDLED, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_MANUAL_CHANGES_LOST.get( |
| | | configFile, stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_MANUAL_CHANGES_LOST.get(configFile, |
| | | stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_MANUAL_CONFIG_EDIT_HANDLED, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_WRITE_CANNOT_EXPORT_NEW_CONFIG.get( |
| | | String.valueOf(tempConfig), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_FILE_WRITE_CANNOT_EXPORT_NEW_CONFIG.get(String |
| | | .valueOf(tempConfig), stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_WRITE_CANNOT_RENAME_NEW_CONFIG. |
| | | get(String.valueOf(tempConfig), String.valueOf(configFile), |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_FILE_WRITE_CANNOT_RENAME_NEW_CONFIG.get(String |
| | | .valueOf(tempConfig), String.valueOf(configFile), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | if (! archiveDirectory.mkdirs()) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_FILE_CANNOT_CREATE_ARCHIVE_DIR_NO_REASON. |
| | | get(archiveDirectory.getAbsolutePath()); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_CONFIG_FILE_CANNOT_CREATE_ARCHIVE_DIR_NO_REASON.get( |
| | | archiveDirectory.getAbsolutePath()); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_CANNOT_CREATE_ARCHIVE_DIR. |
| | | get(archiveDirectory.getAbsolutePath(), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_FILE_CANNOT_CREATE_ARCHIVE_DIR.get(archiveDirectory |
| | | .getAbsolutePath(), stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_CANNOT_WRITE_CONFIG_ARCHIVE.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_FILE_CANNOT_WRITE_CONFIG_ARCHIVE |
| | | .get(stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_CANNOT_WRITE_CONFIG_ARCHIVE.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_FILE_CANNOT_WRITE_CONFIG_ARCHIVE |
| | | .get(stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_CANNOT_WRITE_CONFIGURATION, message); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_STARTOK_CANNOT_WRITE.get(configFile, tempFilePath, |
| | | logger.error(ERR_STARTOK_CANNOT_WRITE.get(configFile, tempFilePath, |
| | | getExceptionMessage(e))); |
| | | return; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_STARTOK_CANNOT_OPEN_FOR_WRITING.get(tempFilePath, |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_WRITING.get(tempFilePath, |
| | | getExceptionMessage(e))); |
| | | return; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_STARTOK_CANNOT_OPEN_FOR_READING.get(configFile, |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_READING.get(configFile, |
| | | getExceptionMessage(e))); |
| | | return; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_STARTOK_CANNOT_RENAME.get(tempFilePath, startOKFilePath, |
| | | logger.error(ERR_STARTOK_CANNOT_RENAME.get(tempFilePath, startOKFilePath, |
| | | getExceptionMessage(e))); |
| | | return; |
| | | } |
| | |
| | | try |
| | | { |
| | | configBackupDir.renameTo(configDir); |
| | | LocalizableMessage message = |
| | | NOTE_CONFIG_RESTORE_RESTORED_OLD_CONFIG.get(configDirPath); |
| | | logError(message); |
| | | logger.info(NOTE_CONFIG_RESTORE_RESTORED_OLD_CONFIG, configDirPath); |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_CANNOT_RESTORE_OLD_CONFIG.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_CANNOT_RESTORE_OLD_CONFIG, configBackupDir.getPath()); |
| | | } |
| | | } |
| | | |
| | |
| | | // Tell the user where the previous config was archived. |
| | | if (configBackupDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED, configBackupDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_CANNOT_GET_ZIP_ENTRY.get( |
| | |
| | | // Tell the user where the previous config was archived. |
| | | if (configBackupDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED, configBackupDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_CANNOT_CREATE_FILE. |
| | |
| | | // Tell the user where the previous config was archived. |
| | | if (configBackupDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED, configBackupDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_CANNOT_PROCESS_ARCHIVE_FILE.get( |
| | |
| | | byte[] calculatedHash = digest.digest(); |
| | | if (Arrays.equals(calculatedHash, unsignedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_CONFIG_RESTORE_UNSIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_CONFIG_RESTORE_UNSIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | | // Tell the user where the previous config was archived. |
| | | if (configBackupDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED, configBackupDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = |
| | |
| | | byte[] calculatedSignature = mac.doFinal(); |
| | | if (Arrays.equals(calculatedSignature, signedHash)) |
| | | { |
| | | LocalizableMessage message = NOTE_CONFIG_RESTORE_SIGNED_HASH_VALID.get(); |
| | | logError(message); |
| | | logger.info(NOTE_CONFIG_RESTORE_SIGNED_HASH_VALID); |
| | | } |
| | | else |
| | | { |
| | | // Tell the user where the previous config was archived. |
| | | if (configBackupDir != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED.get( |
| | | configBackupDir.getPath()); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_RESTORE_OLD_CONFIG_SAVED, configBackupDir.getPath()); |
| | | } |
| | | |
| | | LocalizableMessage message = |
| | |
| | | // If we are just verifying the archive, then we're done. |
| | | if (verifyOnly) |
| | | { |
| | | LocalizableMessage message = |
| | | NOTE_CONFIG_RESTORE_VERIFY_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_CONFIG_RESTORE_VERIFY_SUCCESSFUL, backupID, backupPath); |
| | | return; |
| | | } |
| | | |
| | |
| | | recursiveDelete(configBackupDir); |
| | | } |
| | | |
| | | LocalizableMessage message = NOTE_CONFIG_RESTORE_SUCCESSFUL.get(backupID, backupPath); |
| | | logError(message); |
| | | logger.info(NOTE_CONFIG_RESTORE_SUCCESSFUL, backupID, backupPath); |
| | | } |
| | | |
| | | |
| | |
| | | { |
| | | if (result == null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_CHANGE_NO_RESULT. |
| | | get(String.valueOf(className), String.valueOf(methodName), |
| | | logger.error(ERR_CONFIG_CHANGE_NO_RESULT, String.valueOf(className), String.valueOf(methodName), |
| | | String.valueOf(entryDN)); |
| | | logError(message); |
| | | return; |
| | | } |
| | | |
| | |
| | | |
| | | if (resultCode != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_CHANGE_RESULT_ERROR. |
| | | get(String.valueOf(className), String.valueOf(methodName), |
| | | logger.error(ERR_CONFIG_CHANGE_RESULT_ERROR, String.valueOf(className), String.valueOf(methodName), |
| | | String.valueOf(entryDN), String.valueOf(resultCode), |
| | | adminActionRequired, messageBuffer.toString()); |
| | | logError(message); |
| | | } |
| | | else if (adminActionRequired) |
| | | { |
| | | LocalizableMessage message = WARN_CONFIG_CHANGE_RESULT_ACTION_REQUIRED. |
| | | get(String.valueOf(className), String.valueOf(methodName), |
| | | logger.warn(WARN_CONFIG_CHANGE_RESULT_ACTION_REQUIRED, String.valueOf(className), String.valueOf(methodName), |
| | | String.valueOf(entryDN), messageBuffer.toString()); |
| | | logError(message); |
| | | } |
| | | else if (messageBuffer.length() > 0) |
| | | { |
| | | LocalizableMessage message = INFO_CONFIG_CHANGE_RESULT_MESSAGES. |
| | | get(String.valueOf(className), String.valueOf(methodName), |
| | | logger.debug(INFO_CONFIG_CHANGE_RESULT_MESSAGES, String.valueOf(className), String.valueOf(methodName), |
| | | String.valueOf(entryDN), messageBuffer.toString()); |
| | | logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.opends.server.types.InitializationException; |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | identityMapper = DirectoryServer.getIdentityMapper(identityMapperDN); |
| | | serverFQDN = getFQDN(configuration); |
| | | LocalizableMessage msg= NOTE_DIGEST_MD5_SERVER_FQDN.get(serverFQDN); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | String QOP = getQOP(configuration); |
| | | saslProps = new HashMap<String,String>(); |
| | | saslProps.put(Sasl.QOP, QOP); |
| | | String realm=getRealm(configuration); |
| | | if(realm != null) { |
| | | msg = INFO_DIGEST_MD5_REALM.get(realm); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | saslProps.put(REALM_PROPERTY, getRealm(configuration)); |
| | | } |
| | | this.configuration = configuration; |
| | |
| | | identityMapper = DirectoryServer.getIdentityMapper(identityMapperDN); |
| | | serverFQDN = getFQDN(configuration); |
| | | LocalizableMessage msg = NOTE_DIGEST_MD5_SERVER_FQDN.get(serverFQDN); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | String QOP = getQOP(configuration); |
| | | saslProps = new HashMap<String,String>(); |
| | | saslProps.put(Sasl.QOP, QOP); |
| | | String realm=getRealm(configuration); |
| | | if(realm != null) { |
| | | msg = INFO_DIGEST_MD5_REALM.get(realm); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | saslProps.put(REALM_PROPERTY, getRealm(configuration)); |
| | | } |
| | | this.configuration = configuration; |
| | |
| | | import org.opends.server.api.MonitorProvider; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.CoreMessages. |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | ErrorLogger.logError(ERR_DISK_SPACE_MONITOR_UPDATE_FAILED.get( |
| | | directory.getPath(), e.toString())); |
| | | logger.error(ERR_DISK_SPACE_MONITOR_UPDATE_FAILED.get(directory.getPath(), e.toString())); |
| | | |
| | | logger.traceException(e); |
| | | } |
| | |
| | | import org.opends.server.admin.std.server.DynamicGroupImplementationCfg; |
| | | import org.opends.server.api.Group; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.Attribute; |
| | | import org.opends.server.types.AttributeType; |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_DYNAMICGROUP_CANNOT_DECODE_MEMBERURL. |
| | | get(v.getValue().toString(), |
| | | logger.error(ERR_DYNAMICGROUP_CANNOT_DECODE_MEMBERURL, v.getValue().toString(), |
| | | String.valueOf(groupEntry.getName()), |
| | | de.getMessageObject()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.extensions; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.SearchScope; |
| | | |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | |
| | | /** |
| | | * This class implements a Directory Server thread that will be used to perform |
| | |
| | | extends DirectoryThread |
| | | implements InternalSearchListener |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The set of base DNs for the search requests. |
| | | private final DN[] baseDNs; |
| | | |
| | |
| | | { |
| | | if (resultCode == ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | LocalizableMessage message = WARN_DYNAMICGROUP_NONEXISTENT_BASE_DN. |
| | | get(String.valueOf(baseDNs[searchCounter]), |
| | | logger.warn(WARN_DYNAMICGROUP_NONEXISTENT_BASE_DN, String.valueOf(baseDNs[searchCounter]), |
| | | String.valueOf(memberList.getDynamicGroupDN())); |
| | | ErrorLogger.logError(message); |
| | | continue; |
| | | } |
| | | else |
| | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | import java.util.ArrayList; |
| | |
| | | */ |
| | | public class EntryCacheCommon |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Configuration phases. Each value identifies a configuration step: |
| | | * - PHASE_INIT when invoking method initializeEntryCache() |
| | |
| | | { |
| | | case PHASE_INIT: |
| | | { |
| | | logError (error); |
| | | logger.error(error); |
| | | break; |
| | | } |
| | | case PHASE_ACCEPTABLE: |
| | |
| | | */ |
| | | package org.opends.server.extensions; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | |
| | | |
| | |
| | | ConfigurationChangeListener |
| | | <ErrorLogAccountStatusNotificationHandlerCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The set of names for the account status notification types that may be |
| | | * logged by this notification handler. |
| | |
| | | public void handleStatusNotification( |
| | | AccountStatusNotification notification) |
| | | { |
| | | logError(NOTE_ERRORLOG_ACCTNOTHANDLER_NOTIFICATION.get( |
| | | notification.getNotificationType().getName(), |
| | | logger.info(NOTE_ERRORLOG_ACCTNOTHANDLER_NOTIFICATION.get(notification.getNotificationType().getName(), |
| | | String.valueOf(notification.getUserDN()), |
| | | notification.getMessage().ordinal(), |
| | | notification.getMessage())); |
| | |
| | | import org.forgerock.opendj.ldap.ByteStringBuilder; |
| | | import org.opends.server.util.ServerConstants; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | INDEXKEY.getBytes("UTF-8")); |
| | | |
| | | // Persistent state report. |
| | | LocalizableMessage message = NOTE_FSCACHE_RESTORE.get(); |
| | | logError(message); |
| | | logger.info(NOTE_FSCACHE_RESTORE); |
| | | |
| | | if (OperationStatus.SUCCESS == |
| | | entryCacheDB.get(null, indexKey, indexData, LockMode.DEFAULT)) { |
| | |
| | | // Remove cache entries specific to this backend. |
| | | clearBackend(DirectoryServer.getBackend(backend)); |
| | | // Log an error message. |
| | | logError(WARN_FSCACHE_OFFLINE_STATE_FAIL.get(backend)); |
| | | logger.warn(WARN_FSCACHE_OFFLINE_STATE_FAIL.get(backend)); |
| | | } |
| | | } |
| | | // Pop max entries limit. |
| | |
| | | } |
| | | |
| | | // Persistent state report. |
| | | message = NOTE_FSCACHE_RESTORE_REPORT.get( |
| | | entryCacheIndex.dnMap.size()); |
| | | logError(message); |
| | | logger.info(NOTE_FSCACHE_RESTORE_REPORT, entryCacheIndex.dnMap.size()); |
| | | |
| | | } catch (CacheIndexNotFoundException e) { |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError(NOTE_FSCACHE_INDEX_NOT_FOUND.get()); |
| | | logger.info(NOTE_FSCACHE_INDEX_NOT_FOUND.get()); |
| | | |
| | | // Clear the entry cache. |
| | | clear(); |
| | |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError(ERR_FSCACHE_INDEX_IMPAIRED.get()); |
| | | logger.error(ERR_FSCACHE_INDEX_IMPAIRED.get()); |
| | | |
| | | // Clear the entry cache. |
| | | clear(); |
| | |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError(ERR_FSCACHE_CANNOT_LOAD_PERSISTENT_DATA.get()); |
| | | logger.error(ERR_FSCACHE_CANNOT_LOAD_PERSISTENT_DATA.get()); |
| | | |
| | | // Clear the entry cache. |
| | | clear(); |
| | |
| | | DatabaseEntry indexData = new DatabaseEntry(); |
| | | |
| | | // Persistent state save report. |
| | | LocalizableMessage message = NOTE_FSCACHE_SAVE.get(); |
| | | logError(message); |
| | | logger.info(NOTE_FSCACHE_SAVE); |
| | | //This line causes an unchecked call error if the SuppressWarnings |
| | | //annotation is removed at the beginning of this method. |
| | | entryCacheDataBinding.objectToEntry(entryCacheIndex, indexData); |
| | |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError(ERR_FSCACHE_CANNOT_STORE_PERSISTENT_DATA.get()); |
| | | logger.error(ERR_FSCACHE_CANNOT_STORE_PERSISTENT_DATA.get()); |
| | | } |
| | | |
| | | // Persistent state save report. |
| | | LocalizableMessage message = NOTE_FSCACHE_SAVE_REPORT.get( |
| | | entryCacheIndex.dnMap.size()); |
| | | logError(message); |
| | | logger.info(NOTE_FSCACHE_SAVE_REPORT, entryCacheIndex.dnMap.size()); |
| | | } |
| | | |
| | | // Close JE databases and environment and clear all the maps. |
| | |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError(ERR_FSCACHE_CANNOT_RETRIEVE_ENTRY.get()); |
| | | logger.error(ERR_FSCACHE_CANNOT_RETRIEVE_ENTRY.get()); |
| | | } |
| | | return null; |
| | | } |
| | |
| | | logger.traceException(e); |
| | | |
| | | // Log an error message. |
| | | logError( |
| | | logger.error( |
| | | ERR_FSCACHE_CANNOT_STORE_ENTRY.get()); |
| | | |
| | | return false; |
| | |
| | | } |
| | | } catch(Exception e) { |
| | | // Log a warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_FSCACHE_SET_PERMISSIONS_FAILED.get(cacheHome); |
| | | logError(message); |
| | | logger.warn(WARN_FSCACHE_SET_PERMISSIONS_FAILED, cacheHome); |
| | | } |
| | | } |
| | | } else { |
| | |
| | | import org.opends.server.api.CertificateMapper; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.internal.InternalSearchOperation; |
| | |
| | | Backend b = DirectoryServer.getBackend(baseDN); |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | LocalizableMessage message = WARN_SATUACM_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | logger.warn(WARN_SATUACM_ATTR_UNINDEXED, configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | messages.add(message); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.CONFIG_DIR_NAME; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | configuration.addGSSAPIChangeListener(this); |
| | | this.configuration = configuration; |
| | | LocalizableMessage msg = INFO_GSSAPI_STARTED.get(); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | catch (UnknownHostException unhe) |
| | | { |
| | |
| | | } |
| | | w.write(principal.toString()); |
| | | LocalizableMessage msg = INFO_GSSAPI_PRINCIPAL_NAME.get(principal.toString()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | w.write("\" isInitiator=false;"); |
| | | w.newLine(); |
| | | w.write("};"); |
| | |
| | | DirectoryServer.deregisterSASLMechanismHandler(SASL_MECHANISM_GSSAPI); |
| | | clearProperties(); |
| | | LocalizableMessage msg = INFO_GSSAPI_STOPPED.get(); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | |
| | | |
| | |
| | | LocalizableMessage message = ERR_SASLGSSAPI_CANNOT_CREATE_LOGIN_CONTEXT |
| | | .get(getExceptionMessage(ex)); |
| | | // Log a configuration error. |
| | | logError(message); |
| | | logger.error(message); |
| | | connection.setSASLAuthStateInfo(null); |
| | | bindOp.setAuthFailureReason(message); |
| | | bindOp.setResultCode(ResultCode.INVALID_CREDENTIALS); |
| | |
| | | identityMapper = DirectoryServer.getIdentityMapper(identityMapperDN); |
| | | serverFQDN = getFQDN(config); |
| | | LocalizableMessage msg = INFO_GSSAPI_SERVER_FQDN.get(serverFQDN); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | saslProps = new HashMap<String, String>(); |
| | | saslProps.put(Sasl.QOP, getQOP(config)); |
| | | saslProps.put(Sasl.REUSE, "false"); |
| | |
| | | |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.extensions.ExtensionsConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e))); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get(storedPassword.toString(), String.valueOf(e))); |
| | | |
| | | return false; |
| | | } |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | saltLength = decodedBytes.length - SHA1_LENGTH; |
| | | if (saltLength <= 0) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD.get( |
| | | storedPassword.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD, storedPassword.toString()); |
| | | return false; |
| | | } |
| | | saltBytes = new byte[saltLength]; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | | import java.util.concurrent.ConcurrentLinkedQueue; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_WORK_QUEUE_CANNOT_CREATE_MONITOR.get( |
| | | String.valueOf(ParallelWorkQueueMonitor.class), String.valueOf(e)); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_WORK_QUEUE_CANNOT_CREATE_MONITOR, String |
| | | .valueOf(ParallelWorkQueueMonitor.class), String.valueOf(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(WARN_QUEUE_UNABLE_TO_CANCEL.get( |
| | | String.valueOf(o), String.valueOf(e))); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL.get(String.valueOf(o), String.valueOf(e))); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get( |
| | | t.getName(), String.valueOf(e))); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get(t.getName(), String.valueOf(e))); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | if (numFailures > MAX_RETRY_COUNT) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_WORK_QUEUE_TOO_MANY_FAILURES.get( |
| | | Thread.currentThread().getName(), numFailures, MAX_RETRY_COUNT); |
| | | logError(message); |
| | | logger.error(ERR_CONFIG_WORK_QUEUE_TOO_MANY_FAILURES, Thread |
| | | .currentThread().getName(), numFailures, MAX_RETRY_COUNT); |
| | | } |
| | | |
| | | return null; |
| | |
| | | |
| | | // This should not happen. The only recourse we have is to log a message |
| | | // and try again. |
| | | logError(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get( |
| | | Thread.currentThread().getName(), String.valueOf(e))); |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get(Thread |
| | | .currentThread().getName(), String.valueOf(e))); |
| | | return retryNextOperation(workerThread, numFailures + 1); |
| | | } |
| | | } |
| | |
| | | |
| | | try |
| | | { |
| | | LocalizableMessage message = ERR_UNCAUGHT_WORKER_THREAD_EXCEPTION. |
| | | get(getName(), String.valueOf(operation), |
| | | stackTraceToSingleLineString(t)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_UNCAUGHT_WORKER_THREAD_EXCEPTION.get(getName(), String |
| | | .valueOf(operation), stackTraceToSingleLineString(t)); |
| | | logger.error(message); |
| | | |
| | | operation.setResultCode(DirectoryServer.getServerErrorResultCode()); |
| | | operation.appendErrorMessage(message); |
| | |
| | | // and we will want to log a message. |
| | | if (stoppedByReducedThreadNumber) |
| | | { |
| | | logError(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | } |
| | | else if (! workQueue.shutdownRequested()) |
| | | { |
| | | logError(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | } |
| | | |
| | | |
| | |
| | | import org.opends.server.api.VirtualAttributeProvider; |
| | | import org.opends.server.core.PasswordPolicyState; |
| | | import org.opends.server.core.SearchOperation; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.schema.GeneralizedTimeSyntax; |
| | | import org.opends.server.types.*; |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | ErrorLogger.logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | ErrorLogger.logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | |
| | | import org.opends.server.core.ExtendedOperation; |
| | | import org.opends.server.core.ModifyOperation; |
| | | import org.opends.server.core.PasswordPolicyState; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.asn1.ASN1; |
| | | import org.opends.server.protocols.asn1.ASN1Reader; |
| | |
| | | // At this point, the user's password is already changed so there's |
| | | // not much point in returning a non-success result. However, we |
| | | // should at least log that something went wrong. |
| | | ErrorLogger.logError(WARN_EXTOP_PASSMOD_CANNOT_UPDATE_PWP_STATE.get( |
| | | String.valueOf(userDN), |
| | | logger.warn(WARN_EXTOP_PASSMOD_CANNOT_UPDATE_PWP_STATE.get(String.valueOf(userDN), |
| | | String.valueOf(modOp.getResultCode()), |
| | | modOp.getErrorMessage())); |
| | | } |
| | |
| | | import org.opends.server.api.VirtualAttributeProvider; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.core.SearchOperation; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | |
| | | { |
| | | // Something went wrong while trying to |
| | | // retrieve password policy, log this. |
| | | ErrorLogger.logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | |
| | | |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.extensions.ExtensionsConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e))); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get(storedPassword.toString(), String.valueOf(e))); |
| | | |
| | | return false; |
| | | } |
| | |
| | | import org.opends.server.util.EMailMessage; |
| | | |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE.get(notificationType.getName(), |
| | | logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE.get(notificationType.getName(), |
| | | notification.getUserDN().toString(), |
| | | getExceptionMessage(e))); |
| | | } |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | import org.opends.server.util.EMailMessage; |
| | | |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.ExtensionMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | |
| | | LocalizableMessage msg = WARN_SMTPALERTHANDLER_ERROR_SENDING_MESSAGE.get( |
| | | alertType, alertMessage, e.getLocalizedMessage()); |
| | | ErrorLogger.logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | saltLength = decodedBytes.length - SHA1_LENGTH; |
| | | if (saltLength <= 0) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD.get( |
| | | storedPassword.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD, storedPassword.toString()); |
| | | return false; |
| | | } |
| | | saltBytes = new byte[saltLength]; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | saltLength = decodedBytes.length - SHA256_LENGTH; |
| | | if (saltLength <= 0) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD.get( |
| | | storedPassword.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD, storedPassword.toString()); |
| | | return false; |
| | | } |
| | | saltBytes = new byte[saltLength]; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | saltLength = decodedBytes.length - SHA384_LENGTH; |
| | | if (saltLength <= 0) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD.get( |
| | | storedPassword.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD, storedPassword.toString()); |
| | | return false; |
| | | } |
| | | saltBytes = new byte[saltLength]; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.api.PasswordStorageScheme; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | saltLength = decodedBytes.length - SHA512_LENGTH; |
| | | if (saltLength <= 0) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD.get( |
| | | storedPassword.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_INVALID_BASE64_DECODED_STORED_PASSWORD, storedPassword.toString()); |
| | | return false; |
| | | } |
| | | saltBytes = new byte[saltLength]; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword.toString(), String.valueOf(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.core.ModifyOperationBasis; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.ldap.LDAPControl; |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_STATICGROUP_CANNOT_DECODE_MEMBER_VALUE_AS_DN. |
| | | get(v.getValue().toString(), |
| | | logger.error(ERR_STATICGROUP_CANNOT_DECODE_MEMBER_VALUE_AS_DN, v.getValue().toString(), |
| | | someMemberAttributeType.getNameOrOID(), |
| | | String.valueOf(groupEntry.getName()), |
| | | de.getMessageObject()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.opends.server.api.CertificateMapper; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.internal.InternalSearchOperation; |
| | |
| | | Backend b = DirectoryServer.getBackend(baseDN); |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | LocalizableMessage message = WARN_SATUACM_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | logger.warn(WARN_SATUACM_ATTR_UNINDEXED, configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | messages.add(message); |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.opends.server.api.CertificateMapper; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.internal.InternalSearchOperation; |
| | |
| | | Backend b = DirectoryServer.getBackend(baseDN); |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | LocalizableMessage message = WARN_SATUACM_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | logger.warn(WARN_SATUACM_ATTR_UNINDEXED, configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | | import java.util.concurrent.LinkedBlockingQueue; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_WORK_QUEUE_CANNOT_CREATE_MONITOR.get( |
| | | String.valueOf(TraditionalWorkQueueMonitor.class), |
| | | logger.error(ERR_CONFIG_WORK_QUEUE_CANNOT_CREATE_MONITOR, String.valueOf(TraditionalWorkQueueMonitor.class), |
| | | String.valueOf(e)); |
| | | logError(message); |
| | | } |
| | | } |
| | | finally |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(WARN_QUEUE_UNABLE_TO_CANCEL.get(String.valueOf(o), |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL.get(String.valueOf(o), |
| | | String.valueOf(e))); |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get(t.getName(), |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get(t.getName(), |
| | | String.valueOf(e))); |
| | | } |
| | | } |
| | |
| | | |
| | | if (numFailures > MAX_RETRY_COUNT) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_WORK_QUEUE_TOO_MANY_FAILURES.get(Thread |
| | | logger.error(ERR_CONFIG_WORK_QUEUE_TOO_MANY_FAILURES, Thread |
| | | .currentThread().getName(), numFailures, MAX_RETRY_COUNT); |
| | | logError(message); |
| | | |
| | | return null; |
| | | } |
| | |
| | | |
| | | // If we've gotten here, then the worker thread was interrupted for some |
| | | // other reason. This should not happen, and we need to log a message. |
| | | logError(WARN_WORKER_INTERRUPTED_WITHOUT_SHUTDOWN.get(Thread |
| | | logger.warn(WARN_WORKER_INTERRUPTED_WITHOUT_SHUTDOWN.get(Thread |
| | | .currentThread().getName(), String.valueOf(ie))); |
| | | } |
| | | catch (Exception e) |
| | |
| | | |
| | | // This should not happen. The only recourse we have is to log a message |
| | | // and try again. |
| | | logError(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get(Thread |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get(Thread |
| | | .currentThread().getName(), String.valueOf(e))); |
| | | } |
| | | finally |
| | |
| | | |
| | | try |
| | | { |
| | | LocalizableMessage message = ERR_UNCAUGHT_WORKER_THREAD_EXCEPTION. |
| | | get(getName(), String.valueOf(operation), |
| | | stackTraceToSingleLineString(t)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_UNCAUGHT_WORKER_THREAD_EXCEPTION.get(getName(), String |
| | | .valueOf(operation), stackTraceToSingleLineString(t)); |
| | | logger.error(message); |
| | | |
| | | // Ensure that the client receives some kind of result so that it does |
| | | // not hang. |
| | |
| | | // and we will want to log a message. |
| | | if (stoppedByReducedThreadNumber) |
| | | { |
| | | logError(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | } |
| | | else if (! workQueue.shutdownRequested()) |
| | | { |
| | | logError(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | } |
| | | |
| | | |
| | |
| | | package org.opends.server.loggers; |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.messages.Severity; |
| | | import org.opends.server.admin.ClassPropertyDefinition; |
| | |
| | | { |
| | | if(!FilePermission.setPermissions(file, filePermissions)) |
| | | { |
| | | LocalizableMessage message = WARN_LOGGER_UNABLE_SET_PERMISSIONS.get( |
| | | filePermissions.toString(), file.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_LOGGER_UNABLE_SET_PERMISSIONS, filePermissions.toString(), file.toString()); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | // Log an warning that the permissions were not set. |
| | | LocalizableMessage message = WARN_LOGGER_SET_PERMISSION_FAILED.get( |
| | | file.toString(), stackTraceToSingleLineString(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.warn(WARN_LOGGER_SET_PERMISSION_FAILED, file.toString(), stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | config.addDebugTargetDeleteListener(this); |
| | | |
| | | //Get the default/global settings |
| | | LogLevel logLevel = |
| | | DebugLogLevel.parse(config.getDefaultDebugLevel().toString()); |
| | | LogLevel logLevel = LogLevel.ALL; |
| | | Set<LogCategory> logCategories = null; |
| | | if(!config.getDefaultDebugCategory().isEmpty()) |
| | | { |
| | |
| | | package org.opends.server.monitors; |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | import java.util.ArrayList; |
| | |
| | | public class EntryCacheMonitorProvider |
| | | extends MonitorProvider<EntryCacheMonitorProviderCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The name for this monitor. |
| | | private String monitorName; |
| | | |
| | |
| | | public EntryCacheMonitorProvider() |
| | | { |
| | | this.entryCacheName = "Entry Caches"; |
| | | this.entryCache = (EntryCache<?>) DirectoryServer.getEntryCache(); |
| | | this.entryCache = DirectoryServer.getEntryCache(); |
| | | } |
| | | |
| | | /** |
| | |
| | | if (monitorConfiguration == null) { |
| | | LocalizableMessage message = |
| | | INFO_WARN_CONFIG_ENTRYCACHE_NO_MONITOR_CONFIG_ENTRY.get( |
| | | ConfigConstants.DN_ENTRY_CACHE_MONITOR_CONFIG, |
| | | monitorName); |
| | | logError(message); |
| | | ConfigConstants.DN_ENTRY_CACHE_MONITOR_CONFIG, monitorName); |
| | | logger.debug(message); |
| | | throw new ConfigException(message); |
| | | } |
| | | if (!monitorConfiguration.isEnabled()) { |
| | | LocalizableMessage message = |
| | | INFO_WARN_CONFIG_ENTRYCACHE_MONITOR_CONFIG_DISABLED.get( |
| | | ConfigConstants.DN_ENTRY_CACHE_MONITOR_CONFIG, |
| | | monitorName); |
| | | logError(message); |
| | | ConfigConstants.DN_ENTRY_CACHE_MONITOR_CONFIG, monitorName); |
| | | logger.debug(message); |
| | | throw new ConfigException(message); |
| | | } |
| | | } |
| | |
| | | import static org.opends.messages.PluginMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.extensions.ExtensionsConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | .getAuthenticationPolicy(policyDN); |
| | | if (authPolicy == null) |
| | | { |
| | | LocalizableMessage message = WARN_PLUGIN_PWIMPORT_NO_SUCH_POLICY.get( |
| | | String.valueOf(entry.getName()), String.valueOf(policyDN)); |
| | | logError(message); |
| | | logger.warn(WARN_PLUGIN_PWIMPORT_NO_SUCH_POLICY, String |
| | | .valueOf(entry.getName()), String.valueOf(policyDN)); |
| | | } |
| | | else if (authPolicy.isPasswordPolicy()) |
| | | { |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = WARN_PLUGIN_PWIMPORT_CANNOT_DECODE_POLICY_DN.get( |
| | | String.valueOf(entry.getName()), de.getMessageObject()); |
| | | logError(message); |
| | | logger.warn(WARN_PLUGIN_PWIMPORT_CANNOT_DECODE_POLICY_DN, String |
| | | .valueOf(entry.getName()), de.getMessageObject()); |
| | | break policyLoop; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD |
| | | .get(policy.getPasswordAttribute().getNameOrOID(), |
| | | String.valueOf(entry.getName()), |
| | | logger.error(ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD, |
| | | policy.getPasswordAttribute().getNameOrOID(), String |
| | | .valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | gotError = true; |
| | | break; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD |
| | | .get(policy.getPasswordAttribute().getNameOrOID(), |
| | | String.valueOf(entry.getName()), |
| | | logger.error(ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD, |
| | | policy.getPasswordAttribute().getNameOrOID(), String |
| | | .valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | gotError = true; |
| | | break; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD |
| | | .get(t.getNameOrOID(), String.valueOf(entry.getName()), |
| | | logger.error(ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD, t |
| | | .getNameOrOID(), String.valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | gotError = true; |
| | | break; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD |
| | | .get(t.getNameOrOID(), String.valueOf(entry.getName()), |
| | | logger.error(ERR_PLUGIN_PWPIMPORT_ERROR_ENCODING_PASSWORD, t |
| | | .getNameOrOID(), String.valueOf(entry.getName()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | gotError = true; |
| | | break; |
| | | } |
| | |
| | | import org.opends.server.types.operation.PostOperationDeleteOperation; |
| | | |
| | | import static org.opends.messages.PluginMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | /* This should never happen because the filter has already |
| | | * been verified. |
| | | */ |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | } |
| | | } |
| | | |
| | |
| | | break; |
| | | |
| | | case NO_SUCH_OBJECT: |
| | | logError(INFO_PLUGIN_REFERENT_SEARCH_NO_SUCH_OBJECT.get( |
| | | baseDN.toString())); |
| | | logger.debug(INFO_PLUGIN_REFERENT_SEARCH_NO_SUCH_OBJECT.get(baseDN.toString())); |
| | | return; |
| | | |
| | | default: |
| | | LocalizableMessage message1 = ERR_PLUGIN_REFERENT_SEARCH_FAILED. |
| | | get(String.valueOf(operation.getErrorMessage())); |
| | | logError(message1); |
| | | logger.error(message1); |
| | | return; |
| | | } |
| | | |
| | |
| | | conn.processModify(entryDN, mods); |
| | | if(modifyOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | logError(ERR_PLUGIN_REFERENT_MODIFY_FAILED.get(entryDN.toString(), |
| | | logger.error(ERR_PLUGIN_REFERENT_MODIFY_FAILED.get(entryDN.toString(), |
| | | String.valueOf(modifyOperation.getErrorMessage()))); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (IOException io) |
| | | { |
| | | logError(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (IOException io) |
| | | { |
| | | logError(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | } |
| | | } |
| | | } |
| | |
| | | } catch (DirectoryException ex) { |
| | | //This exception should rarely happen since the plugin wrote the DN |
| | | //strings originally. |
| | | LocalizableMessage message= |
| | | ERR_PLUGIN_REFERENT_CANNOT_DECODE_STRING_AS_DN. |
| | | get(ex.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_PLUGIN_REFERENT_CANNOT_DECODE_STRING_AS_DN, ex.getMessage()); |
| | | } |
| | | } |
| | | reader.close(); |
| | | logFile.delete(); |
| | | logFile.createNewFile(); |
| | | } catch (IOException io) { |
| | | logError(ERR_PLUGIN_REFERENT_REPLACE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_REPLACE_LOGFILE.get(io.getMessage())); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.PluginMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.server.util.StaticUtils.bytesToHexNoSpace; |
| | | import static org.opends.server.util.StaticUtils.toLowerCase; |
| | | |
| | |
| | | { |
| | | for (final LocalizableMessage m : messages) |
| | | { |
| | | logError(m); |
| | | logger.error(m); |
| | | } |
| | | throw new ConfigException(messages.poll()); |
| | | } |
| | |
| | | import org.opends.server.util.TimeThread; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import static org.opends.messages.PluginMessages.*; |
| | | |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PLUGIN_PROFILER_CANNOT_WRITE_PROFILE_DATA. |
| | | get(String.valueOf(configEntryDN), filename, |
| | | logger.error(ERR_PLUGIN_PROFILER_CANNOT_WRITE_PROFILE_DATA, String.valueOf(configEntryDN), filename, |
| | | stackTraceToSingleLineString(e)); |
| | | ErrorLogger.logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | import org.opends.server.util.TimeThread; |
| | | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | // The path specified as the LDIF directory exists, but isn't a |
| | | // directory. This is probably a mistake, and we should at least log |
| | | // a warning message. |
| | | logError(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_NOT_DIRECTORY.get( |
| | | ldifDirectory.getAbsolutePath(), |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_NOT_DIRECTORY.get(ldifDirectory.getAbsolutePath(), |
| | | configuration.dn().toString())); |
| | | } |
| | | } |
| | |
| | | { |
| | | // The path specified as the LDIF directory doesn't exist. We should log |
| | | // a warning message saying that we won't do anything until it's created. |
| | | logError(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_MISSING.get( |
| | | ldifDirectory.getAbsolutePath(), |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_MISSING.get(ldifDirectory.getAbsolutePath(), |
| | | configuration.dn().toString())); |
| | | } |
| | | |
| | |
| | | fullyProcessed = false; |
| | | LocalizableMessage m = ERR_LDIF_CONNHANDLER_IO_ERROR.get(inputPath, |
| | | getExceptionMessage(ioe)); |
| | | logError(m); |
| | | logger.error(m); |
| | | DirectoryConfig.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_CONNHANDLER_PARSE_ERROR, m); |
| | | } |
| | |
| | | |
| | | LocalizableMessage m = ERR_LDIF_CONNHANDLER_CANNOT_RENAME.get(inputPath, |
| | | renamedPath, getExceptionMessage(e)); |
| | | logError(m); |
| | | logger.error(m); |
| | | DirectoryConfig.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_CONNHANDLER_IO_ERROR, m); |
| | | } |
| | |
| | | |
| | | LocalizableMessage m = ERR_LDIF_CONNHANDLER_CANNOT_DELETE.get(inputPath, |
| | | getExceptionMessage(e)); |
| | | logError(m); |
| | | logger.error(m); |
| | | DirectoryConfig.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_CONNHANDLER_IO_ERROR, m); |
| | | } |
| | |
| | | INFO_CONNHANDLER_UNABLE_TO_REGISTER_CLIENT.get(ctx.clientConnection |
| | | .getClientHostPort(), ctx.clientConnection.getServerHostPort(), |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.debug(message); |
| | | |
| | | ctx.clientConnection.disconnect(DisconnectReason.SERVER_ERROR, false, |
| | | message); |
| | |
| | | // error + alert about the horked config |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | String.valueOf(currentConfig.dn()), getExceptionMessage(e))); |
| | | |
| | | if (lastIterationFailed) |
| | |
| | | ERR_CONNHANDLER_CONSECUTIVE_ACCEPT_FAILURES.get(friendlyName, |
| | | String.valueOf(currentConfig.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_HTTP_CONNECTION_HANDLER_CONSECUTIVE_FAILURES, message); |
| | |
| | | |
| | | if (HTTPAccessLogger.getHTTPAccessLogPublishers().isEmpty()) |
| | | { |
| | | logError(WARN_CONFIG_LOGGER_NO_ACTIVE_HTTP_ACCESS_LOGGERS.get()); |
| | | logger.warn(WARN_CONFIG_LOGGER_NO_ACTIVE_HTTP_ACCESS_LOGGERS.get()); |
| | | } |
| | | |
| | | this.httpServer = createHttpServer(); |
| | |
| | | logger.trace("Starting HTTP server..."); |
| | | this.httpServer.start(); |
| | | logger.trace("HTTP server started"); |
| | | logError(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | } |
| | | |
| | | private HttpServer createHttpServer() |
| | |
| | | this.httpServer.shutdownNow(); |
| | | cleanUpHttpServer(); |
| | | logger.trace("HTTP server stopped"); |
| | | logError(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | logError(ERR_INTERNAL_CANNOT_DECODE_DN.get( |
| | | fullDNString, getExceptionMessage(de))); |
| | | logger.error(ERR_INTERNAL_CANNOT_DECODE_DN.get(fullDNString, getExceptionMessage(de))); |
| | | } |
| | | |
| | | connectionID = nextConnectionID.getAndDecrement(); |
| | |
| | | package org.opends.server.protocols.jmx; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.net.InetSocketAddress; |
| | | import java.util.*; |
| | | import java.util.concurrent.CopyOnWriteArrayList; |
| | |
| | | ServerShutdownListener, |
| | | ConfigurationChangeListener<JMXConnectionHandlerCfg> { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * Key that may be placed into a JMX connection environment map to |
| | | * provide a custom {@code javax.net.ssl.TrustManager} array |
| | |
| | | config.getListenPort(), reasons)) |
| | | { |
| | | LocalizableMessage message = reasons.get(0); |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new InitializationException(message); |
| | | } |
| | | |
| | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.core.DirectoryServer.*; |
| | | import static org.opends.server.loggers.AccessLogger.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.protocols.ldap.LDAPConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | // This must mean that the operation has either not yet completed |
| | | // or that it completed without a result for some reason. In any |
| | | // case, log a message and set the response to "operations error". |
| | | logError(ERR_LDAP_CLIENT_SEND_RESPONSE_NO_RESULT_CODE.get( |
| | | operation.getOperationType().toString(), operation |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_NO_RESULT_CODE.get(operation.getOperationType().toString(), operation |
| | | .getConnectionID(), operation.getOperationID())); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | } |
| | |
| | | // If this an LDAPv2 client, then we can't send this. |
| | | if (ldapVersion == 2) |
| | | { |
| | | logError(ERR_LDAPV2_SKIPPING_EXTENDED_RESPONSE.get( |
| | | getConnectionID(), operation.getOperationID(), String |
| | | logger.error(ERR_LDAPV2_SKIPPING_EXTENDED_RESPONSE.get(getConnectionID(), operation.getOperationID(), String |
| | | .valueOf(operation))); |
| | | return null; |
| | | } |
| | |
| | | default: |
| | | // This must be a type of operation that doesn't have a response. |
| | | // This shouldn't happen, so log a message and return. |
| | | logError(ERR_LDAP_CLIENT_SEND_RESPONSE_INVALID_OP.get(String |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_INVALID_OP.get(String |
| | | .valueOf(operation.getOperationType()), getConnectionID(), |
| | | operation.getOperationID(), String.valueOf(operation))); |
| | | return null; |
| | |
| | | // any more referrals to this client for the rest of the operation. |
| | | if (ldapVersion == 2) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDAPV2_SKIPPING_SEARCH_REFERENCE.get(getConnectionID(), |
| | | logger.error(ERR_LDAPV2_SKIPPING_SEARCH_REFERENCE, getConnectionID(), |
| | | searchOperation.getOperationID(), String |
| | | .valueOf(searchReference)); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | |
| | |
| | | LocalizableMessage msg = |
| | | ERR_LDAPV2_EXTENDED_REQUEST_NOT_ALLOWED.get( |
| | | getConnectionID(), message.getMessageID()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | disconnect(DisconnectReason.PROTOCOL_ERROR, false, msg); |
| | | return false; |
| | | } |
| | |
| | | allowReuseAddress, config.dn()); |
| | | if (errorMessage != null) |
| | | { |
| | | logError(errorMessage); |
| | | logger.error(errorMessage); |
| | | throw new InitializationException(errorMessage); |
| | | } |
| | | |
| | |
| | | cleanUpSelector(); |
| | | listening = false; |
| | | |
| | | logError(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | } |
| | | |
| | | StaticUtils.sleep(1000); |
| | |
| | | // administrative action before trying again. |
| | | if (numRegistered == 0) |
| | | { |
| | | logError(ERR_LDAP_CONNHANDLER_NO_ACCEPTORS.get(String |
| | | logger.error(ERR_LDAP_CONNHANDLER_NO_ACCEPTORS.get(String |
| | | .valueOf(currentConfig.dn()))); |
| | | |
| | | enabled = false; |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | String.valueOf(currentConfig.dn()), getExceptionMessage(e))); |
| | | |
| | | if (lastIterationFailed) |
| | |
| | | // encountered a failure. Rather than enter a potential |
| | | // infinite loop of failures, disable this acceptor and |
| | | // log an error. |
| | | LocalizableMessage message = ERR_CONNHANDLER_CONSECUTIVE_ACCEPT_FAILURES |
| | | .get(friendlyName, String.valueOf(currentConfig.dn()), |
| | | LocalizableMessage message = |
| | | ERR_CONNHANDLER_CONSECUTIVE_ACCEPT_FAILURES.get(friendlyName, |
| | | String.valueOf(currentConfig.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_LDAP_CONNECTION_HANDLER_CONSECUTIVE_FAILURES, |
| | |
| | | // only thing we can do here is log a message, send an alert, |
| | | // and disable the selector until an administrator can figure |
| | | // out what's going on. |
| | | LocalizableMessage message = ERR_LDAP_CONNHANDLER_UNCAUGHT_ERROR |
| | | .get(String.valueOf(currentConfig.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_LDAP_CONNHANDLER_UNCAUGHT_ERROR.get(String |
| | | .valueOf(currentConfig.dn()), stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_LDAP_CONNECTION_HANDLER_UNCAUGHT_ERROR, message); |
| | |
| | | channel.register(selector, SelectionKey.OP_ACCEPT); |
| | | numRegistered++; |
| | | |
| | | logError(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_LDAP_CONNHANDLER_CREATE_CHANNEL_FAILED.get( |
| | | String.valueOf(currentConfig.dn()), a.getHostAddress(), |
| | | listenPort, stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_LDAP_CONNHANDLER_CREATE_CHANNEL_FAILED.get(String |
| | | .valueOf(currentConfig.dn()), a.getHostAddress(), listenPort, |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | } |
| | | return numRegistered; |
| | |
| | | INFO_CONNHANDLER_UNABLE_TO_REGISTER_CLIENT.get(clientConnection |
| | | .getClientHostPort(), clientConnection.getServerHostPort(), |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.debug(message); |
| | | |
| | | clientConnection.disconnect(DisconnectReason.SERVER_ERROR, |
| | | currentConfig.isSendRejectionNotice(), message); |
| | |
| | | import org.opends.server.api.DirectoryThread; |
| | | import org.opends.server.api.ServerShutdownListener; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.asn1.ASN1ByteChannelReader; |
| | | import org.opends.server.protocols.asn1.ASN1Exception; |
| | |
| | | |
| | | // This should not happen, and it would have caused our reader |
| | | // thread to die. Log a severe error. |
| | | LocalizableMessage message = ERR_LDAP_REQHANDLER_UNEXPECTED_SELECT_EXCEPTION. |
| | | get(getName(), getExceptionMessage(e)); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_LDAP_REQHANDLER_UNEXPECTED_SELECT_EXCEPTION, getName(), getExceptionMessage(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | |
| | | import java.util.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.replication.common.CSN; |
| | |
| | | import org.opends.server.util.TimeThread; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | * historical information is going to be kept. |
| | | * Log information for the repair tool. |
| | | */ |
| | | LocalizableMessage message = ERR_UNKNOWN_ATTRIBUTE_IN_HISTORICAL.get( |
| | | entry.getName().toNormalizedString(), |
| | | logger.error(ERR_UNKNOWN_ATTRIBUTE_IN_HISTORICAL, entry.getName().toNormalizedString(), |
| | | histVal.getAttrString()); |
| | | logError(message); |
| | | continue; |
| | | } |
| | | |
| | |
| | | // Any exception happening here means that the coding of the historical |
| | | // information was wrong. |
| | | // Log an error and continue with an empty historical. |
| | | LocalizableMessage message = ERR_BAD_HISTORICAL.get(entry.getName().toString()); |
| | | logError(message); |
| | | logger.error(ERR_BAD_HISTORICAL, entry.getName().toString()); |
| | | } |
| | | |
| | | /* set the reference to the historical information in the entry */ |
| | |
| | | { |
| | | // Replication server is missing some of our changes: let's |
| | | // send them to him. |
| | | logError(DEBUG_GOING_TO_SEARCH_FOR_CHANGES.get()); |
| | | logger.trace(DEBUG_GOING_TO_SEARCH_FOR_CHANGES.get()); |
| | | |
| | | /* |
| | | * Get all the changes that have not been seen by this |
| | |
| | | { |
| | | if (buildAndPublishMissingChanges(startCSN, broker, shutdown)) |
| | | { |
| | | logError(DEBUG_CHANGES_SENT.get()); |
| | | logger.trace(DEBUG_CHANGES_SENT.get()); |
| | | synchronized(replayOperations) |
| | | { |
| | | replayOperations.clear(); |
| | |
| | | * Log an error for the repair tool |
| | | * that will need to re-synchronize the servers. |
| | | */ |
| | | logError(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | } |
| | | } catch (Exception e) |
| | | { |
| | |
| | | * Log an error for the repair tool |
| | | * that will need to re-synchronize the servers. |
| | | */ |
| | | logError(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (DirectoryException e) |
| | | { |
| | | logError(ERR_LOADING_GENERATION_ID.get( |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | |
| | | // Should not happen as normally already called without problem in |
| | | // isConfigurationChangeAcceptable or isConfigurationAcceptable |
| | | // if we come up to this method |
| | | logError(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | return; |
| | | } |
| | |
| | | catch (ConfigException e) |
| | | { |
| | | // Should not happen |
| | | logError(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | return; |
| | | } |
| | |
| | | if (search.getResultCode() != ResultCode.SUCCESS |
| | | && search.getResultCode() != ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | logError(ERR_SEARCHING_GENERATION_ID.get( |
| | | logger.error(ERR_SEARCHING_GENERATION_ID.get( |
| | | search.getResultCode().getResultCodeName() + " " + |
| | | search.getErrorMessage(), |
| | | getBaseDNString())); |
| | |
| | | } |
| | | if (attr.size() > 1) |
| | | { |
| | | logError(ERR_LOADING_GENERATION_ID.get(getBaseDNString(), |
| | | logger.error(ERR_LOADING_GENERATION_ID.get(getBaseDNString(), |
| | | "#Values=" + attr.size() + " Must be exactly 1 in entry " |
| | | + resultEntry.toLDIFString())); |
| | | } |
| | |
| | | { |
| | | // Should not happen as configuration in domain root entry is flushed |
| | | // from valid configuration in local variables |
| | | logError(NOTE_ERR_FRACTIONAL.get( |
| | | logger.error(NOTE_ERR_FRACTIONAL.get( |
| | | fractionalConfig.getBaseDn().toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | return false; |
| | |
| | | // Should not happen as configuration in domain root entry is flushed |
| | | // from valid configuration in local variables so both should have already |
| | | // been checked |
| | | logError(NOTE_ERR_FRACTIONAL.get( |
| | | logger.error(NOTE_ERR_FRACTIONAL.get( |
| | | fractionalConfig.getBaseDn().toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | return false; |
| | |
| | | } |
| | | catch(DirectoryException e) |
| | | { |
| | | logError(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | return FRACTIONAL_HAS_NO_FRACTIONAL_FILTERED_ATTRIBUTES; |
| | | } |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logError(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | op.toString(), curCSN.toString())); |
| | | return; |
| | | } |
| | |
| | | * It should never happen. |
| | | */ |
| | | pendingChanges.remove(curCSN); |
| | | logError(ERR_UNKNOWN_TYPE.get(op.getOperationType().toString())); |
| | | logger.error(ERR_UNKNOWN_TYPE.get(op.getOperationType().toString())); |
| | | return; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logError(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | op.toString(), curCSN.toString())); |
| | | return; |
| | | } |
| | |
| | | } catch (TimeoutException ex) |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logError(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | Long.toString(getAssuredTimeout()), msg.toString())); |
| | | } |
| | | } |
| | |
| | | ResultCode res = newOp.getResultCode(); |
| | | if (res != ResultCode.SUCCESS) |
| | | { |
| | | logError(ERR_COULD_NOT_SOLVE_CONFLICT.get( |
| | | logger.error(ERR_COULD_NOT_SOLVE_CONFLICT.get( |
| | | entryDN.toString(), res.toString())); |
| | | } |
| | | } |
| | |
| | | // Let the repair tool know about this. |
| | | LocalizableMessage message = ERR_LOOP_REPLAYING_OPERATION.get(op.toString(), |
| | | op.getErrorMessage().toString()); |
| | | logError(message); |
| | | logger.error(message); |
| | | numUnresolvedNamingConflicts.incrementAndGet(); |
| | | replayErrorMsg = message.toString(); |
| | | updateError(csn); |
| | |
| | | * to be inconsistent. |
| | | * Let the repair tool know about this. |
| | | */ |
| | | LocalizableMessage message = ERR_EXCEPTION_REPLAYING_OPERATION.get( |
| | | LocalizableMessage message = |
| | | ERR_EXCEPTION_REPLAYING_OPERATION.get( |
| | | stackTraceToSingleLineString(e), op.toString()); |
| | | logError(message); |
| | | replayErrorMsg = message.toString(); |
| | | updateError(csn); |
| | | } else |
| | |
| | | |
| | | private String logDecodingOperationError(LDAPUpdateMsg msg, Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_EXCEPTION_DECODING_OPERATION.get( |
| | | String.valueOf(msg) + " " + stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_EXCEPTION_DECODING_OPERATION.get(String.valueOf(msg) + " " |
| | | + stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | return message.toString(); |
| | | } |
| | | |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logError(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | return true; |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logError(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | return true; |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logError(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | return true; |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // log a message for the repair tool. |
| | | logError(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | return true; |
| | |
| | | mb.append(String.valueOf(conflictOp)); |
| | | mb.append(" "); |
| | | mb.append(String.valueOf(op.getResultCode())); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | } catch (DirectoryException e) |
| | | { |
| | |
| | | mb.append(String.valueOf(conflictOp)); |
| | | mb.append(" "); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | |
| | | return conflict; |
| | |
| | | mb.append(String.valueOf(conflictOp)); |
| | | mb.append(" "); |
| | | mb.append(String.valueOf(newOp.getResultCode())); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | mb.append(String.valueOf(op)); |
| | | mb.append(" "); |
| | | mb.append(String.valueOf(newOp.getResultCode())); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | |
| | | // Generate an alert to let the administration know that some |
| | |
| | | * not available, log an error and retry upon timeout |
| | | * should we stop the modifications ? |
| | | */ |
| | | logError(ERR_LOADING_GENERATION_ID.get( |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | return; |
| | | } |
| | |
| | | |
| | | if (result != ResultCode.SUCCESS) |
| | | { |
| | | logError(ERR_UPDATING_GENERATION_ID.get( |
| | | logger.error(ERR_UPDATING_GENERATION_ID.get( |
| | | result.getResultCodeName(), getBaseDNString())); |
| | | } |
| | | } |
| | |
| | | { |
| | | if (search.getResultCode() != ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | logError(ERR_SEARCHING_GENERATION_ID.get( |
| | | logger.error(ERR_SEARCHING_GENERATION_ID.get( |
| | | search.getResultCode().getResultCodeName() + " " + |
| | | search.getErrorMessage(), |
| | | getBaseDNString())); |
| | |
| | | Attribute attr = attrs.get(0); |
| | | if (attr.size()>1) |
| | | { |
| | | logError(ERR_LOADING_GENERATION_ID.get( |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), "#Values=" + attr.size() + |
| | | " Must be exactly 1 in entry " + resultEntry.toLDIFString())); |
| | | } |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(ERR_LOADING_GENERATION_ID.get( |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), |
| | | String.valueOf(failureReason)); |
| | | logger.error(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | |
| | |
| | | if (ros == null || |
| | | ros.getNumExportedEntries() < entryCount) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(de.getMessageObject()); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(de.getMessageObject()); |
| | | logger.error(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(stackTraceToSingleLineString(e)); |
| | | logger.error(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | finally |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), |
| | | String.valueOf(failureReason)); |
| | | logger.warn(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), |
| | | stackTraceToSingleLineString(e)); |
| | | logger.warn(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_INIT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), |
| | | LocalizableMessage message = ERR_INIT_CANNOT_LOCK_BACKEND.get(backend.getBackendID(), |
| | | String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | } |
| | |
| | | // Release lock |
| | | if (!LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), |
| | | String.valueOf(failureReason)); |
| | | logger.warn(message); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | } |
| | | |
| | |
| | | catch(Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logError(ERR_CHECK_CREATE_REPL_BACKEND_FAILED.get( |
| | | logger.error(ERR_CHECK_CREATE_REPL_BACKEND_FAILED.get( |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logError(NOTE_ERR_UNABLE_TO_ENABLE_ECL.get( |
| | | logger.error(NOTE_ERR_UNABLE_TO_ENABLE_ECL.get( |
| | | "Replication Domain on " + getBaseDNString(), |
| | | stackTraceToSingleLineString(de))); |
| | | // and go on |
| | |
| | | // Go into bad data set status |
| | | setNewStatus(StatusMachineEvent.TO_BAD_GEN_ID_STATUS_EVENT); |
| | | broker.signalStatusChange(status); |
| | | logError(NOTE_FRACTIONAL_BAD_DATA_SET_NEED_RESYNC.get(getBaseDNString())); |
| | | logger.error(NOTE_FRACTIONAL_BAD_DATA_SET_NEED_RESYNC.get(getBaseDNString())); |
| | | return; // Do not send changes to the replication server |
| | | } |
| | | |
| | |
| | | } |
| | | } catch (Exception e) |
| | | { |
| | | logError(ERR_PUBLISHING_FAKE_OPS.get(getBaseDNString(), |
| | | logger.error(ERR_PUBLISHING_FAKE_OPS.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | } |
| | |
| | | if (!backend.supportsLDIFExport()) |
| | | { |
| | | LocalizableMessage msg = ERR_INIT_EXPORT_NOT_SUPPORTED.get(backend.getBackendID()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | throw new DirectoryException(ResultCode.OTHER, msg); |
| | | } |
| | | |
| | |
| | | mb.append(String.valueOf(newOp)); |
| | | mb.append(" "); |
| | | mb.append(String.valueOf(newOp.getResultCode())); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | else if (task != null) |
| | | { |
| | |
| | | package org.opends.server.replication.plugin; |
| | | |
| | | import java.util.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.concurrent.BlockingQueue; |
| | | import java.util.concurrent.ConcurrentHashMap; |
| | | import java.util.concurrent.LinkedBlockingQueue; |
| | |
| | | import org.opends.server.types.operation.*; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.plugin. |
| | | ReplicationRepairRequestControl.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | BackupTaskListener, RestoreTaskListener, ImportTaskListener, |
| | | ExportTaskListener |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private ReplicationServerListener replicationServerListener = null; |
| | | private static final Map<DN, LDAPReplicationDomain> domains = |
| | | new ConcurrentHashMap<DN, LDAPReplicationDomain>(4) ; |
| | |
| | | } |
| | | catch (ConfigException e) |
| | | { |
| | | logError(ERR_COULD_NOT_START_REPLICATION.get( |
| | | configuration.dn().toString(), e.getLocalizedMessage() |
| | | logger.error(ERR_COULD_NOT_START_REPLICATION.get(configuration.dn().toString(), e.getLocalizedMessage() |
| | | + " " + stackTraceToSingleLineString(e))); |
| | | } |
| | | return null; |
| | |
| | | package org.opends.server.replication.plugin; |
| | | |
| | | import java.util.ArrayList; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.LinkedHashSet; |
| | | import java.util.LinkedList; |
| | | import java.util.List; |
| | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * This class implements a ServerState that is stored in the backend |
| | |
| | | */ |
| | | public class PersistentServerState |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private final DN baseDn; |
| | | private final InternalClientConnection conn = |
| | | InternalClientConnection.getRootConnection(); |
| | |
| | | if (((search.getResultCode() != ResultCode.SUCCESS)) && |
| | | ((search.getResultCode() != ResultCode.NO_SUCH_OBJECT))) |
| | | { |
| | | LocalizableMessage message = ERR_ERROR_SEARCHING_RUV. |
| | | get(search.getResultCode().getResultCodeName(), search.toString(), |
| | | logger.error(ERR_ERROR_SEARCHING_RUV, search.getResultCode().getResultCodeName(), search.toString(), |
| | | search.getErrorMessage(), baseDn.toString()); |
| | | logError(message); |
| | | return null; |
| | | } |
| | | |
| | |
| | | op.run(); |
| | | if (op.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = DEBUG_ERROR_UPDATING_RUV.get( |
| | | op.getResultCode().getResultCodeName().toString(), |
| | | logger.trace(DEBUG_ERROR_UPDATING_RUV, op.getResultCode().getResultCodeName().toString(), |
| | | op.toString(), |
| | | op.getErrorMessage().toString(), |
| | | baseDn.toString()); |
| | | logError(message); |
| | | } |
| | | return op.getResultCode(); |
| | | } |
| | |
| | | { |
| | | // An error happened trying to search for the updates |
| | | // Log an error |
| | | message = ERR_CANNOT_RECOVER_CHANGES.get( |
| | | baseDn.toNormalizedString()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES, baseDn.toNormalizedString()); |
| | | } |
| | | else |
| | | { |
| | |
| | | // Update the serverState with the new maxCsn |
| | | // present in the database |
| | | this.update(dbMaxCsn); |
| | | message = NOTE_SERVER_STATE_RECOVERY.get( |
| | | baseDn.toNormalizedString(), dbMaxCsn.toString()); |
| | | logError(message); |
| | | logger.info(NOTE_SERVER_STATE_RECOVERY, baseDn.toNormalizedString(), dbMaxCsn.toString()); |
| | | } |
| | | } |
| | | } |
| | |
| | | package org.opends.server.replication.plugin; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | import java.util.concurrent.BlockingQueue; |
| | | import java.util.concurrent.TimeUnit; |
| | | import java.util.concurrent.atomic.AtomicBoolean; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.DirectoryThread; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.replication.protocol.LDAPUpdateMsg; |
| | |
| | | * catch all exceptions happening so that the thread never dies even |
| | | * in case of problems. |
| | | */ |
| | | LocalizableMessage message = ERR_EXCEPTION_REPLAYING_REPLICATION_MESSAGE.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_EXCEPTION_REPLAYING_REPLICATION_MESSAGE, stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | if (logger.isTraceEnabled()) |
| | |
| | | package org.opends.server.replication.protocol; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.net.Socket; |
| | | import java.util.SortedSet; |
| | | |
| | |
| | | import javax.net.ssl.SSLSocket; |
| | | import javax.net.ssl.SSLSocketFactory; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.types.CryptoManager; |
| | | import org.opends.server.types.DirectoryConfig; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | */ |
| | | public final class ReplSessionSecurity |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Whether replication sessions use SSL encryption. |
| | | */ |
| | |
| | | { |
| | | // This is probably a connection attempt from an unexpected client |
| | | // log that to warn the administrator. |
| | | final LocalizableMessage message = INFO_SSL_SERVER_CON_ATTEMPT_ERROR.get( |
| | | socket.getRemoteSocketAddress().toString(), |
| | | logger.debug(INFO_SSL_SERVER_CON_ATTEMPT_ERROR, socket.getRemoteSocketAddress().toString(), |
| | | socket.getLocalSocketAddress().toString(), |
| | | e.getLocalizedMessage()); |
| | | logError(message); |
| | | return null; |
| | | } |
| | | finally |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | |
| | | import org.opends.server.replication.protocol.*; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.common.ServerStatus.*; |
| | | import static org.opends.server.replication.common.StatusMachine.*; |
| | | import static org.opends.server.replication.protocol.ProtocolVersion.*; |
| | |
| | | */ |
| | | public class DataServerHandler extends ServerHandler |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Temporary generationId received in handshake/phase1, and used after |
| | | * handshake/phase2. |
| | |
| | | { |
| | | // Prevent useless error message (full update status cannot lead to bad |
| | | // gen status) |
| | | LocalizableMessage message = NOTE_BAD_GEN_ID_IN_FULL_UPDATE.get( |
| | | Integer.toString(replicationServer.getServerId()), |
| | | logger.info(NOTE_BAD_GEN_ID_IN_FULL_UPDATE, Integer.toString(replicationServer.getServerId()), |
| | | getBaseDNString(), |
| | | Integer.toString(serverId), |
| | | Long.toString(generationId), |
| | | Long.toString(newGenId)); |
| | | logError(message); |
| | | return; |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage msg = ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | Integer.toString(serverId), status.toString(), event.toString()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | // Only change allowed is from NORMAL_STATUS to DEGRADED_STATUS and vice |
| | | // versa. We may be trying to change the status while another status has |
| | | // just been entered: e.g a full update has just been engaged. |
| | |
| | | { |
| | | LocalizableMessage msg = ERR_RS_INVALID_NEW_STATUS.get(reqStatus.toString(), |
| | | getBaseDNString(), Integer.toString(serverId)); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | return ServerStatus.INVALID_STATUS; |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage msg = ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | Integer.toString(serverId), status.toString(), event.toString()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | return ServerStatus.INVALID_STATUS; |
| | | } |
| | | |
| | |
| | | |
| | | replicationServerDomain.register(this); |
| | | |
| | | LocalizableMessage message = INFO_REPLICATION_SERVER_CONNECTION_FROM_DS |
| | | .get(getReplicationServerId(), getServerId(), |
| | | logger.debug(INFO_REPLICATION_SERVER_CONNECTION_FROM_DS, getReplicationServerId(), getServerId(), |
| | | replicationServerDomain.getBaseDN().toNormalizedString(), |
| | | session.getReadableRemoteAddress()); |
| | | logError(message); |
| | | |
| | | super.finalizeStart(); |
| | | } |
| | |
| | | { |
| | | if (generationId != localGenerationId) |
| | | { |
| | | LocalizableMessage message = WARN_BAD_GENERATION_ID_FROM_DS.get( |
| | | serverId, session.getReadableRemoteAddress(), |
| | | logger.warn(WARN_BAD_GENERATION_ID_FROM_DS, serverId, session.getReadableRemoteAddress(), |
| | | generationId, getBaseDNString(), |
| | | getReplicationServerId(), localGenerationId); |
| | | logError(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | // If the LDAP server has already sent changes |
| | | // it is not expected to connect to an empty RS |
| | | LocalizableMessage message = WARN_BAD_GENERATION_ID_FROM_DS.get( |
| | | serverId, session.getReadableRemoteAddress(), |
| | | logger.warn(WARN_BAD_GENERATION_ID_FROM_DS, serverId, session.getReadableRemoteAddress(), |
| | | generationId, getBaseDNString(), |
| | | getReplicationServerId(), localGenerationId); |
| | | logError(message); |
| | | } |
| | | else |
| | | { |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.*; |
| | | import java.util.concurrent.Semaphore; |
| | | import java.util.concurrent.TimeUnit; |
| | |
| | | import org.opends.server.util.ServerConstants; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.protocol.ProtocolVersion.*; |
| | | import static org.opends.server.replication.protocol.StartECLSessionMsg |
| | | .ECLRequestType.*; |
| | |
| | | public final class ECLServerHandler extends ServerHandler |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * Marks the end of the search on the External Change Log. |
| | | */ |
| | |
| | | releaseCursor(); |
| | | for (DomainContext domainCtxt : domainCtxts) { |
| | | if (!domainCtxt.unRegisterHandler()) { |
| | | logError(LocalizableMessage.raw( this + " shutdown() - error when unregistering handler " |
| | | logger.error(LocalizableMessage.raw( this + " shutdown() - error when unregistering handler " |
| | | + domainCtxt.mh)); |
| | | } |
| | | domainCtxt.stopServer(); |
| | |
| | | import org.opends.server.workflowelement.externalchangelog.ECLWorkflowElement; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | // session is always null if a socket exception has occurred. |
| | | if (session != null) |
| | | { |
| | | logError(handler.getBadlyDisconnectedErrorMessage()); |
| | | logger.error(handler.getBadlyDisconnectedErrorMessage()); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | // An unexpected error happened. |
| | | // Log an error and close the connection. |
| | | logError(ERR_WRITER_UNEXPECTED_EXCEPTION.get( |
| | | handler + " " + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION.get(handler + " " + stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(ERR_WRITER_UNEXPECTED_EXCEPTION.get( |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION.get( |
| | | handler + " " + stackTraceToSingleLineString(e))); |
| | | mypsearch.cancel(); |
| | | } |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.util.NavigableMap; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.TreeMap; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | |
| | | import org.opends.server.replication.protocol.UpdateMsg; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * This class is used to build ordered lists of UpdateMsg. |
| | |
| | | */ |
| | | public class MsgQueue |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private NavigableMap<CSN, UpdateMsg> map = new TreeMap<CSN, UpdateMsg>(); |
| | | private final Object lock = new Object(); |
| | | |
| | |
| | | LocalizableMessage errMsg = ERR_RSQUEUE_DIFFERENT_MSGS_WITH_SAME_CN.get( |
| | | msgSameCSN.getCSN().toString(), |
| | | msgSameCSN.toString(), update.toString()); |
| | | logError(errMsg); |
| | | logger.error(errMsg); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | |
| | | { |
| | | // should never happen |
| | | LocalizableMessage msg = ERR_BYTE_COUNT.get(Integer.toString(bytesCount)); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | bytesCount = 0; |
| | | } |
| | | return update; |
| | |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.types.FilterType.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | rate = 1000f*exportedCount / totalTime; |
| | | } |
| | | |
| | | LocalizableMessage message = NOTE_JEB_EXPORT_FINAL_STATUS.get( |
| | | exportedCount, skippedCount, totalTime/1000, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_EXPORT_FINAL_STATUS, exportedCount, skippedCount, totalTime/1000, rate); |
| | | } |
| | | |
| | | private List<ReplicationServerDomain> selectReplicationDomains( |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logError(ERR_BACKEND_EXPORT_ENTRY.get(dnString, String.valueOf(e))); |
| | | logger.error(ERR_BACKEND_EXPORT_ENTRY.get(dnString, String.valueOf(e))); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | message = ERR_BACKEND_SEARCH_ENTRY.get(dnStr, e.getLocalizedMessage()); |
| | | } |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | float rate = 1000f*deltaCount / deltaTime; |
| | | |
| | | LocalizableMessage message = |
| | | NOTE_JEB_EXPORT_PROGRESS_REPORT.get(latestCount, skippedCount, rate); |
| | | logError(message); |
| | | logger.info(NOTE_JEB_EXPORT_PROGRESS_REPORT, latestCount, skippedCount, rate); |
| | | |
| | | previousCount = latestCount; |
| | | previousTime = latestTime; |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.HashSet; |
| | | import java.util.Set; |
| | | import java.util.concurrent.CountDownLatch; |
| | | import java.util.concurrent.TimeUnit; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.replication.common.CSN; |
| | | import org.opends.server.replication.common.ServerState; |
| | | import org.opends.server.replication.protocol.MonitorMsg; |
| | |
| | | import org.opends.server.util.TimeThread; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | class ReplicationDomainMonitor |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * The monitor data consolidated over the topology. |
| | | */ |
| | |
| | | catch (IOException e) |
| | | { |
| | | // Log a message and do a best effort from here. |
| | | LocalizableMessage message = ERR_SENDING_REMOTE_MONITOR_DATA_REQUEST.get( |
| | | baseDN, serverId, e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_SENDING_REMOTE_MONITOR_DATA_REQUEST, baseDN, serverId, e.getMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | // error log with repeated messages. |
| | | if (!pendingMonitorDataServerIDs.contains(serverId)) |
| | | { |
| | | logError(NOTE_MONITOR_DATA_RECEIVED.get(baseDN, serverId)); |
| | | logger.info(NOTE_MONITOR_DATA_RECEIVED.get(baseDN, serverId)); |
| | | } |
| | | } |
| | | |
| | |
| | | // error log with repeated messages. |
| | | if (!monitorDataLateServers.contains(serverId)) |
| | | { |
| | | logError(WARN_MISSING_REMOTE_MONITOR_DATA.get( |
| | | baseDN, serverId)); |
| | | logger.warn(WARN_MISSING_REMOTE_MONITOR_DATA.get(baseDN, serverId)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | // This is a response for an earlier request whose computing is |
| | | // already complete. |
| | | logError(INFO_IGNORING_REMOTE_MONITOR_DATA.get( |
| | | domain.getBaseDN().toNormalizedString(), msg.getSenderID())); |
| | | logger.debug(INFO_IGNORING_REMOTE_MONITOR_DATA.get(domain.getBaseDN().toNormalizedString(), msg.getSenderID())); |
| | | return; |
| | | } |
| | | |
| | |
| | | catch (RuntimeException e) |
| | | { |
| | | // FIXME: do we really expect these??? |
| | | logError(ERR_PROCESSING_REMOTE_MONITOR_DATA.get(e.getMessage() + " " |
| | | logger.error(ERR_PROCESSING_REMOTE_MONITOR_DATA.get(e.getMessage() + " " |
| | | + stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | |
| | | import org.opends.server.workflowelement.externalchangelog.ECLWorkflowElement; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | getServerId(), |
| | | listenSocket.getInetAddress().getHostAddress(), |
| | | listenSocket.getLocalPort()); |
| | | logError(listenMsg); |
| | | logger.error(listenMsg); |
| | | |
| | | while (!shutdown && !stopListen) |
| | | { |
| | |
| | | // Do not log the message during shutdown. |
| | | logger.traceException(e); |
| | | if (!shutdown) { |
| | | LocalizableMessage message = |
| | | ERR_EXCEPTION_LISTENING.get(e.getLocalizedMessage()); |
| | | logError(message); |
| | | logger.error(ERR_EXCEPTION_LISTENING, e.getLocalizedMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | " successfully initialized"); |
| | | } catch (UnknownHostException e) |
| | | { |
| | | logError(ERR_UNKNOWN_HOSTNAME.get()); |
| | | logger.error(ERR_UNKNOWN_HOSTNAME.get()); |
| | | } catch (IOException e) |
| | | { |
| | | LocalizableMessage message = ERR_COULD_NOT_BIND_CHANGELOG.get( |
| | | getReplicationPort(), e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_COULD_NOT_BIND_CHANGELOG, getReplicationPort(), e.getMessage()); |
| | | } catch (DirectoryException e) |
| | | { |
| | | //FIXME:DirectoryException is raised by initializeECL => fix err msg |
| | |
| | | LocalizableMessage |
| | | .raw("Directory Exception raised by ECL initialization: " |
| | | + e.getMessage()); |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | if (logger.isTraceEnabled()) |
| | | logger.traceException(e); |
| | | logError(ERR_COULD_NOT_CLOSE_THE_SOCKET.get(e.toString())); |
| | | logger.error(ERR_COULD_NOT_CLOSE_THE_SOCKET.get(e.toString())); |
| | | } |
| | | catch (InterruptedException e) |
| | | { |
| | | if (logger.isTraceEnabled()) |
| | | logger.traceException(e); |
| | | logError(ERR_COULD_NOT_STOP_LISTEN_THREAD.get(e.toString())); |
| | | logger.error(ERR_COULD_NOT_STOP_LISTEN_THREAD.get(e.toString())); |
| | | } |
| | | } |
| | | |
| | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(e.getLocalizedMessage()); |
| | | LocalizableMessage msg = ERR_DELETE_REPL_BACKEND_FAILED.get(mb.toString()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | } |
| | | |
| | |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | assuredMode.toString(), baseDN.toNormalizedString(), |
| | | update.toString()); |
| | | logError(errorMsg); |
| | | logger.error(errorMsg); |
| | | assuredMessage = false; |
| | | } |
| | | } else |
| | |
| | | * job properly anymore and needs to close all its connections and |
| | | * shutdown itself. |
| | | */ |
| | | logError(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | .get(stackTraceToSingleLineString(e))); |
| | | localReplicationServer.shutdown(); |
| | | return false; |
| | |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | Byte.toString(safeDataLevel), baseDN.toNormalizedString(), |
| | | update.toString()); |
| | | logError(errorMsg); |
| | | logger.error(errorMsg); |
| | | } else if (sourceGroupId == groupId |
| | | // Assured feature does not cross different group IDS |
| | | && isSameGenerationId(sourceHandler.getGenerationId())) |
| | |
| | | csn.toString(), baseDN.toNormalizedString())); |
| | | mb.append(" "); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | stopServer(origServer, false); |
| | | } |
| | | // Mark the ack info object as completed to prevent potential timeout |
| | |
| | | csn.toString(), baseDN.toNormalizedString())); |
| | | mb.append(" "); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | stopServer(origServer, false); |
| | | } |
| | | // Increment assured counters |
| | |
| | | if (connectedDSs.containsKey(dsHandler.getServerId())) |
| | | { |
| | | // looks like two connected LDAP servers have the same serverId |
| | | LocalizableMessage message = ERR_DUPLICATE_SERVER_ID.get( |
| | | localReplicationServer.getMonitorInstanceName(), |
| | | logger.error(ERR_DUPLICATE_SERVER_ID, localReplicationServer.getMonitorInstanceName(), |
| | | connectedDSs.get(dsHandler.getServerId()).toString(), |
| | | dsHandler.toString(), dsHandler.getServerId()); |
| | | logError(message); |
| | | return true; |
| | | } |
| | | return false; |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | if (msg instanceof ErrorMsg) |
| | | { |
| | | ErrorMsg errorMsg = (ErrorMsg) msg; |
| | | logError(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | } else if (msg instanceof MonitorRequestMsg) |
| | | { |
| | | replyWithTopologyMonitorMsg(msg, msgEmitter); |
| | |
| | | { |
| | | // We log the error. The requestor will detect a timeout or |
| | | // any other failure on the connection. |
| | | logError(ERR_CHANGELOG_ERROR_SENDING_MSG.get(Integer.toString(msg |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG.get(Integer.toString(msg |
| | | .getDestination()))); |
| | | } |
| | | } |
| | |
| | | RoutableMsg msg) |
| | | { |
| | | String msgClassname = msg.getClass().getCanonicalName(); |
| | | logError(NOTE_ERR_ROUTING_TO_SERVER.get(msgClassname)); |
| | | logger.info(NOTE_ERR_ROUTING_TO_SERVER.get(msgClassname)); |
| | | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(NOTE_ERR_ROUTING_TO_SERVER.get(msgClassname)); |
| | |
| | | mb.append(" unroutable message =").append(msg.getClass().getSimpleName()); |
| | | mb.append(" Details:routing table is empty"); |
| | | final LocalizableMessage message = mb.toMessage(); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | ErrorMsg errMsg = new ErrorMsg(this.localReplicationServer.getServerId(), |
| | | msg.getSenderID(), message); |
| | |
| | | mb2.append(ERR_CHANGELOG_ERROR_SENDING_ERROR.get(this.toString())); |
| | | mb2.append(" "); |
| | | mb2.append(stackTraceToSingleLineString(ignored)); |
| | | logError(mb2.toMessage()); |
| | | logger.error(mb2.toMessage()); |
| | | stopServer(msgEmitter, false); |
| | | } |
| | | } |
| | |
| | | mb.append(" unroutable message =" + msg.getClass().getSimpleName()); |
| | | mb.append(" Details: " + ioe.getLocalizedMessage()); |
| | | final LocalizableMessage message = mb.toMessage(); |
| | | logError(message); |
| | | logger.error(message); |
| | | |
| | | ErrorMsg errMsg = new ErrorMsg(msg.getSenderID(), message); |
| | | try |
| | |
| | | { |
| | | if (i == 2) |
| | | { |
| | | LocalizableMessage message = ERR_EXCEPTION_SENDING_TOPO_INFO.get( |
| | | baseDN.toNormalizedString(), "directory", |
| | | logger.error(ERR_EXCEPTION_SENDING_TOPO_INFO, baseDN.toNormalizedString(), "directory", |
| | | Integer.toString(dsHandler.getServerId()), e.getMessage()); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | if (i == 2) |
| | | { |
| | | LocalizableMessage message = ERR_EXCEPTION_SENDING_TOPO_INFO.get( |
| | | baseDN.toNormalizedString(), "replication", |
| | | logger.error(ERR_EXCEPTION_SENDING_TOPO_INFO, baseDN.toNormalizedString(), "replication", |
| | | Integer.toString(rsHandler.getServerId()), e.getMessage()); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | } catch (IOException e) |
| | | { |
| | | logError(ERR_EXCEPTION_FORWARDING_RESET_GEN_ID.get( |
| | | baseDN.toNormalizedString(), e.getMessage())); |
| | | logger.error(ERR_EXCEPTION_FORWARDING_RESET_GEN_ID.get(baseDN.toNormalizedString(), e.getMessage())); |
| | | } |
| | | } |
| | | |
| | |
| | | dsHandler.changeStatusForResetGenId(newGenId); |
| | | } catch (IOException e) |
| | | { |
| | | logError(ERR_EXCEPTION_CHANGING_STATUS_AFTER_RESET_GEN_ID.get( |
| | | baseDN.toNormalizedString(), |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_AFTER_RESET_GEN_ID.get(baseDN.toNormalizedString(), |
| | | Integer.toString(dsHandler.getServerId()), |
| | | e.getMessage())); |
| | | } |
| | |
| | | // treatment. |
| | | sendTopoInfoToAll(); |
| | | |
| | | logError(NOTE_RESET_GENERATION_ID.get(baseDN.toNormalizedString(), |
| | | logger.info(NOTE_RESET_GENERATION_ID.get(baseDN.toNormalizedString(), |
| | | newGenId)); |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | |
| | | sendTopoInfoToAllExcept(senderHandler); |
| | | |
| | | LocalizableMessage message = NOTE_DIRECTORY_SERVER_CHANGED_STATUS.get( |
| | | senderHandler.getServerId(), baseDN.toNormalizedString(), |
| | | logger.info(NOTE_DIRECTORY_SERVER_CHANGED_STATUS, senderHandler.getServerId(), baseDN.toNormalizedString(), |
| | | newStatus.toString()); |
| | | logError(message); |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (IOException e) |
| | | { |
| | | logError(ERR_EXCEPTION_CHANGING_STATUS_FROM_STATUS_ANALYZER |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_FROM_STATUS_ANALYZER |
| | | .get(baseDN.toNormalizedString(), |
| | | Integer.toString(dsHandler.getServerId()), |
| | | e.getMessage())); |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(ERR_ERROR_CLEARING_DB.get(baseDN.toString(), e.getMessage() |
| | | + " " + stackTraceToSingleLineString(e))); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (isDifferentGenerationId(rsHandler.getGenerationId())) |
| | | { |
| | | LocalizableMessage message = WARN_BAD_GENERATION_ID_FROM_RS.get( |
| | | rsHandler.getServerId(), |
| | | rsHandler.session.getReadableRemoteAddress(), |
| | | rsHandler.getGenerationId(), |
| | | baseDN.toNormalizedString(), getLocalRSServerId(), generationId); |
| | | logError(message); |
| | | LocalizableMessage message = |
| | | WARN_BAD_GENERATION_ID_FROM_RS.get(rsHandler.getServerId(), |
| | | rsHandler.session.getReadableRemoteAddress(), rsHandler |
| | | .getGenerationId(), baseDN.toNormalizedString(), |
| | | getLocalRSServerId(), generationId); |
| | | logger.warn(message); |
| | | |
| | | ErrorMsg errorMsg = new ErrorMsg(getLocalRSServerId(), |
| | | rsHandler.getServerId(), message); |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | catch (IOException e) |
| | | { |
| | | logger.traceException(e); |
| | | logError(ERR_CHANGELOG_ERROR_SENDING_MSG |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG |
| | | .get("Replication Server " |
| | | + localReplicationServer.getReplicationPort() + " " |
| | | + baseDN + " " + localReplicationServer.getServerId())); |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.List; |
| | | import java.util.Map; |
| | | import java.util.Set; |
| | |
| | | import org.opends.server.replication.protocol.*; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.protocol.ProtocolVersion.*; |
| | | |
| | | /** |
| | |
| | | public class ReplicationServerHandler extends ServerHandler |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * Properties filled only if remote server is a RS. |
| | | */ |
| | |
| | | replicationServerDomain.receiveTopoInfoFromRS(inTopoMsg, this, false); |
| | | } |
| | | |
| | | LocalizableMessage message = INFO_REPLICATION_SERVER_CONNECTION_TO_RS |
| | | .get(getReplicationServerId(), getServerId(), |
| | | logger.debug(INFO_REPLICATION_SERVER_CONNECTION_TO_RS, getReplicationServerId(), getServerId(), |
| | | replicationServerDomain.getBaseDN().toNormalizedString(), |
| | | session.getReadableRemoteAddress()); |
| | | logError(message); |
| | | |
| | | super.finalizeStart(); |
| | | } |
| | |
| | | if (inTopoMsg!=null) |
| | | replicationServerDomain.receiveTopoInfoFromRS(inTopoMsg, this, false); |
| | | |
| | | LocalizableMessage message = INFO_REPLICATION_SERVER_CONNECTION_FROM_RS |
| | | .get(getReplicationServerId(), getServerId(), |
| | | logger.debug(INFO_REPLICATION_SERVER_CONNECTION_FROM_RS, getReplicationServerId(), getServerId(), |
| | | replicationServerDomain.getBaseDN().toNormalizedString(), |
| | | session.getReadableRemoteAddress()); |
| | | logError(message); |
| | | |
| | | super.finalizeStart(); |
| | | } |
| | |
| | | * and we have a null state ? |
| | | * replicationServerDomain.setGenerationId(generationId, false); |
| | | */ |
| | | LocalizableMessage message = WARN_BAD_GENERATION_ID_FROM_RS.get( |
| | | serverId, session.getReadableRemoteAddress(), generationId, |
| | | logger.warn(WARN_BAD_GENERATION_ID_FROM_RS, serverId, session.getReadableRemoteAddress(), generationId, |
| | | getBaseDNString(), getReplicationServerId(), localGenerationId); |
| | | logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | package org.opends.server.replication.server; |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.List; |
| | | import java.util.Random; |
| | | import java.util.concurrent.Semaphore; |
| | |
| | | import org.opends.server.replication.protocol.*; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * This class defines a server handler : |
| | |
| | | */ |
| | | public abstract class ServerHandler extends MessageHandler |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Time during which the server will wait for existing thread to stop |
| | | * during the shutdownWriter. |
| | |
| | | logger.trace("In " + |
| | | ((handler != null) ? handler.toString() : "Replication Server") + |
| | | " closing session with err=" + providedMsg); |
| | | logError(providedMsg); |
| | | logger.error(providedMsg); |
| | | } |
| | | |
| | | if (providedSession != null) |
| | |
| | | import org.opends.server.replication.protocol.*; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.common.ServerStatus.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | long referenceGenerationId = handler.getReferenceGenId(); |
| | | if (dsStatus == BAD_GEN_ID_STATUS) |
| | | logError(WARN_IGNORING_UPDATE_FROM_DS_BADGENID.get( |
| | | handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | if (dsStatus == FULL_UPDATE_STATUS) |
| | | logError(WARN_IGNORING_UPDATE_FROM_DS_FULLUP.get( |
| | | handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | |
| | | if (referenceGenerationId > 0 |
| | | && referenceGenerationId != handler.getGenerationId()) |
| | | { |
| | | logError( |
| | | logger.error( |
| | | WARN_IGNORING_UPDATE_FROM_RS.get( |
| | | handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | |
| | | handler.getBaseDNString(), |
| | | Integer.toString(handler.getServerId()), |
| | | csMsg.toString()); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | } |
| | | } else if (msg instanceof ChangeTimeHeartbeatMsg) |
| | | { |
| | |
| | | * connection. |
| | | */ |
| | | errMessage = NOTE_READER_NULL_MSG.get(handler.toString()); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | return; |
| | | } |
| | | } catch (NotSupportedOldVersionPDUException e) |
| | |
| | | if (!handler.shuttingDown()) |
| | | { |
| | | errMessage = handler.getBadlyDisconnectedErrorMessage(); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | */ |
| | | errMessage = NOTE_READER_EXCEPTION.get( |
| | | handler.toString(), stackTraceToSingleLineString(e)); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | } |
| | | finally |
| | | { |
| | |
| | | import org.opends.server.replication.protocol.UpdateMsg; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | { |
| | | if (dsStatus == ServerStatus.BAD_GEN_ID_STATUS) |
| | | { |
| | | logError(WARN_IGNORING_UPDATE_TO_DS_BADGENID.get( |
| | | handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | |
| | | } |
| | | else if (dsStatus == ServerStatus.FULL_UPDATE_STATUS) |
| | | { |
| | | logError(WARN_IGNORING_UPDATE_TO_DS_FULLUP.get( |
| | | handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | |
| | | || referenceGenerationId == -1 |
| | | || handler.getGenerationId() == -1) |
| | | { |
| | | logError( |
| | | logger.error( |
| | | WARN_IGNORING_UPDATE_TO_RS.get( |
| | | handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | |
| | | * be removed, just ignore the exception and let the thread die as well |
| | | */ |
| | | errMessage = handler.getBadlyDisconnectedErrorMessage(); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | |
| | | */ |
| | | errMessage = ERR_WRITER_UNEXPECTED_EXCEPTION.get(handler + |
| | | " " + stackTraceToSingleLineString(e)); |
| | | logError(errMessage); |
| | | logger.error(errMessage); |
| | | } |
| | | finally { |
| | | session.close(); |
| | |
| | | import static com.sleepycat.je.OperationStatus.*; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logError(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(ERR_ERROR_CLEARING_DB.get(toString(), |
| | | e.getMessage() + " " + stackTraceToSingleLineString(e))); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | finally |
| | | { |
| | |
| | | import org.opends.server.replication.server.changelog.je.DraftCNDB.*; |
| | | import org.opends.server.types.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | } |
| | | catch (Exception end) |
| | | { |
| | | logError(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH |
| | | logger.error(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH |
| | | .get(stackTraceToSingleLineString(end))); |
| | | if (replicationServer != null) |
| | | { |
| | |
| | | import com.forgerock.opendj.util.Pair; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | if (logger.isTraceEnabled()) |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_COULD_NOT_READ_DB.get(this.dbDirectory.getAbsolutePath(), |
| | | logger.error(ERR_COULD_NOT_READ_DB.get(this.dbDirectory.getAbsolutePath(), |
| | | e.getLocalizedMessage())); |
| | | } |
| | | } |
| | |
| | | { |
| | | if (logger.isTraceEnabled()) |
| | | logger.traceException(e); |
| | | logError(ERR_CHANGENUMBER_DATABASE.get(e.getLocalizedMessage())); |
| | | logger.error(ERR_CHANGENUMBER_DATABASE.get(e.getLocalizedMessage())); |
| | | } |
| | | } |
| | | return cnIndexDB; |
| | |
| | | * |
| | | * |
| | | * Copyright 2006-2010 Sun Microsystems, Inc. |
| | | * Portions copyright 2011-2013 ForgeRock AS |
| | | * Portions copyright 2011-2014 ForgeRock AS |
| | | */ |
| | | package org.opends.server.replication.server.changelog.je; |
| | | |
| | | import java.util.ArrayList; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.Date; |
| | | import java.util.LinkedList; |
| | | import java.util.List; |
| | |
| | | * It is responsible for efficiently saving the updates that is received from |
| | | * each master server into stable storage. |
| | | * <p> |
| | | * This class is also able to generate a {@link DBCursor} that can be used to |
| | | * This class is also able to generate a { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | @link DBCursor} that can be used to |
| | | * read all changes from a given {@link CSN}. |
| | | * <p> |
| | | * This class publish some monitoring information below cn=monitor. |
| | | */ |
| | | public class JEReplicaDB implements Runnable |
| | | { |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The msgQueue holds all the updates not yet saved to stable storage. |
| | | * <p> |
| | |
| | | catch (ChangelogException e) |
| | | { |
| | | // We are already shutting down |
| | | logError(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH |
| | | .get(stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH, stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | private void stop(Exception e) |
| | | { |
| | | logError(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH |
| | | .get(stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH, stackTraceToSingleLineString(e)); |
| | | |
| | | thread.initiateShutdown(); |
| | | |
| | |
| | | package org.opends.server.replication.server.changelog.je; |
| | | |
| | | import java.io.Closeable; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.io.UnsupportedEncodingException; |
| | | import java.util.List; |
| | | import java.util.concurrent.locks.ReadWriteLock; |
| | | import java.util.concurrent.locks.ReentrantReadWriteLock; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import org.opends.server.replication.common.CSN; |
| | | import org.opends.server.replication.protocol.UpdateMsg; |
| | |
| | | import static com.sleepycat.je.OperationStatus.*; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | public class ReplicationDB |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | private Database db; |
| | | private ReplicationDbEnv dbenv; |
| | | private ReplicationServer replicationServer; |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logError(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | |
| | | * changes. |
| | | * TODO : This should be handled by the repair functionality. |
| | | */ |
| | | LocalizableMessage message = ERR_REPLICATIONDB_CANNOT_PROCESS_CHANGE_RECORD |
| | | .get(replicationServer.getServerId(), |
| | | logger.error(ERR_REPLICATIONDB_CANNOT_PROCESS_CHANGE_RECORD, replicationServer.getServerId(), |
| | | (csn == null ? "" : csn.toString()), |
| | | e.getMessage()); |
| | | logError(message); |
| | | } |
| | | } |
| | | return currentChange; |
| | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(ERR_ERROR_CLEARING_DB.get(toString(), |
| | | e.getMessage() + " " + stackTraceToSingleLineString(e))); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | finally |
| | | { |
| | |
| | | |
| | | import static org.opends.messages.JebMessages.*; |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | | /** |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logError(closeDBErrorMessage(null, e)); |
| | | logger.error(closeDBErrorMessage(null, e)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logError(closeDBErrorMessage(db.getDatabaseName(), e)); |
| | | logger.error(closeDBErrorMessage(db.getDatabaseName(), e)); |
| | | } |
| | | } |
| | | |
| | |
| | | mb.append(ERR_ERROR_CLEARING_DB.get(databaseName, |
| | | e.getMessage() + " " + |
| | | stackTraceToSingleLineString(e))); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | finally |
| | | { |
| | |
| | | */ |
| | | void shutdownOnException(DatabaseException e) |
| | | { |
| | | logError(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | .get(stackTraceToSingleLineString(e))); |
| | | replicationServer.shutdown(); |
| | | } |
| | |
| | | package org.opends.server.replication.service; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.replication.protocol.Session; |
| | | |
| | |
| | | if (gotOneFailure) |
| | | { |
| | | // Heartbeat is well overdue so the server is assumed to be dead. |
| | | logError(WARN_HEARTBEAT_FAILURE.get(serverID, |
| | | logger.warn(WARN_HEARTBEAT_FAILURE.get(serverID, |
| | | replicationServerID, session.getReadableRemoteAddress(), |
| | | baseDN)); |
| | | |
| | |
| | | import org.opends.server.util.ServerConstants; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.protocol.ProtocolVersion.*; |
| | | import static org.opends.server.replication.server.ReplicationServer.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | final int rsServerId = rs.rsInfo.getServerId(); |
| | | if (rsGenId == getGenerationID() || rsGenId == -1) |
| | | { |
| | | logError(NOTE_NOW_FOUND_SAME_GENERATION_CHANGELOG.get( |
| | | serverId, rsServerId, baseDN.toNormalizedString(), |
| | | logger.info(NOTE_NOW_FOUND_SAME_GENERATION_CHANGELOG.get(serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID())); |
| | | } |
| | | else |
| | | { |
| | | logError(WARN_NOW_FOUND_BAD_GENERATION_CHANGELOG.get( |
| | | serverId, rsServerId, baseDN.toNormalizedString(), |
| | | logger.warn(WARN_NOW_FOUND_BAD_GENERATION_CHANGELOG.get(serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID(), rsGenId)); |
| | | } |
| | | } |
| | |
| | | |
| | | if (replicationServerInfos.size() > 0) |
| | | { |
| | | logError(WARN_COULD_NOT_FIND_CHANGELOG.get( |
| | | serverId, baseDN.toNormalizedString(), |
| | | collectionToString(replicationServerInfos.keySet(), ", "))); |
| | | logger.warn(WARN_COULD_NOT_FIND_CHANGELOG.get(serverId, baseDN |
| | | .toNormalizedString(), collectionToString( |
| | | replicationServerInfos.keySet(), ", "))); |
| | | } |
| | | else |
| | | { |
| | | logError(WARN_NO_AVAILABLE_CHANGELOGS.get( |
| | | serverId, baseDN.toNormalizedString())); |
| | | logger.warn(WARN_NO_AVAILABLE_CHANGELOGS.get(serverId, baseDN.toNormalizedString())); |
| | | } |
| | | } |
| | | } |
| | |
| | | warn user and start heartbeat monitor to recover when a server |
| | | with the right group id shows up. |
| | | */ |
| | | logError(WARN_CONNECTED_TO_SERVER_WITH_WRONG_GROUP_ID.get( |
| | | Byte.toString(groupId), Integer.toString(rs.getServerId()), |
| | | rsInfo.getServerURL(), Byte.toString(rs.getGroupId()), |
| | | baseDN.toNormalizedString(), Integer.toString(getServerId()))); |
| | | logger.warn(WARN_CONNECTED_TO_SERVER_WITH_WRONG_GROUP_ID.get(Byte |
| | | .toString(groupId), Integer.toString(rs.getServerId()), rsInfo |
| | | .getServerURL(), Byte.toString(rs.getGroupId()), baseDN |
| | | .toNormalizedString(), Integer.toString(getServerId()))); |
| | | } |
| | | startRSHeartBeatMonitoring(rs); |
| | | if (rsInfo.getProtocolVersion() >= |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(ERR_COMPUTING_FAKE_OPS.get( |
| | | baseDN.toNormalizedString(), rsInfo.getServerURL(), |
| | | logger.error(ERR_COMPUTING_FAKE_OPS.get(baseDN.toNormalizedString(), rsInfo.getServerURL(), |
| | | e.getLocalizedMessage() + " " + stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | |
| | | if (keepSession) // Log error message only for final connection |
| | | { |
| | | // log the error message only once to avoid overflowing the error log |
| | | logError(errorMessage); |
| | | logger.error(errorMessage); |
| | | } |
| | | |
| | | if (logger.isTraceEnabled()) |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(WARN_EXCEPTION_STARTING_SESSION_PHASE.get( |
| | | getServerId(), server, getBaseDN().toNormalizedString(), |
| | | logger.warn(WARN_EXCEPTION_STARTING_SESSION_PHASE.get(getServerId(), server, getBaseDN().toNormalizedString(), |
| | | stackTraceToSingleLineString(e))); |
| | | |
| | | rs.session.close(); |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(WARN_EXCEPTION_STARTING_SESSION_PHASE.get( |
| | | logger.error(WARN_EXCEPTION_STARTING_SESSION_PHASE.get( |
| | | getServerId(), electedRS.rsInfo.getServerURL(), |
| | | getBaseDN().toNormalizedString(), stackTraceToSingleLineString(e))); |
| | | |
| | |
| | | mb.append(NOTE_EXCEPTION_RESTARTING_SESSION.get( |
| | | getBaseDN().toNormalizedString(), e.getLocalizedMessage())); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logError(mb.toMessage()); |
| | | logger.error(mb.toMessage()); |
| | | } |
| | | |
| | | if (rs.isConnected() || !infiniteTry) |
| | |
| | | else if (msg instanceof StopMsg) |
| | | { |
| | | // RS performs a proper disconnection |
| | | LocalizableMessage message = WARN_REPLICATION_SERVER_PROPERLY_DISCONNECTED.get( |
| | | previousRsServerID, rs.replicationServer, |
| | | logger.warn(WARN_REPLICATION_SERVER_PROPERLY_DISCONNECTED, previousRsServerID, rs.replicationServer, |
| | | serverId, baseDN.toNormalizedString()); |
| | | logError(message); |
| | | |
| | | // Try to find a suitable RS |
| | | reStart(rs.session, true); |
| | |
| | | evals.getEvaluation(previousRsServerID).toString(), |
| | | evals.getEvaluation(bestRsServerId).toString()); |
| | | } |
| | | logError(message); |
| | | logger.error(message); |
| | | if (logger.isTraceEnabled()) |
| | | debugInfo("best replication servers evaluation results: " |
| | | + evals); |
| | |
| | | if (rs.session == null || !rs.session.closeInitiated()) |
| | | { |
| | | // We did not initiate the close on our side, log an error message. |
| | | logError(WARN_REPLICATION_SERVER_BADLY_DISCONNECTED.get( |
| | | logger.error(WARN_REPLICATION_SERVER_BADLY_DISCONNECTED.get( |
| | | serverId, baseDN.toNormalizedString(), previousRsServerID, |
| | | rs.replicationServer)); |
| | | } |
| | |
| | | new ChangeStatusMsg(ServerStatus.INVALID_STATUS, newStatus)); |
| | | } catch (IOException ex) |
| | | { |
| | | LocalizableMessage message = ERR_EXCEPTION_SENDING_CS.get( |
| | | getBaseDN().toNormalizedString(), |
| | | logger.error(ERR_EXCEPTION_SENDING_CS, getBaseDN().toNormalizedString(), |
| | | Integer.toString(getServerId()), |
| | | ex.getLocalizedMessage() + " " + stackTraceToSingleLineString(ex)); |
| | | logError(message); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.common.AssuredMode.*; |
| | | import static org.opends.server.replication.common.StatusMachine.*; |
| | | |
| | |
| | | // Sanity check: is it a valid initial status? |
| | | if (!isValidInitialStatus(initStatus)) |
| | | { |
| | | logError(ERR_DS_INVALID_INIT_STATUS.get(initStatus.toString(), |
| | | logger.error(ERR_DS_INVALID_INIT_STATUS.get(initStatus.toString(), |
| | | getBaseDNString(), Integer.toString(getServerId()))); |
| | | } |
| | | else |
| | |
| | | StatusMachineEvent event = StatusMachineEvent.statusToEvent(reqStatus); |
| | | if (event == StatusMachineEvent.INVALID_EVENT) |
| | | { |
| | | logError(ERR_DS_INVALID_REQUESTED_STATUS.get(reqStatus.toString(), |
| | | logger.error(ERR_DS_INVALID_REQUESTED_STATUS.get(reqStatus.toString(), |
| | | getBaseDNString(), Integer.toString(getServerId()))); |
| | | return; |
| | | } |
| | |
| | | attempt of initialization while we have started a new one |
| | | on this side. |
| | | */ |
| | | logError(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | // Simply log - happen if import/export has been terminated |
| | | // on our side before receiving this ErrorMsg. |
| | | logError(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | } |
| | | } |
| | | else if (msg instanceof ChangeStatusMsg) |
| | |
| | | Some problems detected: message did not correctly reach every |
| | | requested servers. Log problem |
| | | */ |
| | | logError(NOTE_DS_RECEIVED_ACK_ERROR.get( |
| | | logger.error(NOTE_DS_RECEIVED_ACK_ERROR.get( |
| | | getBaseDNString(), Integer.toString(getServerId()), |
| | | update.toString(), ack.errorsToString())); |
| | | |
| | |
| | | |
| | | if (serverToInitialize == RoutableMsg.ALL_SERVERS) |
| | | { |
| | | logError(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START_ALL.get( |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START_ALL.get( |
| | | countEntries(), getBaseDNString(), getServerId())); |
| | | |
| | | for (DSInfo dsi : getReplicasList()) |
| | |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START.get(countEntries(), |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START.get(countEntries(), |
| | | getBaseDNString(), getServerId(), serverToInitialize)); |
| | | |
| | | ieCtx.startList.add(serverToInitialize); |
| | |
| | | */ |
| | | try { Thread.sleep(1000); } |
| | | catch(Exception e){ /* do nothing */ } |
| | | logError(NOTE_RESENDING_INIT_TARGET.get( |
| | | logger.error(NOTE_RESENDING_INIT_TARGET.get( |
| | | exportRootException.getLocalizedMessage())); |
| | | |
| | | continue; |
| | |
| | | : exportRootException.getLocalizedMessage(); |
| | | if (serverToInitialize == RoutableMsg.ALL_SERVERS) |
| | | { |
| | | logError(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END_ALL.get( |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END_ALL.get( |
| | | getBaseDNString(), getServerId(), cause)); |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END.get( |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END.get( |
| | | getBaseDNString(), getServerId(), serverToInitialize, cause)); |
| | | } |
| | | |
| | |
| | | { |
| | | // Should not happen |
| | | errMsg = LocalizableMessage.raw( e.getLocalizedMessage()); |
| | | logError(errMsg); |
| | | logger.error(errMsg); |
| | | } |
| | | |
| | | // When error, update the task and raise the error to the caller |
| | |
| | | try |
| | | { |
| | | // Log starting |
| | | logError(NOTE_FULL_UPDATE_ENGAGED_FROM_REMOTE_START.get(getBaseDNString(), |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FROM_REMOTE_START.get(getBaseDNString(), |
| | | initTargetMsgReceived.getSenderID(), getServerId())); |
| | | |
| | | // Go into full update status |
| | |
| | | Restart the whole import protocol exchange by sending again |
| | | the request |
| | | */ |
| | | logError(NOTE_RESENDING_INIT_FROM_REMOTE_REQUEST.get( |
| | | logger.error(NOTE_RESENDING_INIT_FROM_REMOTE_REQUEST.get( |
| | | ieCtx.getException().getLocalizedMessage())); |
| | | |
| | | broker.publish(ieCtx.initReqMsgSent); |
| | |
| | | An error occurs when sending a new request for a new import. |
| | | This error is not stored, preferring to keep the initial one. |
| | | */ |
| | | logError(ERR_SENDING_NEW_ATTEMPT_INIT_REQUEST.get( |
| | | logger.error(ERR_SENDING_NEW_ATTEMPT_INIT_REQUEST.get( |
| | | e.getLocalizedMessage(), |
| | | ieCtx.getException().getLocalizedMessage())); |
| | | } |
| | |
| | | getServerId(), |
| | | (ieCtx.getException() == null ? "" |
| | | : ieCtx.getException().getLocalizedMessage())); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | releaseIEContext(); |
| | | } // finally |
| | | } // finally |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | logError(ERR_DS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | logger.error(ERR_DS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | String.valueOf(getServerId()), status.toString(), event.toString())); |
| | | return; |
| | | } |
| | |
| | | } |
| | | else if (getAssuredMode() != AssuredMode.SAFE_DATA_MODE) |
| | | { |
| | | logError(ERR_DS_UNKNOWN_ASSURED_MODE.get(String.valueOf(getServerId()), |
| | | logger.error(ERR_DS_UNKNOWN_ASSURED_MODE.get(String.valueOf(getServerId()), |
| | | msg.getAssuredMode().toString(), getBaseDNString(), |
| | | msg.toString())); |
| | | } |
| | |
| | | } catch (TimeoutException ex) |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logError(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | Long.toString(getAssuredTimeout()), update.toString())); |
| | | } |
| | | } |
| | |
| | | import org.opends.server.types.DN; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | invalidReason.append(e.getMessageObject()); |
| | | return false; |
| | | } |
| | |
| | | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | case REJECT: |
| | | throw de; |
| | | case WARN: |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | return ByteString.valueOf(value.toString()); |
| | | default: |
| | | return ByteString.valueOf(value.toString()); |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class AuthPasswordSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_AUTH_PASSWORD_EXACT_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_AUTH_PASSWORD_EXACT_NAME, SYNTAX_AUTH_PASSWORD_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.*; |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class BinarySyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | class BitStringEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this bitStringMatch matching rule. |
| | | */ |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logError(message); |
| | | logger.error(message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | | return ByteString.valueOf(valueString); |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logError(message); |
| | | logger.error(message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | | return ByteString.valueOf(valueString); |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class BitStringSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_BIT_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_BIT_STRING_OID, SYNTAX_BIT_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_BIT_STRING_OID, SYNTAX_BIT_STRING_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class BooleanEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this booleanMatch matching rule. |
| | | */ |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | | return ByteString.valueOf(valueString); |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class BooleanSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_BOOLEAN_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | | |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class CaseExactIA5EqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseExactMatch matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | class CaseExactIA5SubstringMatchingRule |
| | | extends SubstringMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseExactSubstringsMatch matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | | |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class CaseIgnoreIA5EqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseIgnoreIA5Match matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | | |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.SubstringMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class CaseIgnoreIA5SubstringMatchingRule |
| | | extends SubstringMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseIgnoreSubstringsMatch matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class CertificateExactAssertionSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | } |
| | | } |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.asn1.GSERException; |
| | | import org.opends.server.protocols.asn1.GSERParser; |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | |
| | | certificateIssuer= toLowerCase(dnstring); |
| | | break; |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | break; |
| | | } |
| | | } |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | |
| | | certificateIssuer= toLowerCase(dnstring); |
| | | break; |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class CertificateListSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class CertificatePairSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import java.util.List; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | | import org.opends.server.admin.std.server.CertificateAttributeSyntaxCfg; |
| | |
| | | import org.opends.server.protocols.asn1.ASN1Exception; |
| | | import org.opends.server.protocols.asn1.ASN1Reader; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | |
| | | extends AttributeSyntax<CertificateAttributeSyntaxCfg> |
| | | implements ConfigurationChangeListener<CertificateAttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CERTIFICATE_EXACT_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CERTIFICATE_EXACT_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | ConfigurationChangeListener<CollationMatchingRuleCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | // Whether equality matching rules are enabled. |
| | | private boolean equalityMatchingRuleType; |
| | | |
| | |
| | | LocalizableMessage msg = |
| | | WARN_ATTR_INVALID_COLLATION_MATCHING_RULE_FORMAT |
| | | .get(collation); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | continue; |
| | | } |
| | | |
| | |
| | | collation, configuration.dn().toNormalizedString(), |
| | | languageTag); |
| | | |
| | | logError(msg); |
| | | logger.error(msg); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import java.util.List; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | | import org.opends.server.admin.std.server.CountryStringAttributeSyntaxCfg; |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | extends AttributeSyntax<CountryStringAttributeSyntaxCfg> |
| | | implements ConfigurationChangeListener<CountryStringAttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import java.util.HashSet; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.StringTokenizer; |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class DeliveryMethodSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The set of values that may be used as delivery methods. |
| | | */ |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | extends AttributeSyntax<DirectoryStringAttributeSyntaxCfg> |
| | | implements ConfigurationChangeListener<DirectoryStringAttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_DN_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_DN_OID, SYNTAX_DN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_DN_OID, SYNTAX_DN_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_DN_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class EnhancedGuideSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import java.util.HashSet; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class FaxNumberSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The set of allowed fax parameter values, formatted entirely in lowercase |
| | | * characters. |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class FaxSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | throw de; |
| | | |
| | | case WARN: |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | return value.toByteString(); |
| | | |
| | | default: |
| | |
| | | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | throw de; |
| | | |
| | | case WARN: |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | return value.toByteString(); |
| | | |
| | | default: |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_GENERALIZED_TIME_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_GENERALIZED_TIME_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class GuideSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class IA5StringSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_IA5_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_IA5_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class IntegerEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this integerMatch matching rule. |
| | | */ |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | break; |
| | | } |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | break; |
| | | } |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | break; |
| | | } |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | break; |
| | | } |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | buffer.append("0"); |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | buffer.setCharAt(0, '0'); |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | extends AbstractMatchingRule |
| | | implements OrderingMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | break; |
| | | } |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | } |
| | | break; |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | } |
| | | break; |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | } |
| | | break; |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | } |
| | | |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | } |
| | | |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class IntegerSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_INTEGER_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_INTEGER_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_EXACT_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_EXACT_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_EXACT_OID, SYNTAX_INTEGER_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import java.util.List; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | | import org.opends.server.admin.std.server.JPEGAttributeSyntaxCfg; |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | |
| | | extends AttributeSyntax<JPEGAttributeSyntaxCfg> |
| | | implements ConfigurationChangeListener<JPEGAttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | } |
| | | |
| | | this.config = configuration; |
| | |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch(DirectoryException de) |
| | | { |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | } |
| | | } |
| | | return orderingMatchingRule; |
| | |
| | | |
| | | import org.opends.server.types.*; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | false); |
| | | if (syntax == null) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_MR_UNKNOWN_SYNTAX.get( |
| | | valueStr, oidBuffer.toString()); |
| | | logError(message); |
| | | logger.error(ERR_ATTR_SYNTAX_MR_UNKNOWN_SYNTAX, valueStr, oidBuffer.toString()); |
| | | |
| | | syntax = DirectoryServer.getDefaultAttributeSyntax(); |
| | | } |
| | |
| | | |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_UNIQUE_MEMBER_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_UNIQUE_MEMBER_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class NumericStringEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseExactMatch matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | |
| | | import org.opends.server.api.AbstractMatchingRule; |
| | | import org.opends.server.api.OrderingMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | extends AbstractMatchingRule |
| | | implements OrderingMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.schema.StringPrepProfile.*; |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.SubstringMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | class NumericStringSubstringMatchingRule |
| | | extends SubstringMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this numericStringSubstringsMatch matching rule. |
| | | */ |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class NumericStringSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_NUMERIC_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_NUMERIC_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_EXACT_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class OIDSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OID_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OID_OID, SYNTAX_OID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OID_OID, SYNTAX_OID_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_OID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_OID_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.api.MatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.opends.server.types.AttributeType; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | class ObjectIdentifierEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this objectIdentifierMatch matching rule. |
| | | */ |
| | |
| | | if (! isValidSchemaElement(lowerValue, 0, lowerValue.length(), |
| | | invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_OID_INVALID_VALUE.get( |
| | | lowerValue, invalidReason.toString()); |
| | | ErrorLogger.logError(message); |
| | | logger.error(ERR_ATTR_SYNTAX_OID_INVALID_VALUE, lowerValue, invalidReason.toString()); |
| | | } |
| | | |
| | | return ByteString.valueOf(lowerValue); |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class OctetStringSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class OtherMailboxSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_LIST_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_LIST_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class PostalAddressSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class PresentationAddressSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class PrintableStringSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class ProtocolInformationSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default approximate matching rule for this syntax. |
| | | private ApproximateMatchingRule defaultApproximateMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class SubstringAssertionSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | } |
| | | } |
| | |
| | | package org.opends.server.schema; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | defaultEqualityMatchingRule = DirectoryServer |
| | | .getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = DirectoryServer |
| | | .getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = DirectoryServer |
| | | .getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class SupportedAlgorithmSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | |
| | | extends AttributeSyntax<TelephoneNumberAttributeSyntaxCfg> |
| | | implements ConfigurationChangeListener<TelephoneNumberAttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // Indicates whether this matching rule should operate in strict mode. |
| | | private boolean strictMode; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_TELEPHONE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_TELEPHONE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | } |
| | | |
| | | |
| | |
| | | |
| | | |
| | | import java.util.HashSet; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class TeletexTerminalIdentifierSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The set of allowed fax parameter values, formatted entirely in lowercase |
| | | * characters. |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | } |
| | | |
| | |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class TelexNumberSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | package org.opends.server.schema; |
| | | |
| | | import org.opends.server.util.StaticUtils; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.nio.ByteBuffer; |
| | | import java.util.ArrayList; |
| | | import java.util.Calendar; |
| | |
| | | public final class TimeBasedMatchingRuleFactory |
| | | extends MatchingRuleFactory<MatchingRuleCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | //Greater-than RelativeTimeMatchingRule. |
| | | private MatchingRule greaterThanRTMRule; |
| | | |
| | |
| | | throw de; |
| | | |
| | | case WARN: |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | return value.toByteString(); |
| | | |
| | | default: |
| | |
| | | if(message !=null) |
| | | { |
| | | //Log the message and throw an exception. |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | } |
| | | if(message !=null) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_YEAR_ASSERTION_FORMAT. |
| | | get(value.toString(),year); |
| | | logError(message); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_MONTH_ASSERTION_FORMAT. |
| | | get(value.toString(),month); |
| | | logError(message); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | if(invalidDate) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT. |
| | | get(value.toString(),date); |
| | | logError(message); |
| | | WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT.get(value.toString(), date); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_HOUR_ASSERTION_FORMAT. |
| | | get(value.toString(),date); |
| | | logError(message); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_MINUTE_ASSERTION_FORMAT. |
| | | get(value.toString(),date); |
| | | logError(message); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | WARN_ATTR_INVALID_SECOND_ASSERTION_FORMAT. |
| | | get(value.toString(),date); |
| | | logError(message); |
| | | logger.warn(message); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | } |
| | |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_GENERALIZED_TIME_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_GENERALIZED_TIME_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME)); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_UTC_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_UTC_TIME_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | class UUIDEqualityMatchingRule |
| | | extends EqualityMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Creates a new instance of this caseExactMatch matching rule. |
| | | */ |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logError(message); |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | return value.toByteString(); |
| | | default: |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logError( |
| | | logger.error( |
| | | message); |
| | | return value.toByteString(); |
| | | default: |
| | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | import java.util.Collection; |
| | |
| | | import org.opends.server.api.AbstractMatchingRule; |
| | | import org.opends.server.api.OrderingMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.opends.server.types.DirectoryException; |
| | |
| | | extends AbstractMatchingRule |
| | | implements OrderingMatchingRule |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The serial version identifier required to satisfy the compiler because this |
| | | * class implements the <CODE>java.io.Serializable</CODE> interface. This |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | public class UUIDSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_UUID_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_UUID_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.loggers.ErrorLogger; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | |
| | | valueBuffer.append(toLowerCase(valueString).substring(0, dnEndPos)); |
| | | break; |
| | |
| | | case WARN: |
| | | if (! logged) |
| | | { |
| | | ErrorLogger.logError(message); |
| | | logger.error(message); |
| | | logged = true; |
| | | } |
| | | break; |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | * order: |
| | | * <BR> |
| | | * <UL> |
| | | * <LI>An opening curly brace ("{") character.</LI> |
| | | * <LI>An opening curly brace ("{ |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | ") character.</LI> |
| | | * <LI>The name of the storage scheme used to encode the value.</LI> |
| | | * <LI>A closing curly brace ("}") character.</LI> |
| | | * <LI>The encoded value.</LI> |
| | |
| | | public class UserPasswordSyntax |
| | | extends AttributeSyntax<AttributeSyntaxCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The default equality matching rule for this syntax. |
| | | private EqualityMatchingRule defaultEqualityMatchingRule; |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a new instance of this syntax. Note that the only thing that |
| | | * should be done here is to invoke the default constructor for the |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_USER_PASSWORD_EXACT_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logError(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_USER_PASSWORD_EXACT_NAME, SYNTAX_USER_PASSWORD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_USER_PASSWORD_EXACT_NAME, SYNTAX_USER_PASSWORD_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | final Lock schemaLock = LockManager.lockWrite(schemaDN); |
| | | if (schemaLock == null) |
| | | { |
| | | LocalizableMessage message = ERR_TASK_ADDSCHEMAFILE_CANNOT_LOCK_SCHEMA.get( |
| | | String.valueOf(schemaDN)); |
| | | logError(message); |
| | | logger.error(ERR_TASK_ADDSCHEMAFILE_CANNOT_LOCK_SCHEMA, String.valueOf(schemaDN)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(ce); |
| | | |
| | | LocalizableMessage message = ERR_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE. |
| | | get(String.valueOf(schemaFile), ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE, String |
| | | .valueOf(schemaFile), ce.getMessage()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (InitializationException ie) |
| | | { |
| | | logger.traceException(ie); |
| | | |
| | | LocalizableMessage message = ERR_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE. |
| | | get(String.valueOf(schemaFile), ie.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_TASK_ADDSCHEMAFILE_ERROR_LOADING_SCHEMA_FILE, String |
| | | .valueOf(schemaFile), ie.getMessage()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_TASK_ADDSCHEMAFILE_CANNOT_NOTIFY_SYNC_PROVIDER. |
| | | get(provider.getClass().getName(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_TASK_ADDSCHEMAFILE_CANNOT_NOTIFY_SYNC_PROVIDER, |
| | | provider.getClass().getName(), getExceptionMessage(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | */ |
| | | package org.opends.server.tasks; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.messages.TaskMessages; |
| | | |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | |
| | | public class BackupTask extends Task |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | |
| | | /** |
| | | * Stores mapping between configuration attribute name and its label. |
| | |
| | | { |
| | | if (!backendIDList.isEmpty()) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_MIX_BACKUP_ALL_AND_BACKEND_ID.get( |
| | | logger.error(ERR_BACKUPDB_CANNOT_MIX_BACKUP_ALL_AND_BACKEND_ID, |
| | | ATTR_TASK_BACKUP_ALL, ATTR_TASK_BACKUP_BACKEND_ID); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | } |
| | | else if (backendIDList.isEmpty()) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_NEED_BACKUP_ALL_OR_BACKEND_ID.get( |
| | | logger.error(ERR_BACKUPDB_NEED_BACKUP_ALL_OR_BACKEND_ID, |
| | | ATTR_TASK_BACKUP_ALL, ATTR_TASK_BACKUP_BACKEND_ID); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | |
| | |
| | | { |
| | | if (! incremental) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_INCREMENTAL_BASE_REQUIRES_INCREMENTAL. |
| | | get(ATTR_TASK_BACKUP_INCREMENTAL_BASE_ID, |
| | | logger.error(ERR_BACKUPDB_INCREMENTAL_BASE_REQUIRES_INCREMENTAL, ATTR_TASK_BACKUP_INCREMENTAL_BASE_ID, |
| | | ATTR_TASK_BACKUP_INCREMENTAL); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | // was given. |
| | | if (signHash && (! hash)) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_SIGN_REQUIRES_HASH.get( |
| | | ATTR_TASK_BACKUP_SIGN_HASH, ATTR_TASK_BACKUP_HASH); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_SIGN_REQUIRES_HASH, ATTR_TASK_BACKUP_SIGN_HASH, ATTR_TASK_BACKUP_HASH); |
| | | return false; |
| | | } |
| | | |
| | |
| | | Backend b = DirectoryServer.getBackend(id); |
| | | if (b == null || configEntries.get(id) == null) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_NO_BACKENDS_FOR_ID.get(id); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_NO_BACKENDS_FOR_ID, id); |
| | | } |
| | | else if (! b.supportsBackup()) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_BACKUPDB_BACKUP_NOT_SUPPORTED.get(b.getBackendID()); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_BACKUP_NOT_SUPPORTED, b.getBackendID()); |
| | | } |
| | | else |
| | | { |
| | |
| | | // If there are no backends to archive, then print an error and exit. |
| | | if (backendsToArchive.isEmpty()) |
| | | { |
| | | LocalizableMessage message = WARN_BACKUPDB_NO_BACKENDS_TO_ARCHIVE.get(); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_NO_BACKENDS_TO_ARCHIVE); |
| | | return false; |
| | | } |
| | | |
| | |
| | | // backend |
| | | if (! backupDir.getConfigEntryDN().equals(cfg.dn())) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY.get( |
| | | b.getBackendID(),backupLocation.getPath(), |
| | | logger.error(ERR_BACKUPDB_CANNOT_BACKUP_IN_DIRECTORY, b.getBackendID(),backupLocation.getPath(), |
| | | backupDir.getConfigEntryDN().rdn(). |
| | | getAttributeValue(0).toString()); |
| | | logError(message); |
| | | return false ; |
| | | } |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR.get( |
| | | descriptorPath, ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR, descriptorPath, ce.getMessage()); |
| | | return false; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR.get( |
| | | descriptorPath, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR, descriptorPath, getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_CREATE_BACKUP_DIR.get( |
| | | backupLocation.getPath(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_CREATE_BACKUP_DIR, backupLocation.getPath(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | catch (DirectoryException de) |
| | | { |
| | | DirectoryServer.notifyBackupEnded(b, backupConfig, false); |
| | | LocalizableMessage message = ERR_BACKUPDB_ERROR_DURING_BACKUP.get( |
| | | b.getBackendID(), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_ERROR_DURING_BACKUP, b.getBackendID(), de.getMessageObject()); |
| | | return false; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | DirectoryServer.notifyBackupEnded(b, backupConfig, false); |
| | | LocalizableMessage message = ERR_BACKUPDB_ERROR_DURING_BACKUP.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_ERROR_DURING_BACKUP, b.getBackendID(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_LOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_LOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | return false; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_LOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_LOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | return false; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | |
| | | try |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_STARTING_BACKUP.get(b.getBackendID()); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_STARTING_BACKUP, b.getBackendID()); |
| | | |
| | | |
| | | // Get the path to the directory to use for this backup. If we will be |
| | |
| | | // completed at least for one of the backends. |
| | | if (errorsEncountered) |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_COMPLETED_WITH_ERRORS.get(); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_COMPLETED_WITH_ERRORS); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | else if (isCancelled()) |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_CANCELLED.get(); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_CANCELLED); |
| | | return getTaskInterruptState(); |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_COMPLETED_SUCCESSFULLY.get(); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_COMPLETED_SUCCESSFULLY); |
| | | return TaskState.COMPLETED_SUCCESSFULLY; |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.tasks; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | public class DisconnectClientTask |
| | | extends Task |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // Indicates whether to send a notification message to the client. |
| | | private boolean notifyClient; |
| | | |
| | |
| | | // terminate it. |
| | | if (clientConnection == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_TASK_DISCONNECT_NO_SUCH_CONNECTION.get( |
| | | String.valueOf(connectionID)); |
| | | logError(message); |
| | | logger.error(ERR_TASK_DISCONNECT_NO_SUCH_CONNECTION, String.valueOf(connectionID)); |
| | | |
| | | return TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.tasks; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.messages.TaskMessages; |
| | | |
| | | import static org.opends.server.core.DirectoryServer.getAttributeType; |
| | |
| | | public class ExportTask extends Task |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * Stores mapping between configuration attribute name and its label. |
| | | */ |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_NO_BACKENDS_FOR_ID.get(backendID); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_NO_BACKENDS_FOR_ID, backendID); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | else if (! backend.supportsLDIFExport()) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_EXPORT_BACKEND.get(backendID); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_EXPORT_BACKEND, backendID); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | | if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches, |
| | | excludeBranches)) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_INVALID_INCLUDE_BASE.get(s, backendID); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_INVALID_INCLUDE_BASE, s, backendID); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | catch (DirectoryException de) |
| | | { |
| | | DirectoryServer.notifyExportEnded(backend, exportConfig, false); |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | DirectoryServer.notifyExportEnded(backend, exportConfig, false); |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID.get(); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | else if (! backend.supportsLDIFImport()) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_IMPORT.get(backendID); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_IMPORT, backendID); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | // Make sure that if the "backendID" argument was provided, no include |
| | |
| | | builder.append(" / "); |
| | | builder.append(backend.getBaseDNs()[i].toNormalizedString()); |
| | | } |
| | | LocalizableMessage message = ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND.get( |
| | | builder.toString(), ATTR_IMPORT_CLEAR_BACKEND); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND, builder.toString(), ATTR_IMPORT_CLEAR_BACKEND); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | else if(backend != locatedBackend) |
| | | { |
| | | // The include branches span across multiple backends. |
| | | LocalizableMessage message = ERR_LDIFIMPORT_INVALID_INCLUDE_BASE.get( |
| | | includeBranch.toNormalizedString(), backend.getBackendID()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_INVALID_INCLUDE_BASE, includeBranch |
| | | .toNormalizedString(), backend.getBackendID()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches, |
| | | excludeBranches)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_INVALID_INCLUDE_BASE.get( |
| | | includeBranch.toNormalizedString(), backend.getBackendID()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_INVALID_INCLUDE_BASE, includeBranch.toNormalizedString(), backend.getBackendID()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_TEMPLATE_FILE.get( |
| | | templateFile, e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_TEMPLATE_FILE, templateFile, e.getMessage()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_OPEN_REJECTS_FILE.get( |
| | | rejectFile, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_REJECTS_FILE, rejectFile, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_OPEN_SKIP_FILE.get( |
| | | skipFile, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_SKIP_FILE, skipFile, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | message = ERR_LDIFIMPORT_ERROR_DURING_IMPORT.get( |
| | | de.getMessageObject()); |
| | | } |
| | | logError(message); |
| | | logger.error(message); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | catch (Exception e) |
| | |
| | | logger.traceException(e); |
| | | |
| | | DirectoryServer.notifyImportEnded(backend, importConfig, false); |
| | | LocalizableMessage message = |
| | | ERR_LDIFIMPORT_ERROR_DURING_IMPORT.get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_ERROR_DURING_IMPORT, getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | finally |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | DirectoryServer.notifyImportEnded(backend, importConfig, true); |
| | |
| | | logger.traceException(e); |
| | | |
| | | // This log will go to the task log message |
| | | LocalizableMessage message = ERR_TASK_EXECUTE_FAILED.get( |
| | | String.valueOf(getTaskEntryDN()), stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_TASK_EXECUTE_FAILED, String.valueOf(getTaskEntryDN()), stackTraceToSingleLineString(e)); |
| | | |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | |
| | | |
| | | // Error raised at completion time |
| | | if (taskCompletionError != null) |
| | | logError(taskCompletionError); |
| | | logger.error(taskCompletionError); |
| | | |
| | | } |
| | | catch(InterruptedException ie) {} |
| | | catch(DirectoryException de) |
| | | { |
| | | // Error raised at submission time |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | initState = TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | if (de.getResultCode() != ResultCode.ADMIN_LIMIT_EXCEEDED) |
| | | { |
| | | // Error raised at submission time |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | initState = TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | else |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DECODE_BASE_DN.get(baseDN, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DECODE_BASE_DN, baseDN, de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = ERR_NO_BACKENDS_FOR_BASE.get(baseDN); |
| | | logError(message); |
| | | logger.error(ERR_NO_BACKENDS_FOR_BASE, baseDN); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | | if (!(backend instanceof BackendImpl)) |
| | | { |
| | | LocalizableMessage message = ERR_REBUILDINDEX_WRONG_BACKEND_TYPE.get(); |
| | | logError(message); |
| | | logger.error(ERR_REBUILDINDEX_WRONG_BACKEND_TYPE); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | { |
| | | if (!LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND, backend |
| | | .getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND, backend |
| | | .getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | { |
| | | if (!LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_SHARED_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_SHARED_LOCK_BACKEND, backend |
| | | .getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_SHARED_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_SHARED_LOCK_BACKEND, backend |
| | | .getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_ERROR_DURING_REBUILD.get(e.getMessage()); |
| | | logger.traceException(e); |
| | | logError(message); |
| | | logger.error(message); |
| | | isBackendNeedToBeEnabled = true; |
| | | returnCode = TaskState.STOPPED_BY_ERROR; |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_REBUILDINDEX_ERROR_DURING_REBUILD.get(e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD, e.getMessage()); |
| | | returnCode = TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | finally |
| | |
| | | failureReason = new StringBuilder(); |
| | | if (!LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | logger.warn(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND, backend |
| | | .getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | returnCode = TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), |
| | | logger.warn(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), |
| | | getExceptionMessage(t)); |
| | | logError(message); |
| | | returnCode = TaskState.COMPLETED_WITH_ERRORS; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | returnCode = TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return false; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | return true; |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return false; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return false; |
| | | } |
| | | return true; |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_READ_BACKUP_DIRECTORY.get( |
| | | String.valueOf(backupDirectory), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_READ_BACKUP_DIRECTORY, String.valueOf(backupDirectory), getExceptionMessage(e)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | BackupInfo backupInfo = backupDir.getBackupInfo(backupID); |
| | | if (backupInfo == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_RESTOREDB_INVALID_BACKUP_ID.get( |
| | | backupID, String.valueOf(backupDirectory)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_INVALID_BACKUP_ID, backupID, String.valueOf(backupDirectory)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | BackupInfo latestBackup = backupDir.getLatestBackup(); |
| | | if (latestBackup == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_RESTOREDB_NO_BACKUPS_IN_DIRECTORY.get( |
| | | String.valueOf(backupDirectory)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_NO_BACKUPS_IN_DIRECTORY, String.valueOf(backupDirectory)); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | else |
| | |
| | | catch (ConfigException e) |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = ERR_RESTOREDB_NO_BACKENDS_FOR_DN.get( |
| | | String.valueOf(backupDirectory), configEntryDN.toString()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_NO_BACKENDS_FOR_DN, String.valueOf(backupDirectory), configEntryDN.toString()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | |
| | | if (! backend.supportsRestore()) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_RESTOREDB_CANNOT_RESTORE.get(backend.getBackendID()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_RESTORE, backend.getBackendID()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | } |
| | |
| | | catch (DirectoryException de) |
| | | { |
| | | DirectoryServer.notifyRestoreEnded(backend, restoreConfig, false); |
| | | LocalizableMessage message = ERR_RESTOREDB_ERROR_DURING_BACKUP.get( |
| | | backupID, backupDir.getPath(), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_ERROR_DURING_BACKUP, backupID, backupDir.getPath(), de.getMessageObject()); |
| | | errorsEncountered = true; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | DirectoryServer.notifyRestoreEnded(backend, restoreConfig, false); |
| | | LocalizableMessage message = ERR_RESTOREDB_ERROR_DURING_BACKUP.get( |
| | | backupID, backupDir.getPath(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_ERROR_DURING_BACKUP, backupID, backupDir.getPath(), getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(e.getMessageObject()); |
| | | logger.error(e.getMessageObject()); |
| | | errorsEncountered = true; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch(DirectoryException de) |
| | | { |
| | | logError(de.getMessageObject()); |
| | | logger.error(de.getMessageObject()); |
| | | return TaskState.STOPPED_BY_ERROR; |
| | | } |
| | | |
| | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import org.opends.server.util.ServerConstants; |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DETERMINE_BACKEND_ID.get( |
| | | String.valueOf(configEntry.getDN()), ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry.getDN()), ce.getMessage()); |
| | | return null; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DETERMINE_BACKEND_ID.get( |
| | | String.valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | return null; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DECODE_BACKEND_BASE_DN.get( |
| | | DN_BACKEND_BASE, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DECODE_BACKEND_BASE_DN, DN_BACKEND_BASE, de.getMessageObject()); |
| | | return configEntries; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DECODE_BACKEND_BASE_DN.get( |
| | | DN_BACKEND_BASE, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DECODE_BACKEND_BASE_DN, DN_BACKEND_BASE, getExceptionMessage(e)); |
| | | return configEntries; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY.get( |
| | | DN_BACKEND_BASE, ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY, DN_BACKEND_BASE, ce.getMessage()); |
| | | return configEntries; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY.get( |
| | | DN_BACKEND_BASE, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY, DN_BACKEND_BASE, getExceptionMessage(e)); |
| | | return configEntries; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DETERMINE_BACKEND_ID.get( |
| | | String.valueOf(configEntry.getDN()), ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry.getDN()), ce.getMessage()); |
| | | continue; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DETERMINE_BACKEND_ID.get( |
| | | String.valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | continue; |
| | | } |
| | | |
| | |
| | | package org.opends.server.tools; |
| | | |
| | | import java.io.File; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.io.OutputStream; |
| | | import java.io.PrintStream; |
| | | import java.text.SimpleDateFormat; |
| | |
| | | |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.tools.ToolConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | */ |
| | | public class BackUpDB extends TaskTool |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The main method for BackUpDB tool. |
| | | * |
| | |
| | | { |
| | | if (! b.supportsBackup()) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_BACKUPDB_BACKUP_NOT_SUPPORTED.get(b.getBackendID()); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_BACKUP_NOT_SUPPORTED, b.getBackendID()); |
| | | } |
| | | else |
| | | { |
| | |
| | | { |
| | | for (String id : requestedBackends) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_NO_BACKENDS_FOR_ID.get(id); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_NO_BACKENDS_FOR_ID, id); |
| | | } |
| | | |
| | | return 1; |
| | |
| | | // If there are no backends to archive, then print an error and exit. |
| | | if (backendsToArchive.isEmpty()) |
| | | { |
| | | LocalizableMessage message = WARN_BACKUPDB_NO_BACKENDS_TO_ARCHIVE.get(); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_NO_BACKENDS_TO_ARCHIVE); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_LOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_LOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | errorsEncountered = true; |
| | | continue; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_CANNOT_LOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_LOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | continue; |
| | | } |
| | | |
| | | |
| | | LocalizableMessage message = NOTE_BACKUPDB_STARTING_BACKUP.get(b.getBackendID()); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_STARTING_BACKUP, b.getBackendID()); |
| | | |
| | | |
| | | // Get the config entry for this backend. |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | message = ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR.get( |
| | | descriptorPath, ce.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR, descriptorPath, ce.getMessage()); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | |
| | | continue; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR.get( |
| | | descriptorPath, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_PARSE_BACKUP_DESCRIPTOR, descriptorPath, getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e2)); |
| | | } |
| | | |
| | | continue; |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = ERR_BACKUPDB_CANNOT_CREATE_BACKUP_DIR.get( |
| | | backupDirPath, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_CREATE_BACKUP_DIR, backupDirPath, getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e2)); |
| | | } |
| | | |
| | | continue; |
| | |
| | | StringBuilder unsupportedReason = new StringBuilder(); |
| | | if (! b.supportsBackup(backupConfig, unsupportedReason)) |
| | | { |
| | | message = ERR_BACKUPDB_CANNOT_BACKUP.get( |
| | | b.getBackendID(), unsupportedReason.toString()); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_CANNOT_BACKUP, b.getBackendID(), unsupportedReason.toString()); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e2)); |
| | | } |
| | | |
| | | continue; |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | message = ERR_BACKUPDB_ERROR_DURING_BACKUP.get( |
| | | b.getBackendID(), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_ERROR_DURING_BACKUP, b.getBackendID(), de.getMessageObject()); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | |
| | | continue; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = ERR_BACKUPDB_ERROR_DURING_BACKUP.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_BACKUPDB_ERROR_DURING_BACKUP, b.getBackendID(), getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | |
| | | try |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e2) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e2)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e2)); |
| | | } |
| | | |
| | | continue; |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), String.valueOf(failureReason)); |
| | | errorsEncountered = true; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | message = WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND.get( |
| | | b.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_BACKUPDB_CANNOT_UNLOCK_BACKEND, b.getBackendID(), getExceptionMessage(e)); |
| | | errorsEncountered = true; |
| | | } |
| | | } |
| | |
| | | int ret = 0; |
| | | if (errorsEncountered) |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_COMPLETED_WITH_ERRORS.get(); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_COMPLETED_WITH_ERRORS); |
| | | ret = 1; |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = NOTE_BACKUPDB_COMPLETED_SUCCESSFULLY.get(); |
| | | logError(message); |
| | | logger.info(NOTE_BACKUPDB_COMPLETED_SUCCESSFULLY); |
| | | } |
| | | return ret; |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.tools; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import org.opends.server.api.Backend; |
| | | import org.opends.server.config.ConfigEntry; |
| | |
| | | import org.opends.server.core.DirectoryServer; |
| | | |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | */ |
| | | public class BackendToolUtils |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Retrieves information about the backends defined in the Directory Server |
| | | * configuration. |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DECODE_BACKEND_BASE_DN.get(DN_BACKEND_BASE, de |
| | | logger.error(ERR_CANNOT_DECODE_BACKEND_BASE_DN, DN_BACKEND_BASE, de |
| | | .getMessageObject()); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DECODE_BACKEND_BASE_DN.get(DN_BACKEND_BASE, |
| | | logger.error(ERR_CANNOT_DECODE_BACKEND_BASE_DN, DN_BACKEND_BASE, |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY.get(DN_BACKEND_BASE, ce |
| | | logger.error(ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY, DN_BACKEND_BASE, ce |
| | | .getMessage()); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY.get(DN_BACKEND_BASE, |
| | | logger.error(ERR_CANNOT_RETRIEVE_BACKEND_BASE_ENTRY, DN_BACKEND_BASE, |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DETERMINE_BACKEND_ID.get(String.valueOf(configEntry |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry |
| | | .getDN()), ce.getMessage()); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DETERMINE_BACKEND_ID.get(String.valueOf(configEntry |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_ID, String.valueOf(configEntry |
| | | .getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException ce) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DETERMINE_BACKEND_CLASS.get(String.valueOf(configEntry |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_CLASS, String.valueOf(configEntry |
| | | .getDN()), ce.getMessage()); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DETERMINE_BACKEND_CLASS.get(String.valueOf(configEntry |
| | | logger.error(ERR_CANNOT_DETERMINE_BACKEND_CLASS, String.valueOf(configEntry |
| | | .getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_LOAD_BACKEND_CLASS.get(backendClassName, String |
| | | logger.error(ERR_CANNOT_LOAD_BACKEND_CLASS, backendClassName, String |
| | | .valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_INSTANTIATE_BACKEND_CLASS.get(backendClassName, String |
| | | logger.error(ERR_CANNOT_INSTANTIATE_BACKEND_CLASS, backendClassName, String |
| | | .valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | (DNConfigAttribute) configEntry.getConfigAttribute(baseDNStub); |
| | | if (baseDNAttr == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_NO_BASES_FOR_BACKEND.get(String.valueOf(configEntry.getDN())); |
| | | logError(message); |
| | | logger.error(ERR_NO_BASES_FOR_BACKEND, String.valueOf(configEntry.getDN())); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DETERMINE_BASES_FOR_BACKEND.get(String |
| | | logger.error(ERR_CANNOT_DETERMINE_BASES_FOR_BACKEND, String |
| | | .valueOf(configEntry.getDN()), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | |
| | | import static org.opends.messages.ConfigMessages.*; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.protocols.ldap.LDAPResultCode.*; |
| | | import static org.opends.server.tools.ToolConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | |
| | | backend = (Backend) backendClass.newInstance(); |
| | | } catch (Exception e) { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_BACKEND_CANNOT_INSTANTIATE.get( |
| | | String.valueOf(className), |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_INSTANTIATE, String.valueOf(className), |
| | | String.valueOf(backendCfg.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | continue; |
| | | } |
| | | backend.setBackendID(backendID); |
| | |
| | | backend.initializeBackend(); |
| | | } catch (Exception e) { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_BACKEND_CANNOT_INITIALIZE.get( |
| | | String.valueOf(className), |
| | | logger.error(ERR_CONFIG_BACKEND_CANNOT_INITIALIZE, String.valueOf(className), |
| | | String.valueOf(backendCfg.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | } |
| | | try { |
| | | DirectoryServer.registerBackend(backend); |
| | | } catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = |
| | | WARN_CONFIG_BACKEND_CANNOT_REGISTER_BACKEND.get( |
| | | backendCfg.getBackendId(), |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_REGISTER_BACKEND, backendCfg.getBackendId(), |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | package org.opends.server.tools; |
| | | |
| | | import java.io.OutputStream; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.io.PrintStream; |
| | | import java.util.ArrayList; |
| | | import java.util.HashSet; |
| | |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.tools.ToolConstants.*; |
| | |
| | | */ |
| | | public class ExportLDIF extends TaskTool { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | /** |
| | | * The main method for ExportLDIF tool. |
| | | * |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_MULTIPLE_BACKENDS_FOR_ID.get(backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_MULTIPLE_BACKENDS_FOR_ID, backendID.getValue()); |
| | | return 1; |
| | | } |
| | | } |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_NO_BACKENDS_FOR_ID.get(backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_NO_BACKENDS_FOR_ID, backendID.getValue()); |
| | | return 1; |
| | | } |
| | | else if (! backend.supportsLDIFExport()) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_CANNOT_EXPORT_BACKEND.get(backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_EXPORT_BACKEND, backendID.getValue()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | | if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches, |
| | | excludeBranches)) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_INVALID_INCLUDE_BASE.get(s, backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_INVALID_INCLUDE_BASE, s, backendID.getValue()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ArgumentException ae) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_DECODE_WRAP_COLUMN_AS_INTEGER.get( |
| | | wrapColumn.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_WRAP_COLUMN_AS_INTEGER, wrapColumn.getValue()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, de.getMessageObject()); |
| | | errorOccurred = true; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFEXPORT_ERROR_DURING_EXPORT.get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, getExceptionMessage(e)); |
| | | errorOccurred = true; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | |
| | | |
| | |
| | | |
| | | |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.tools.ToolConstants.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | * server process (e.g., via the tasks interface). |
| | | */ |
| | | public class ImportLDIF extends TaskTool { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The buffer size that should be used when reading data from LDIF. |
| | | */ |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER.get( |
| | | filterString, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_MULTIPLE_BACKENDS_FOR_ID.get(); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_MULTIPLE_BACKENDS_FOR_ID); |
| | | return 1; |
| | | } |
| | | } |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID.get(); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_NO_BACKENDS_FOR_ID); |
| | | return 1; |
| | | } |
| | | else if (! backend.supportsLDIFImport()) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_IMPORT.get(backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_IMPORT, backendID.getValue()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE.get( |
| | | s, getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | if (! Backend.handlesEntry(includeBranch, defaultIncludeBranches, |
| | | excludeBranches)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_INVALID_INCLUDE_BASE.get( |
| | | includeBranch.toNormalizedString(), backendID.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_INVALID_INCLUDE_BASE, includeBranch.toNormalizedString(), backendID.getValue()); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | File f = new File(pathname); |
| | | if (!f.canRead()) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_READ_FILE.get(pathname); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_READ_FILE, pathname); |
| | | badFileCount++; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_PARSE_TEMPLATE_FILE.get( |
| | | templateFile.getValue(), e.getMessage()); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_PARSE_TEMPLATE_FILE, templateFile.getValue(), e.getMessage()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | { |
| | | LocalizableMessage msg = ERR_LDIFIMPORT_CANNOT_PARSE_THREAD_COUNT.get( |
| | | threadCount.getValue(), e.getMessage()); |
| | | logError(msg); |
| | | logger.error(msg); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_OPEN_REJECTS_FILE.get( |
| | | rejectFile.getValue(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_REJECTS_FILE, rejectFile.getValue(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_OPEN_SKIP_FILE.get( |
| | | skipFile.getValue(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_OPEN_SKIP_FILE, skipFile.getValue(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | { |
| | | message = ERR_LDIFIMPORT_ERROR_DURING_IMPORT.get(de.getMessageObject()); |
| | | } |
| | | logError(message); |
| | | logger.error(message); |
| | | retCode = 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LDIFIMPORT_ERROR_DURING_IMPORT.get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_LDIFIMPORT_ERROR_DURING_IMPORT, getExceptionMessage(e)); |
| | | retCode = 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | retCode = 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_LDIFIMPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | retCode = 1; |
| | | } |
| | | |
| | |
| | | package org.opends.server.tools; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.logError; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | */ |
| | | public class RebuildIndex extends TaskTool |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private StringArgument configClass = null; |
| | | private StringArgument configFile = null; |
| | | private StringArgument baseDNString = null; |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | final LocalizableMessage message = |
| | | ERR_CANNOT_DECODE_BASE_DN.get(dn, |
| | | logger.error(ERR_CANNOT_DECODE_BASE_DN, dn, |
| | | getExceptionMessage(e)); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(LocalizableMessage.raw(e.getMessage())); |
| | | logger.error(LocalizableMessage.raw(e.getMessage())); |
| | | return false; |
| | | } |
| | | |
| | |
| | | final StringBuilder failureReason = new StringBuilder(); |
| | | if (!LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | final LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND, backend |
| | | .getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | final LocalizableMessage message = |
| | | ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND.get(backend |
| | | logger.error(ERR_REBUILDINDEX_CANNOT_EXCLUSIVE_LOCK_BACKEND, backend |
| | | .getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (InitializationException e) |
| | | { |
| | | logError(ERR_REBUILDINDEX_ERROR_DURING_REBUILD.get(e.getMessage())); |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD.get(e.getMessage())); |
| | | returnCode = 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(ERR_REBUILDINDEX_ERROR_DURING_REBUILD |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD |
| | | .get(getExceptionMessage(e))); |
| | | returnCode = 1; |
| | | } |
| | |
| | | final StringBuilder failureReason = new StringBuilder(); |
| | | if (!LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | logError(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | logger.warn(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | .getBackendID(), String.valueOf(failureReason))); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logError(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | logger.error(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | .getBackendID(), getExceptionMessage(e))); |
| | | } |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.tools; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | |
| | | import org.opends.server.util.args.LDAPConnectionArgumentParser; |
| | | import org.opends.server.util.cli.CLIException; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | * internally within the server process (e.g., via the tasks interface). |
| | | */ |
| | | public class RestoreDB extends TaskTool { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The main method for RestoreDB tool. |
| | | * |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_READ_BACKUP_DIRECTORY.get( |
| | | backupDirectory.getValue(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_READ_BACKUP_DIRECTORY, backupDirectory.getValue(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | BackupInfo backupInfo = backupDir.getLatestBackup(); |
| | | if (backupInfo == null) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_NO_BACKUPS_IN_DIRECTORY.get( |
| | | backupDirectory.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_NO_BACKUPS_IN_DIRECTORY, backupDirectory.getValue()); |
| | | return 1; |
| | | } |
| | | backupID = backupInfo.getBackupID(); |
| | |
| | | backupInfo = backupDir.getBackupInfo(backupID); |
| | | if (backupInfo == null) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_INVALID_BACKUP_ID.get( |
| | | backupID, backupDirectory.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_INVALID_BACKUP_ID, backupID, backupDirectory.getValue()); |
| | | return 1; |
| | | } |
| | | } |
| | | if (backupInfo.isEncrypted() || null != backupInfo.getSignedHash()) { |
| | | LocalizableMessage message = ERR_RESTOREDB_ENCRYPT_OR_SIGN_REQUIRES_ONLINE.get(); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_ENCRYPT_OR_SIGN_REQUIRES_ONLINE); |
| | | return 1; |
| | | } |
| | | } |
| | |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_NO_BACKENDS_FOR_DN.get( |
| | | backupDirectory.getValue(), configEntryDN.toString()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_NO_BACKENDS_FOR_DN, backupDirectory.getValue(), configEntryDN.toString()); |
| | | return 1; |
| | | } |
| | | else if (! backend.supportsRestore()) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_RESTOREDB_CANNOT_RESTORE.get(backend.getBackendID()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_RESTORE, backend.getBackendID()); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireExclusiveLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_ERROR_DURING_BACKUP.get( |
| | | backupID, backupDir.getPath(), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_ERROR_DURING_BACKUP, backupID, backupDir.getPath(), de.getMessageObject()); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_RESTOREDB_ERROR_DURING_BACKUP.get( |
| | | backupID, backupDir.getPath(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_RESTOREDB_ERROR_DURING_BACKUP, backupID, backupDir.getPath(), getExceptionMessage(e)); |
| | | } |
| | | |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_RESTOREDB_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | return 0; |
| | | } |
| | |
| | | |
| | | |
| | | import org.opends.server.api.Backend; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.api.ErrorLogPublisher; |
| | | import org.opends.server.api.DebugLogPublisher; |
| | | import org.opends.server.backends.jeb.BackendImpl; |
| | |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.ToolMessages.*; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | |
| | | */ |
| | | public class VerifyIndex |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Processes the command-line arguments and invokes the verify process. |
| | | * |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DECODE_BASE_DN.get( |
| | | baseDNString.getValue(), de.getMessageObject()); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DECODE_BASE_DN, baseDNString.getValue(), de.getMessageObject()); |
| | | return 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CANNOT_DECODE_BASE_DN.get( |
| | | baseDNString.getValue(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_CANNOT_DECODE_BASE_DN, baseDNString.getValue(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_MULTIPLE_BACKENDS_FOR_BASE.get(baseDNString.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_MULTIPLE_BACKENDS_FOR_BASE, baseDNString.getValue()); |
| | | return 1; |
| | | } |
| | | break; |
| | |
| | | |
| | | if (backend == null) |
| | | { |
| | | LocalizableMessage message = ERR_NO_BACKENDS_FOR_BASE.get(baseDNString.getValue()); |
| | | logError(message); |
| | | logger.error(ERR_NO_BACKENDS_FOR_BASE, baseDNString.getValue()); |
| | | return 1; |
| | | } |
| | | |
| | | if (!(backend instanceof BackendImpl)) |
| | | { |
| | | LocalizableMessage message = ERR_BACKEND_NO_INDEXING_SUPPORT.get(); |
| | | logError(message); |
| | | logger.error(ERR_BACKEND_NO_INDEXING_SUPPORT); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.acquireSharedLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = ERR_VERIFYINDEX_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.error(ERR_VERIFYINDEX_CANNOT_LOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | return 1; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_VERIFYINDEX_CANNOT_LOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_VERIFYINDEX_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_VERIFYINDEX_ERROR_DURING_VERIFY.get( |
| | | stackTraceToSingleLineString(e)); |
| | | logError(message); |
| | | logger.error(ERR_VERIFYINDEX_ERROR_DURING_VERIFY, stackTraceToSingleLineString(e)); |
| | | returnCode = 1; |
| | | } |
| | | |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | LocalizableMessage message = WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), String.valueOf(failureReason)); |
| | | logError(message); |
| | | logger.warn(WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), String.valueOf(failureReason)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND.get( |
| | | backend.getBackendID(), getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.warn(WARN_VERIFYINDEX_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | |
| | | return returnCode; |
| | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.messages.UtilityMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.types.ResultCode.*; |
| | | import static org.opends.server.util.LDIFWriter.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN |
| | | && !multipleOCErrorLogged) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | multipleOCErrorLogged = true; |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | finally |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | finally |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | else |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else if (structuralPolicy == AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | |
| | |
| | | import java.util.HashSet; |
| | | import java.util.Set; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | import static org.opends.messages.ReplicationMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * This class defines a data structure that combines an address and port number, |
| | |
| | | catch (UnknownHostException e) |
| | | { |
| | | // We could not resolve this host name, default to the provided host name |
| | | LocalizableMessage message = ERR_COULD_NOT_SOLVE_HOSTNAME.get(host); |
| | | logError(message); |
| | | logger.error(ERR_COULD_NOT_SOLVE_HOSTNAME, host); |
| | | return host; |
| | | } |
| | | } |
| | |
| | | import static org.opends.messages.BackendMessages.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | // changes could potentially be sent to the other servers again |
| | | // when this server is restarted, which shouldn't hurt anything. |
| | | // Still, we should log a warning message. |
| | | logError(ERR_SCHEMA_CANNOT_WRITE_CONCAT_SCHEMA_FILE.get( |
| | | String.valueOf(concatFilePath), getExceptionMessage(e))); |
| | | logger.error(ERR_SCHEMA_CANNOT_WRITE_CONCAT_SCHEMA_FILE.get(String |
| | | .valueOf(concatFilePath), getExceptionMessage(e))); |
| | | } |
| | | } |
| | | |
| | |
| | | import org.opends.server.core.DirectoryServer; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | |
| | | case UNDEFINED: |
| | | return false; |
| | | default: |
| | | LocalizableMessage message = ERR_SEARCH_FILTER_INVALID_RESULT_TYPE. |
| | | get(String.valueOf(entry.getName()), toString(), |
| | | logger.error(ERR_SEARCH_FILTER_INVALID_RESULT_TYPE, String.valueOf(entry.getName()), toString(), |
| | | String.valueOf(result)); |
| | | logError(message); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | import java.security.cert.CertificateException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.security.cert.CertificateExpiredException; |
| | | import java.security.cert.CertificateNotYetValidException; |
| | | import java.security.cert.X509Certificate; |
| | |
| | | |
| | | |
| | | |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.messages.UtilityMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | |
| | | /** |
| | |
| | | public final class ExpirationCheckTrustManager |
| | | implements X509TrustManager |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // The trust manager that is wrapped by this trust manager. |
| | | private X509TrustManager trustManager; |
| | | |
| | |
| | | } |
| | | catch (CertificateExpiredException cee) |
| | | { |
| | | LocalizableMessage message = ERR_EXPCHECK_TRUSTMGR_CLIENT_CERT_EXPIRED.get( |
| | | c.getSubjectDN().getName(), String.valueOf(c.getNotAfter())); |
| | | logError(message); |
| | | logger.error(ERR_EXPCHECK_TRUSTMGR_CLIENT_CERT_EXPIRED, c |
| | | .getSubjectDN().getName(), String.valueOf(c.getNotAfter())); |
| | | |
| | | throw cee; |
| | | } |
| | | catch (CertificateNotYetValidException cnyve) |
| | | { |
| | | LocalizableMessage message = ERR_EXPCHECK_TRUSTMGR_CLIENT_CERT_NOT_YET_VALID.get( |
| | | c.getSubjectDN().getName(), String.valueOf(c.getNotBefore())); |
| | | logError(message); |
| | | logger.error(ERR_EXPCHECK_TRUSTMGR_CLIENT_CERT_NOT_YET_VALID, c |
| | | .getSubjectDN().getName(), String.valueOf(c.getNotBefore())); |
| | | |
| | | throw cnyve; |
| | | } |
| | |
| | | } |
| | | catch (CertificateExpiredException cee) |
| | | { |
| | | LocalizableMessage message = ERR_EXPCHECK_TRUSTMGR_SERVER_CERT_EXPIRED.get( |
| | | c.getSubjectDN().getName(), String.valueOf(c.getNotAfter())); |
| | | logError(message); |
| | | logger.error(ERR_EXPCHECK_TRUSTMGR_SERVER_CERT_EXPIRED, c |
| | | .getSubjectDN().getName(), String.valueOf(c.getNotAfter())); |
| | | |
| | | throw cee; |
| | | } |
| | | catch (CertificateNotYetValidException cnyve) |
| | | { |
| | | LocalizableMessage message = ERR_EXPCHECK_TRUSTMGR_SERVER_CERT_NOT_YET_VALID.get( |
| | | c.getSubjectDN().getName(), String.valueOf(c.getNotBefore())); |
| | | logError(message); |
| | | logger.error(ERR_EXPCHECK_TRUSTMGR_SERVER_CERT_NOT_YET_VALID, c |
| | | .getSubjectDN().getName(), String.valueOf(c.getNotBefore())); |
| | | |
| | | throw cnyve; |
| | | } |
| | |
| | | package org.opends.server.util; |
| | | |
| | | import static org.opends.messages.UtilityMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | import static org.forgerock.util.Reject.*; |
| | | |
| | |
| | | |
| | | if (objectClasses.containsKey(objectClass)) |
| | | { |
| | | logError(WARN_LDIF_DUPLICATE_OBJECTCLASS.get( |
| | | String.valueOf(entryDN), lastEntryLineNumber, ocName)); |
| | | logger.warn(WARN_LDIF_DUPLICATE_OBJECTCLASS.get(String.valueOf(entryDN), lastEntryLineNumber, ocName)); |
| | | } |
| | | else |
| | | { |
| | |
| | | if (DirectoryServer.getSyntaxEnforcementPolicy() == |
| | | AcceptRejectWarn.WARN) |
| | | { |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | else |
| | | { |
| | |
| | | * |
| | | * |
| | | * Copyright 2008-2009 Sun Microsystems, Inc. |
| | | * Copyright 2013 ForgeRock AS |
| | | * Copyright 2013-2014 ForgeRock AS |
| | | */ |
| | | package org.opends.server.util; |
| | | |
| | | import java.io.File; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.lang.management.ManagementFactory; |
| | | import java.lang.management.RuntimeMXBean; |
| | | import java.net.InetAddress; |
| | |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.messages.RuntimeMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.DynamicConstants.*; |
| | | |
| | | /** |
| | |
| | | */ |
| | | public class RuntimeInformation { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | |
| | | private static boolean is64Bit=false; |
| | | |
| | |
| | | String installDir = toCanonicalPath(DirectoryServer.getServerRoot()); |
| | | if (installDir == null) |
| | | { |
| | | logError(NOTE_UNKNOWN_INSTALL_DIRECTORY.get()); |
| | | logger.info(NOTE_UNKNOWN_INSTALL_DIRECTORY.get()); |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_INSTALL_DIRECTORY.get(installDir)); |
| | | logger.info(NOTE_INSTALL_DIRECTORY.get(installDir)); |
| | | } |
| | | String instanceDir = toCanonicalPath(DirectoryServer.getInstanceRoot()); |
| | | if (instanceDir == null) |
| | | { |
| | | logError(NOTE_UNKNOWN_INSTANCE_DIRECTORY.get()); |
| | | logger.info(NOTE_UNKNOWN_INSTANCE_DIRECTORY.get()); |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_INSTANCE_DIRECTORY.get(instanceDir)); |
| | | logger.info(NOTE_INSTANCE_DIRECTORY.get(instanceDir)); |
| | | } |
| | | logError(NOTE_JVM_INFO.get(System.getProperty("java.runtime.version"), |
| | | logger.info(NOTE_JVM_INFO.get(System.getProperty("java.runtime.version"), |
| | | System.getProperty("java.vendor"), |
| | | getArch(),Runtime.getRuntime().maxMemory())); |
| | | long physicalMemorySize = getPhysicalMemorySize(); |
| | | if (physicalMemorySize != -1) |
| | | { |
| | | logError(NOTE_JVM_HOST.get(getHostName(), getOSInfo(), |
| | | logger.info(NOTE_JVM_HOST.get(getHostName(), getOSInfo(), |
| | | physicalMemorySize, Runtime.getRuntime().availableProcessors())); |
| | | } |
| | | else |
| | | { |
| | | logError(NOTE_JVM_HOST_WITH_UNKNOWN_PHYSICAL_MEM.get(getHostName(), |
| | | logger.info(NOTE_JVM_HOST_WITH_UNKNOWN_PHYSICAL_MEM.get(getHostName(), |
| | | getOSInfo(), Runtime.getRuntime().availableProcessors())); |
| | | } |
| | | logError(NOTE_JVM_ARGS.get(getInputArguments())); |
| | | logger.info(NOTE_JVM_ARGS.get(getInputArguments())); |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.replication.protocol.StartECLSessionMsg |
| | | .ECLRequestType.*; |
| | | import static org.opends.server.replication.protocol.StartECLSessionMsg |
| | |
| | | // Unable to decode the message - log an error. |
| | | logger.traceException(e); |
| | | |
| | | logError(LocalizableMessage.raw("An exception was encountered while try to encode a " |
| | | logger.error(LocalizableMessage.raw("An exception was encountered while try to encode a " |
| | | + "replication add message for entry \"" |
| | | + addMsg.getDN() |
| | | + "\" into an External Change Log entry: " |
| | |
| | | // Unable to decode the message - log an error. |
| | | logger.traceException(e); |
| | | |
| | | logError(LocalizableMessage.raw("An exception was encountered while try to encode a " |
| | | logger.error(LocalizableMessage.raw("An exception was encountered while try to encode a " |
| | | + "replication modify message for entry \"" |
| | | + modifyMsg.getDN() |
| | | + "\" into an External Change Log entry: " |
| | |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(ERR_ADD_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | logger.error(ERR_ADD_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | .get(getExceptionMessage(e))); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logError(ERR_ADD_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | logger.error(ERR_ADD_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de))); |
| | | throw de; |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logError(ERR_ADD_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_ADD_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | throw de; |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | logError(ERR_ADD_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_ADD_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | break; |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logError(message); |
| | | logger.error(message); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logError(cannotProcessAttributeMessage.get(v.getValue().toString(), |
| | | logger.error(cannotProcessAttributeMessage.get(v.getValue().toString(), |
| | | String.valueOf(userEntry.getName()))); |
| | | } |
| | | } |
| | | else if (a.size() > 1) |
| | | { |
| | | logError(nonUniqueAttributeMessage.get(String |
| | | logger.error(nonUniqueAttributeMessage.get(String |
| | | .valueOf(userEntry.getName()))); |
| | | } |
| | | } |
| | |
| | | package org.opends.server.workflowelement.localbackend; |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_DELETE_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | .get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_DELETE_ERROR_NOTIFYING_CHANGE_LISTENER, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_DELETE_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | getConnectionID(), getOperationID(), |
| | | logger.error(ERR_DELETE_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_DELETE_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_DELETE_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return; |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_DELETE_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_DELETE_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | import org.opends.server.types.operation.PreOperationModifyDNOperation; |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_MODDN_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | .get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_MODDN_ERROR_NOTIFYING_CHANGE_LISTENER, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODDN_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | getConnectionID(), getOperationID(), |
| | | logger.error(ERR_MODDN_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | |
| | | setResponseData(de); |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODDN_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_MODDN_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODDN_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_MODDN_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return; |
| | |
| | | |
| | | import static org.opends.messages.CoreMessages.*; |
| | | import static org.opends.server.config.ConfigConstants.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | import static org.opends.server.util.ServerConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_MODIFY_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | .get(getExceptionMessage(e)); |
| | | logError(message); |
| | | logger.error(ERR_MODIFY_ERROR_NOTIFYING_CHANGE_LISTENER, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | if (!syntax.isHumanReadable() || syntax.isBinary()) |
| | | { |
| | | // Value is not human-readable |
| | | logError(ERR_MODIFY_ADD_INVALID_SYNTAX_NO_VALUE.get( |
| | | String.valueOf(entryDN), attr.getName(), invalidReason)); |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX_NO_VALUE.get(String |
| | | .valueOf(entryDN), attr.getName(), invalidReason)); |
| | | } |
| | | else |
| | | { |
| | | logError(ERR_MODIFY_ADD_INVALID_SYNTAX.get(String |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX.get(String |
| | | .valueOf(entryDN), attr.getName(), v.getValue().toString(), |
| | | invalidReason)); |
| | | } |
| | |
| | | if (!syntax.isHumanReadable() || syntax.isBinary()) |
| | | { |
| | | // Value is not human-readable |
| | | logError(ERR_MODIFY_REPLACE_INVALID_SYNTAX_NO_VALUE.get(String |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX_NO_VALUE.get(String |
| | | .valueOf(entryDN), attr.getName(), invalidReason)); |
| | | } |
| | | else |
| | | { |
| | | logError(ERR_MODIFY_REPLACE_INVALID_SYNTAX.get(String |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX.get(String |
| | | .valueOf(entryDN), attr.getName(), v.getValue().toString(), |
| | | invalidReason)); |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODIFY_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | getConnectionID(), getOperationID(), |
| | | logger.error(ERR_MODIFY_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODIFY_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_MODIFY_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logError(ERR_MODIFY_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | logger.error(ERR_MODIFY_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | setResponseData(de); |
| | | return; |
| | |
| | | package org.opends.server.snmp; |
| | | |
| | | import com.sun.management.comm.CommunicatorServer; |
| | | |
| | | import java.io.File; |
| | | |
| | | import org.opends.server.loggers.debug.DebugLogger; |
| | | import org.opends.server.loggers.debug.DebugTracer; |
| | | import org.opends.server.types.DebugLogLevel; |
| | | |
| | | import static org.opends.server.loggers.debug.DebugLogger.*; |
| | | |
| | | import com.sun.management.comm.SnmpV3AdaptorServer; |
| | | import com.sun.management.snmp.InetAddressAcl; |
| | |
| | | import java.net.InetAddress; |
| | | import java.net.UnknownHostException; |
| | | import java.util.SortedSet; |
| | | |
| | | import javax.management.MBeanServer; |
| | | import javax.management.ObjectName; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.admin.std.server.SNMPConnectionHandlerCfg; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.types.ConfigChangeResult; |
| | |
| | | import org.forgerock.util.Reject; |
| | | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | | /** |
| | | * The SNMPClassLoaderProvider. |
| | | */ |
| | | public class SNMPClassLoaderProvider { |
| | | |
| | | /** |
| | | * The debug log tracer for this class. |
| | | */ |
| | | private static final DebugTracer TRACER = DebugLogger.getTracer(); |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The current configuration state. |
| | | */ |
| | |
| | | } |
| | | } |
| | | } catch (Exception ex) { |
| | | if (debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | logger.traceException(ex); |
| | | } |
| | | |
| | | // Check if the security file |
| | |
| | | this.currentConfig.getTrapsDestination()); |
| | | |
| | | if (this.sentTraps == false) { |
| | | LocalizableMessage message = |
| | | ERR_SNMP_CONNHANDLER_NO_VALID_TRAP_DESTINATIONS.get(); |
| | | logError(message); |
| | | logger.error(ERR_SNMP_CONNHANDLER_NO_VALID_TRAP_DESTINATIONS); |
| | | } else { |
| | | // Send a coldStart SNMP Trap. |
| | | this.snmpAdaptor.setTrapPort(snmpTrapPort); |
| | |
| | | 0, |
| | | null); |
| | | } |
| | | String[] names = this.snmpAdaptor.getMibs(); |
| | | this.snmpAdaptor.getMibs(); |
| | | |
| | | // Stop the SNMP Adaptor |
| | | this.snmpAdaptor.stop(); |
| | |
| | | this.server.unregisterMBean(this.UsmObjName); |
| | | } |
| | | } catch (Exception ex) { |
| | | if (debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | logger.traceException(ex); |
| | | } |
| | | } |
| | | |
| | |
| | | engineParameters.activateEncryption(); |
| | | |
| | | // Create the UACL controller |
| | | UserAcl uacls = (UserAcl) new SNMPUserAcl(configuration); |
| | | UserAcl uacls = new SNMPUserAcl(configuration); |
| | | engineParameters.setUserAcl(uacls); |
| | | |
| | | // V1/V2 Security parameters |
| | | InetAddressAcl acls = |
| | | (InetAddressAcl) new SNMPInetAddressAcl(configuration); |
| | | new SNMPInetAddressAcl(configuration); |
| | | |
| | | adaptor = new SnmpV3AdaptorServer(engineParameters, null, acls, |
| | | configuration.getListenPort(), null); |
| | |
| | | |
| | | return adaptor; |
| | | } catch (Exception ex) { |
| | | TRACER.debugError("Could not instanciate the SNMP Adaptor"); |
| | | logger.trace("Could not instanciate the SNMP Adaptor"); |
| | | return null; |
| | | } |
| | | } |
| | |
| | | boolean found = false; |
| | | for (String dest : destinations) { |
| | | try { |
| | | InetAddress addr = InetAddress.getByName(dest); |
| | | InetAddress.getByName(dest); |
| | | found = true; |
| | | } catch (UnknownHostException ex) { |
| | | LocalizableMessage message = ERR_SNMP_CONNHANDLER_TRAPS_DESTINATION.get( |
| | | dest); |
| | | logError(message); |
| | | logger.error(ERR_SNMP_CONNHANDLER_TRAPS_DESTINATION, dest); |
| | | } |
| | | } |
| | | return found; |
| | |
| | | import java.util.LinkedHashMap; |
| | | import java.util.LinkedList; |
| | | import java.util.List; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.admin.server.ConfigurationChangeListener; |
| | | import org.opends.server.api.AlertGenerator; |
| | | import org.opends.server.api.ClientConnection; |
| | |
| | | import org.opends.server.types.ConfigChangeResult; |
| | | import org.opends.server.types.DN; |
| | | import org.opends.server.types.HostPort; |
| | | |
| | | import org.opends.server.admin.std.server.SNMPConnectionHandlerCfg; |
| | | |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.opends.server.types.InitializationException; |
| | | |
| | | import static org.opends.messages.ProtocolMessages.*; |
| | | import static org.opends.server.loggers.ErrorLogger.*; |
| | | |
| | |
| | | implements ConfigurationChangeListener<SNMPConnectionHandlerCfg>, |
| | | AlertGenerator { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | // Current configuration |
| | | SNMPConnectionHandlerCfg currentConfig; |
| | | /** |
| | |
| | | throws ConfigException, InitializationException { |
| | | |
| | | if (configuration == null) { |
| | | LocalizableMessage message = ERR_SNMP_CONNHANDLER_NO_CONFIGURATION.get(); |
| | | logError(message); |
| | | logger.error(ERR_SNMP_CONNHANDLER_NO_CONFIGURATION); |
| | | return; |
| | | } |
| | | |
| | |
| | | |
| | | String jarLocation = this.currentConfig.getOpendmkJarfile(); |
| | | if ((jarLocation==null) || (jarLocation.length()==0)){ |
| | | LocalizableMessage message = ERR_SNMP_CONNHANDLER_NO_OPENDMK_JARFILES.get(); |
| | | logError(message); |
| | | logger.error(ERR_SNMP_CONNHANDLER_NO_OPENDMK_JARFILES); |
| | | return; |
| | | } |
| | | |
| | |
| | | } |
| | | |
| | | if (!fullpathFile.exists()) { |
| | | LocalizableMessage message = |
| | | ERR_SNMP_CONNHANDLER_OPENDMK_JARFILES_DOES_NOT_EXIST.get( |
| | | logger.error(ERR_SNMP_CONNHANDLER_OPENDMK_JARFILES_DOES_NOT_EXIST, |
| | | fullpathFile.getAbsolutePath()); |
| | | logError(message); |
| | | return; |
| | | } |
| | | |
| | |
| | | this.currentConfig.getListenPort())); |
| | | |
| | | if (!this.isOperational(fullpathFile)) { |
| | | LocalizableMessage message = |
| | | ERR_SNMP_CONNHANDLER_OPENDMK_JARFILES_NOT_OPERATIONAL.get( |
| | | logger.error(ERR_SNMP_CONNHANDLER_OPENDMK_JARFILES_NOT_OPERATIONAL, |
| | | fullpathFile.getAbsolutePath()); |
| | | logError(message); |
| | | return; |
| | | } |
| | | |
| | |
| | | this.provider.initializeConnectionHandler(this.currentConfig); |
| | | } |
| | | catch (Exception ex) { |
| | | LocalizableMessage message = ERR_SNMP_CONNHANDLER_BAD_CONFIGURATION.get(); |
| | | logError(message); |
| | | logger.error(ERR_SNMP_CONNHANDLER_BAD_CONFIGURATION); |
| | | return; |
| | | } |
| | | } |
| | |
| | | try { |
| | | String url = "jar:" + file.toURI().toURL() + "!/"; |
| | | URL u = new URL(url); |
| | | Class[] parameters = new Class[]{URL.class}; |
| | | URLClassLoader sysloader = |
| | | (URLClassLoader)ClassLoader.getSystemClassLoader(); |
| | | Class sysclass = URLClassLoader.class; |
| | |
| | | * |
| | | * |
| | | * Copyright 2008 Sun Microsystems, Inc. |
| | | * Portions Copyright 2012 ForgeRock Inc. |
| | | * Portions Copyright 2012-2014 ForgeRock Inc. |
| | | */ |
| | | package org.opends.server.snmp; |
| | | |
| | | import com.sun.management.snmp.SnmpStatusException; |
| | | import java.security.PrivilegedAction; |
| | | |
| | | |
| | | import java.util.HashSet; |
| | | import java.util.Iterator; |
| | | import java.util.Set; |
| | |
| | | import javax.management.MBeanServer; |
| | | import javax.management.ObjectName; |
| | | import javax.security.auth.Subject; |
| | | import org.opends.server.loggers.debug.DebugLogger; |
| | | import org.opends.server.loggers.debug.DebugTracer; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.opends.server.protocols.internal.InternalClientConnection; |
| | | import org.opends.server.protocols.jmx.Credential; |
| | | import org.opends.server.protocols.jmx.OpendsJmxPrincipal; |
| | | import org.opends.server.types.DebugLogLevel; |
| | | |
| | | import com.sun.management.snmp.SnmpStatusException; |
| | | |
| | | /** |
| | | * The SNMPMonitor Class allows to get a singleton SNMPMonitor object allowing |
| | | * to access the JMX cn=monitor MBean. |
| | | */ |
| | | public class SNMPMonitor { |
| | | public class SNMPMonitor |
| | | { |
| | | |
| | | /** |
| | | * Debug Tracer for this class. |
| | | */ |
| | | private static final DebugTracer TRACER = DebugLogger.getTracer(); |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * Singleton SNMPMonitor object. |
| | | */ |
| | |
| | | */ |
| | | public static ObjectName pattern; |
| | | |
| | | static { |
| | | try { |
| | | pattern = new ObjectName( |
| | | SNMPConnectionHandlerDefinitions.JMX_DOMAIN + |
| | | "Name=rootDSE,Rdn1=cn-monitor,*"); |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | static |
| | | { |
| | | try |
| | | { |
| | | pattern = |
| | | new ObjectName(SNMPConnectionHandlerDefinitions.JMX_DOMAIN |
| | | + "Name=rootDSE,Rdn1=cn-monitor,*"); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Creates an SNMPMonitor object mapping. |
| | | * @param server to use to the mapping |
| | | * |
| | | * @param server |
| | | * to use to the mapping |
| | | */ |
| | | private SNMPMonitor(MBeanServer server) { |
| | | private SNMPMonitor(MBeanServer server) |
| | | { |
| | | this.server = server; |
| | | this.subject = new Subject(); |
| | | this.subject.getPrincipals().add(new OpendsJmxPrincipal("cn=anonymous")); |
| | |
| | | |
| | | /** |
| | | * Gets the singleton SNMPMonitor object. |
| | | * @param server The server |
| | | * |
| | | * @param server |
| | | * The server |
| | | * @return the SNMPMonitor mapping object. |
| | | */ |
| | | public static SNMPMonitor getMonitor(MBeanServer server) { |
| | | if (monitor == null) { |
| | | public static SNMPMonitor getMonitor(MBeanServer server) |
| | | { |
| | | if (monitor == null) |
| | | { |
| | | monitor = new SNMPMonitor(server); |
| | | } |
| | | return monitor; |
| | |
| | | |
| | | /** |
| | | * Gets the Connection Handlers Statistics MBean. |
| | | * @return the Set of Connection Handlers Statistics. |
| | | * If Statistics do not exist then an empty Set is returned |
| | | * |
| | | * @return the Set of Connection Handlers Statistics. If Statistics do not |
| | | * exist then an empty Set is returned |
| | | */ |
| | | public Set<ObjectName> getConnectionHandlersStatistics() { |
| | | public Set<ObjectName> getConnectionHandlersStatistics() |
| | | { |
| | | Set<ObjectName> results = new HashSet<ObjectName>(); |
| | | try { |
| | | try |
| | | { |
| | | Set monitorObjects = this.server.queryNames(SNMPMonitor.pattern, null); |
| | | for (Iterator iter = monitorObjects.iterator(); iter.hasNext();) { |
| | | for (Iterator iter = monitorObjects.iterator(); iter.hasNext();) |
| | | { |
| | | ObjectName name = (ObjectName) iter.next(); |
| | | if ((name.getCanonicalName().contains("Connection_Handler")) && |
| | | (name.getCanonicalName().endsWith("_Statistics"))) { |
| | | if ((name.getCanonicalName().contains("Connection_Handler")) |
| | | && (name.getCanonicalName().endsWith("_Statistics"))) |
| | | { |
| | | results.add(name); |
| | | } |
| | | } |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return results; |
| | | } |
| | | |
| | | /** |
| | | * Return the ObjectName of the Connection Handler corresponding to |
| | | * the statistics name. |
| | | * @param statistics ObjectName |
| | | * Return the ObjectName of the Connection Handler corresponding to the |
| | | * statistics name. |
| | | * |
| | | * @param statistics |
| | | * ObjectName |
| | | * @return the Connection Handler ObjectName, null otherwise |
| | | */ |
| | | public ObjectName getConnectionHandler(ObjectName statistics) { |
| | | public ObjectName getConnectionHandler(ObjectName statistics) |
| | | { |
| | | |
| | | // Check parameter |
| | | if (statistics == null) { |
| | | if (statistics == null) |
| | | { |
| | | return null; |
| | | } |
| | | |
| | | try { |
| | | try |
| | | { |
| | | String value = statistics.getCanonicalName(); |
| | | if (!value.endsWith("_Statistics")) { |
| | | if (!value.endsWith("_Statistics")) |
| | | { |
| | | return null; |
| | | } |
| | | int index = value.indexOf("_Statistics"); |
| | |
| | | |
| | | // Check if the MBean exists |
| | | Set query = this.server.queryNames(connectionHandlerName, null); |
| | | if ((query != null) && (!query.isEmpty())) { |
| | | if ((query != null) && (!query.isEmpty())) |
| | | { |
| | | return connectionHandlerName; |
| | | } |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | /** |
| | | * Return a Set of Connection Handler ObjectNames. |
| | | * |
| | | * @return the Set of ObjectNames, an empty Set if no connection handlers |
| | | */ |
| | | public Set<ObjectName> getConnectionHandlers() { |
| | | public Set<ObjectName> getConnectionHandlers() |
| | | { |
| | | Set monitorObjects; |
| | | Set<ObjectName> results = new HashSet<ObjectName>(); |
| | | try { |
| | | try |
| | | { |
| | | monitorObjects = this.server.queryNames(SNMPMonitor.pattern, null); |
| | | for (Iterator iter = monitorObjects.iterator(); iter.hasNext();) { |
| | | for (Iterator iter = monitorObjects.iterator(); iter.hasNext();) |
| | | { |
| | | ObjectName name = (ObjectName) iter.next(); |
| | | if ((name.getCanonicalName().contains("Connection_Handler")) && |
| | | (!(name.getCanonicalName().endsWith("_Statistics"))) && |
| | | (name.getKeyProperty("Rdn3") == null)) { |
| | | if ((name.getCanonicalName().contains("Connection_Handler")) |
| | | && (!(name.getCanonicalName().endsWith("_Statistics"))) |
| | | && (name.getKeyProperty("Rdn3") == null)) |
| | | { |
| | | results.add(name); |
| | | } |
| | | } |
| | | return results; |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return results; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Returns the ObjectName of the Statistics Connection Handler name. |
| | | * corresponding to the Connection Handler name |
| | | * @param connectionHandlerName The connection handler name |
| | | * @return the ObjectName of the statistics ObjectName, |
| | | * null if the statistics could not be found |
| | | * |
| | | * @param connectionHandlerName |
| | | * The connection handler name |
| | | * @return the ObjectName of the statistics ObjectName, null if the statistics |
| | | * could not be found |
| | | */ |
| | | public ObjectName getConnectionHandlerStatistics( |
| | | ObjectName connectionHandlerName) { |
| | | ObjectName connectionHandlerName) |
| | | { |
| | | |
| | | if (connectionHandlerName == null) { |
| | | if (connectionHandlerName == null) |
| | | { |
| | | return null; |
| | | } |
| | | try { |
| | | try |
| | | { |
| | | String value = |
| | | connectionHandlerName.getCanonicalName().concat("_Statistics"); |
| | | ObjectName statistics = new ObjectName(value); |
| | | // Check if the MBean exists |
| | | Set query = this.server.queryNames(statistics, null); |
| | | if ((query != null) && (!query.isEmpty())) { |
| | | if ((query != null) && (!query.isEmpty())) |
| | | { |
| | | return statistics; |
| | | } |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return null; |
| | | } |
| | | |
| | | /** |
| | | * Get the value of the attribute. |
| | | * @param name of Mbean as a String |
| | | * @param attribute to look for |
| | | * @return the value of the attribute, null if the attribute could not |
| | | * be found |
| | | * |
| | | * @param name |
| | | * of Mbean as a String |
| | | * @param attribute |
| | | * to look for |
| | | * @return the value of the attribute, null if the attribute could not be |
| | | * found |
| | | */ |
| | | public Object getAttribute(String name, String attribute) { |
| | | try { |
| | | ObjectName objName = new ObjectName( |
| | | SNMPConnectionHandlerDefinitions.JMX_DOMAIN + |
| | | "Name=" + name); |
| | | public Object getAttribute(String name, String attribute) |
| | | { |
| | | try |
| | | { |
| | | ObjectName objName = |
| | | new ObjectName(SNMPConnectionHandlerDefinitions.JMX_DOMAIN + "Name=" |
| | | + name); |
| | | return getAttribute(objName, attribute); |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return null; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Gets the value of an attribute. |
| | | * @param name of the Mbean |
| | | * @param attribute to look for |
| | | * |
| | | * @param name |
| | | * of the Mbean |
| | | * @param attribute |
| | | * to look for |
| | | * @return the value of the attribute, null if the attribute value could not |
| | | * be found |
| | | */ |
| | | @SuppressWarnings("unchecked") |
| | | public Object getAttribute(final ObjectName name, final String attribute) { |
| | | return Subject.doAs(this.subject, new PrivilegedAction() { |
| | | public Object getAttribute(final ObjectName name, final String attribute) |
| | | { |
| | | return Subject.doAs(this.subject, new PrivilegedAction() |
| | | { |
| | | |
| | | public Object run() { |
| | | try { |
| | | public Object run() |
| | | { |
| | | try |
| | | { |
| | | Attribute attr = (Attribute) server.getAttribute(name, attribute); |
| | | if (attr != null) { |
| | | if (attr != null) |
| | | { |
| | | return attr.getValue(); |
| | | } |
| | | } catch (Exception ex) { |
| | | if (DebugLogger.debugEnabled()) { |
| | | TRACER.debugCaught(DebugLogLevel.ERROR, ex); |
| | | } |
| | | catch (Exception ex) |
| | | { |
| | | logger.traceException(ex); |
| | | } |
| | | return null; |
| | | } |
| | |
| | | |
| | | /** |
| | | * Wrapper for SNMP Byte[]. |
| | | * @param s value string |
| | | * |
| | | * @param s |
| | | * value string |
| | | * @return a Byte[] |
| | | */ |
| | | public static Byte[] string2ByteArray(String s) { |
| | | public static Byte[] string2ByteArray(String s) |
| | | { |
| | | byte[] b = s.getBytes(); |
| | | Byte[] barray = new Byte[b.length]; |
| | | for (int index=0; index<b.length; index++) { |
| | | for (int index = 0; index < b.length; index++) |
| | | { |
| | | barray[index] = new Byte(b[index]); |
| | | } |
| | | return barray; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Wrapper for SNMP Counter32. |
| | | * @param v value |
| | | * |
| | | * @param v |
| | | * value |
| | | * @return a counter32 |
| | | */ |
| | | public static long counter32Value(long v) { |
| | | if (v > (pow(2, 32) - 1)) { |
| | | public static long counter32Value(long v) |
| | | { |
| | | if (v > (pow(2, 32) - 1)) |
| | | { |
| | | return (v % pow(2, 32)); |
| | | } else { |
| | | } |
| | | else |
| | | { |
| | | return v; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Wrapper for SNMP Counter32. |
| | | * @param V Value |
| | | * |
| | | * @param V |
| | | * Value |
| | | * @return a Counter32 |
| | | */ |
| | | public static Long counter32Value(Long V) { |
| | | public static Long counter32Value(Long V) |
| | | { |
| | | long v = V.longValue(); |
| | | if (v > (pow(2, 32) - 1)) { |
| | | if (v > (pow(2, 32) - 1)) |
| | | { |
| | | return new Long(v % pow(2, 32)); |
| | | } else { |
| | | } |
| | | else |
| | | { |
| | | return V; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Latcher for SNMP Gauge32. |
| | | * @param v value |
| | | * |
| | | * @param v |
| | | * value |
| | | * @return a gauge32 |
| | | */ |
| | | public static long gauge32Value(long v) { |
| | | if (v > (pow(2, 32) - 1)) { |
| | | public static long gauge32Value(long v) |
| | | { |
| | | if (v > (pow(2, 32) - 1)) |
| | | { |
| | | return (pow(2, 32) - 1); |
| | | } else { |
| | | } |
| | | else |
| | | { |
| | | return v; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Latcher for SNMP Gauge32. |
| | | * @param V value |
| | | * |
| | | * @param V |
| | | * value |
| | | * @return a gauge32 |
| | | */ |
| | | public static Long gauge32Value(Long V) { |
| | | public static Long gauge32Value(Long V) |
| | | { |
| | | long v = V.longValue(); |
| | | if (v > (pow(2, 32) - 1)) { |
| | | if (v > (pow(2, 32) - 1)) |
| | | { |
| | | return new Long(pow(2, 32) - 1); |
| | | } else { |
| | | } |
| | | else |
| | | { |
| | | return V; |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Checker for SNMP INTEGER. |
| | | * @param V value |
| | | * |
| | | * @param V |
| | | * value |
| | | * @return an Integer |
| | | * @throws com.sun.management.snmp.SnmpStatusException If an error occurs |
| | | * @throws com.sun.management.snmp.SnmpStatusException |
| | | * If an error occurs |
| | | */ |
| | | public static Integer integerValue(Long V) throws SnmpStatusException { |
| | | public static Integer integerValue(Long V) throws SnmpStatusException |
| | | { |
| | | long v = V.longValue(); |
| | | if (v > (pow(2, 31) - 1)) { |
| | | if (v > (pow(2, 31) - 1)) |
| | | { |
| | | throw new SnmpStatusException("Returned intrumented value size too big"); |
| | | } |
| | | Integer ret = new Integer(V.intValue()); |
| | |
| | | /** |
| | | * pow x^y. |
| | | */ |
| | | private static long pow(long x, long y) { |
| | | private static long pow(long x, long y) |
| | | { |
| | | int j = 1; |
| | | long k = x; |
| | | if (y == 0) { |
| | | if (y == 0) |
| | | { |
| | | return 1; |
| | | } |
| | | if (y == 1) { |
| | | if (y == 1) |
| | | { |
| | | return x; |
| | | } |
| | | while (j < y) { |
| | | while (j < y) |
| | | { |
| | | k = k * x; |
| | | j++; |
| | | } |
| | |
| | | |
| | | |
| | | import java.io.IOException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | | import java.util.Set; |
| | |
| | | public class DisconnectClientPlugin |
| | | extends DirectoryServerPlugin<PluginCfg> |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * The OID for the disconnect request control, which is used to flag |
| | | * operations that should cause the client connection to be terminated. |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | ErrorLogger.logError(LocalizableMessage.raw("Unable to decode the disconnect client control: " + |
| | | logger.error(LocalizableMessage.raw("Unable to decode the disconnect client control: " + |
| | | e)); |
| | | } |
| | | |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw("** TEST **" + s)); |
| | | logger.error(LocalizableMessage.raw("** TEST **" + s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void log(String s) |
| | | { |
| | | logError(LocalizableMessage.raw("InitOnLineTests/" + s)); |
| | | logger.error(LocalizableMessage.raw("InitOnLineTests/" + s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace(s); |
| | |
| | | package org.opends.server.replication; |
| | | |
| | | import java.net.SocketTimeoutException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.List; |
| | | import java.util.NoSuchElementException; |
| | | |
| | |
| | | @SuppressWarnings("javadoc") |
| | | public class ProtocolWindowTest extends ReplicationTestCase |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | private static final int WINDOW_SIZE = 10; |
| | | private static final int REPLICATION_QUEUE_SIZE = 100; |
| | | |
| | |
| | | @Test(enabled=true, groups="slow") |
| | | public void saturateQueueAndRestart() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Starting Replication ProtocolWindowTest : saturateAndRestart")); |
| | | logger.error(LocalizableMessage.raw("Starting Replication ProtocolWindowTest : saturateAndRestart")); |
| | | |
| | | // suffix synchronized |
| | | String testName = "protocolWindowTest"; |
| | |
| | | if (op.getResultCode() != ResultCode.SUCCESS |
| | | && op.getResultCode() != ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | logError(LocalizableMessage.raw("saturateQueueAndRestart: error cleaning config entry: " + dn)); |
| | | logger.error(LocalizableMessage.raw("saturateQueueAndRestart: error cleaning config entry: " + dn)); |
| | | } |
| | | } catch (NoSuchElementException e) |
| | | { |
| | | logError(LocalizableMessage.raw("saturateQueueAndRestart: error cleaning config entry: " + dn)); |
| | | logger.error(LocalizableMessage.raw("saturateQueueAndRestart: error cleaning config entry: " + dn)); |
| | | } |
| | | clearChangelogDB(replicationServer); |
| | | } |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace(s); |
| | |
| | | */ |
| | | protected void cleanConfigEntries() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("ReplicationTestCase/Cleaning config entries")); |
| | | logger.error(LocalizableMessage.raw("ReplicationTestCase/Cleaning config entries")); |
| | | |
| | | for (DN dn : configEntriesToCleanup) |
| | | { |
| | |
| | | */ |
| | | protected void cleanRealEntries() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("ReplicationTestCase/Cleaning entries")); |
| | | logger.error(LocalizableMessage.raw("ReplicationTestCase/Cleaning entries")); |
| | | |
| | | for (DN dn : entriesToCleanup) |
| | | { |
| | |
| | | @AfterClass |
| | | public void classCleanUp() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw(" ##### Calling ReplicationTestCase.classCleanUp ##### ")); |
| | | logger.error(LocalizableMessage.raw(" ##### Calling ReplicationTestCase.classCleanUp ##### ")); |
| | | |
| | | removeReplicationServerDB(); |
| | | |
| | |
| | | */ |
| | | protected void paranoiaCheck() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Performing paranoia check")); |
| | | logger.error(LocalizableMessage.raw("Performing paranoia check")); |
| | | |
| | | // Check for config entries for replication server |
| | | assertNoConfigEntriesWithFilter("(objectclass=ds-cfg-replication-server)", |
| | |
| | | package org.opends.server.replication; |
| | | |
| | | import java.io.File; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.io.FileInputStream; |
| | | import java.util.ArrayList; |
| | | import java.util.List; |
| | |
| | | public class SchemaReplicationTest extends ReplicationTestCase |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | private List<Modification> rcvdMods; |
| | | |
| | | private int replServerPort; |
| | |
| | | @Test() |
| | | public void pushSchemaChange() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Starting replication test : pushSchemaChange ")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : pushSchemaChange ")); |
| | | |
| | | cleanUpReplicationServersDB(); |
| | | |
| | |
| | | @Test(enabled=true,dependsOnMethods = { "pushSchemaChange" }) |
| | | public void replaySchemaChange() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Starting replication test : replaySchemaChange ")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : replaySchemaChange ")); |
| | | |
| | | cleanUpReplicationServersDB(); |
| | | |
| | |
| | | @Test(enabled=true, dependsOnMethods = { "replaySchemaChange" }) |
| | | public void pushSchemaFilesChange() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Starting replication test : pushSchemaFilesChange ")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : pushSchemaFilesChange ")); |
| | | |
| | | cleanUpReplicationServersDB(); |
| | | |
| | |
| | | { |
| | | broker.stop(); |
| | | } |
| | | logError(LocalizableMessage.raw("Ending replication test : pushSchemaFilesChange ")); |
| | | logger.error(LocalizableMessage.raw("Ending replication test : pushSchemaFilesChange ")); |
| | | } |
| | | } |
| | |
| | | package org.opends.server.replication; |
| | | |
| | | import java.util.LinkedList; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.List; |
| | | |
| | | import org.assertj.core.api.Assertions; |
| | |
| | | public class StressTest extends ReplicationTestCase |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | private static final String REPLICATION_STRESS_TEST = |
| | | "Replication Stress Test"; |
| | | |
| | |
| | | @Test(enabled=false, groups="slow") |
| | | public void fromServertoBroker() throws Exception |
| | | { |
| | | logError(LocalizableMessage.raw("Starting replication StressTest : fromServertoBroker")); |
| | | logger.error(LocalizableMessage.raw("Starting replication StressTest : fromServertoBroker")); |
| | | |
| | | final DN baseDN = DN.valueOf("ou=People," + TEST_ROOT_DN_STRING); |
| | | final int TOTAL_MESSAGES = 1000; |
| | |
| | | package org.opends.server.replication; |
| | | |
| | | import java.net.SocketTimeoutException; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.ArrayList; |
| | | import java.util.Arrays; |
| | | import java.util.List; |
| | |
| | | @SuppressWarnings("javadoc") |
| | | public class UpdateOperationTest extends ReplicationTestCase |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | /** |
| | | * An entry with a entryUUID |
| | | */ |
| | |
| | | public void toggleReceiveStatus() throws Exception |
| | | { |
| | | testSetUp("toggleReceiveStatus"); |
| | | logError(LocalizableMessage.raw("Starting synchronization test : toggleReceiveStatus")); |
| | | logger.error(LocalizableMessage.raw("Starting synchronization test : toggleReceiveStatus")); |
| | | |
| | | /* |
| | | * Open a session to the replicationServer using the broker API. |
| | |
| | | public void lostHeartbeatFailover() throws Exception |
| | | { |
| | | testSetUp("lostHeartbeatFailover"); |
| | | logError(LocalizableMessage.raw("Starting replication test : lostHeartbeatFailover")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : lostHeartbeatFailover")); |
| | | |
| | | /* |
| | | * Open a session to the replicationServer using the broker API. |
| | |
| | | public void namingConflicts() throws Exception |
| | | { |
| | | testSetUp("namingConflicts"); |
| | | logError(LocalizableMessage.raw("Starting replication test : namingConflicts")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : namingConflicts")); |
| | | |
| | | String resolvedMonitorAttr = "resolved-naming-conflicts"; |
| | | String unresolvedMonitorAttr = "unresolved-naming-conflicts"; |
| | |
| | | public void updateOperations(boolean assured) throws Exception |
| | | { |
| | | testSetUp("updateOperations"); |
| | | logError(LocalizableMessage.raw("Starting replication test : updateOperations " + assured)); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : updateOperations " + assured)); |
| | | |
| | | // Cleanup from previous run |
| | | cleanupTest(); |
| | |
| | | public void deleteNoSuchObject() throws Exception |
| | | { |
| | | testSetUp("deleteNoSuchObject"); |
| | | logError(LocalizableMessage.raw("Starting replication test : deleteNoSuchObject")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : deleteNoSuchObject")); |
| | | |
| | | DeleteOperation op = connection.processDelete("cn=No Such Object," + baseDN); |
| | | assertEquals(op.getResultCode(), ResultCode.NO_SUCH_OBJECT); |
| | |
| | | public void infiniteReplayLoop() throws Exception |
| | | { |
| | | testSetUp("infiniteReplayLoop"); |
| | | logError(LocalizableMessage.raw("Starting replication test : infiniteReplayLoop")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : infiniteReplayLoop")); |
| | | |
| | | int serverId = 11; |
| | | ReplicationBroker broker = |
| | |
| | | public void csnGeneratorAdjust() throws Exception |
| | | { |
| | | testSetUp("csnGeneratorAdjust"); |
| | | logError(LocalizableMessage.raw("Starting synchronization test : CSNGeneratorAdjust")); |
| | | logger.error(LocalizableMessage.raw("Starting synchronization test : CSNGeneratorAdjust")); |
| | | |
| | | /* |
| | | * Open a session to the replicationServer using the broker API. |
| | |
| | | |
| | | if (!msgs.isEmpty()) |
| | | { |
| | | logError(LocalizableMessage.raw("Leftover messages from previous test runs " + msgs)); |
| | | logger.error(LocalizableMessage.raw("Leftover messages from previous test runs " + msgs)); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | private static String ENTRY_DN2 = "uid=1," + TEST2_ORG_DN_STRING; |
| | | |
| | | private void debugInfo(String s) { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | package org.opends.server.replication.plugin; |
| | | |
| | | import java.util.LinkedList; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import java.util.List; |
| | | import java.util.SortedSet; |
| | | import java.util.TreeSet; |
| | |
| | | public class HistoricalCsnOrderingTest extends ReplicationTestCase |
| | | { |
| | | |
| | | private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass(); |
| | | |
| | | |
| | | private final int serverId = 123; |
| | | private SortedSet<String> replServers = new TreeSet<String>(); |
| | | |
| | |
| | | final AttributeType histType = |
| | | DirectoryServer.getAttributeType(EntryHistorical.HISTORICAL_ATTRIBUTE_NAME); |
| | | |
| | | logError(LocalizableMessage.raw("Starting replication test : changesCmpTest")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : changesCmpTest")); |
| | | |
| | | // Add the first test entry. |
| | | TestCaseUtils.addEntry( |
| | |
| | | String histValue = |
| | | attrs1.get(0).iterator().next().getValue().toString(); |
| | | |
| | | logError(LocalizableMessage.raw("First historical value:" + histValue)); |
| | | logger.error(LocalizableMessage.raw("First historical value:" + histValue)); |
| | | |
| | | // Perform a 2nd modification to update the hist attribute with |
| | | // a second value |
| | |
| | | Assertions.assertThat(attrs2).isNotEmpty(); |
| | | |
| | | for (AttributeValue av : attrs2.get(0)) { |
| | | logError(LocalizableMessage.raw("Second historical value:" + av.getValue())); |
| | | logger.error(LocalizableMessage.raw("Second historical value:" + av.getValue())); |
| | | } |
| | | |
| | | LinkedList<ReplicationMsg> opList = new LinkedList<ReplicationMsg>(); |
| | |
| | | |
| | | // Build a CSN from the first modification |
| | | String hv[] = histValue.split(":"); |
| | | logError(LocalizableMessage.raw(hv[1])); |
| | | logger.error(LocalizableMessage.raw(hv[1])); |
| | | CSN fromCSN = new CSN(hv[1]); |
| | | |
| | | opList = new LinkedList<ReplicationMsg>(); |
| | |
| | | |
| | | try |
| | | { |
| | | logError(LocalizableMessage.raw("Starting replication test : changesCmpTest")); |
| | | logger.error(LocalizableMessage.raw("Starting replication test : changesCmpTest")); |
| | | |
| | | // Add 3 entries. |
| | | DN dnTest1 = DN.valueOf("cn=test1," + baseDN); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("*** TEST *** " + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | //ErrorLogger.logError(LocalizableMessage.raw("** TEST ** " + s)); |
| | | //logger.error(LocalizableMessage.raw("** TEST ** " + s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST ** " + s); |
| | |
| | | |
| | | private void debugInfo(String s) |
| | | { |
| | | logError(LocalizableMessage.raw(s)); |
| | | logger.error(LocalizableMessage.raw(s)); |
| | | if (logger.isTraceEnabled()) |
| | | { |
| | | logger.trace("** TEST **" + s); |