| | |
| | | :extensions => ["java"], |
| | | :replacements => |
| | | [ |
| | | /(logger\.\s*(trace|debug|warn|info|error)\s*\([^;]*)\s*\.toString\(\)/m, |
| | | /(logger\.\s*(?:trace|debug|warn|info|error)\s*\([^;]*)\s*\.toString\(\)/m, |
| | | '\1', |
| | | ] |
| | | } |
| | |
| | | :replacements => |
| | | [ |
| | | # Need to fix removing the last parentheses |
| | | /(logger\.\s*(trace|debug|warn|info|error)\s*\([^;]*)\s*String\s*\.\s*valueOf\s*\(/m, |
| | | /(logger\.\s*(?:trace|debug|warn|info|error)\s*\([^;]*)\s*String\s*\.\s*valueOf\s*\(/m, |
| | | '\1', |
| | | ] |
| | | } |
| | |
| | | :extensions => ["java"], |
| | | :replacements => |
| | | [ |
| | | /(logger\.\s*(trace|debug|warn|info|error)\s*\([^;]*)\s*(Character|Byte|Boolean|Short|Integer|Long|Float|Double)\s*\.\s*toString\s*\(/m, |
| | | /(logger\.\s*(?:trace|debug|warn|info|error)\s*\([^;]*)\s*(Character|Byte|Boolean|Short|Integer|Long|Float|Double)\s*\.\s*toString\s*\(/m, |
| | | '\1', |
| | | # Need to fix removing the last parentheses |
| | | /([A-Z0-9_]+\s*\.\s*get\s*\([^;]*)\s*(Character|Byte|Boolean|Short|Integer|Long|Float|Double)\s*\.\s*toString\s*\(/m, |
| | |
| | | ] |
| | | } |
| | | |
| | | LOGGER_AND_ARGN_TO_LOGGER_ONLY = { |
| | | :dirs => JAVA_DIRS, |
| | | :extensions => ["java"], |
| | | :replacements => |
| | | [ |
| | | /(logger\.\s*(?:trace|debug|warn|info|error)\s*\()\s*([A-Z0-9_]+)\s*\.\s*get\s*\(([^;]+)\)([^;]+)/m, |
| | | '\1\2, \3\4', |
| | | ] |
| | | } |
| | | |
| | | LOGGER_ISTRACEENABLED_TRACEEXCEPTION = { |
| | | :dirs => JAVA_DIRS, |
| | | :extensions => ["java"], |
| | |
| | | } |
| | | |
| | | # List of replacements to run |
| | | REPLACEMENTS = [ LOGGER_MSG_ARGN_PRIMITIVE_TOSTRING ] |
| | | REPLACEMENTS = [ LOGGER_AND_ARGN_TO_LOGGER_ONLY ] |
| | | |
| | | |
| | | ################################### Processing methods ######################################## |
| | |
| | | try { |
| | | // Log build information of extensions in the error log |
| | | String[] information = getBuildInformation(jarFile); |
| | | logger.error( |
| | | NOTE_LOG_EXTENSION_INFORMATION. |
| | | get(jarFile.getName(), |
| | | information[1], |
| | | information[2])); |
| | | logger.error(NOTE_LOG_EXTENSION_INFORMATION, jarFile.getName(), information[1], information[2]); |
| | | } catch(Exception e) { |
| | | // Do not log information for that extension |
| | | } |
| | |
| | | final DN authDN = authenticationInfo.getAuthenticationDN(); |
| | | if (operation == null) |
| | | { |
| | | logger.trace(INFO_CLIENTCONNECTION_AUDIT_HASPRIVILEGES.get( |
| | | getConnectionID(), -1L, authDN, buffer, result)); |
| | | logger.trace(INFO_CLIENTCONNECTION_AUDIT_HASPRIVILEGES, |
| | | getConnectionID(), -1L, authDN, buffer, result); |
| | | } |
| | | else |
| | | { |
| | | logger.trace(INFO_CLIENTCONNECTION_AUDIT_HASPRIVILEGES.get( |
| | | getConnectionID(), operation.getOperationID(), authDN, buffer, result)); |
| | | logger.trace(INFO_CLIENTCONNECTION_AUDIT_HASPRIVILEGES, |
| | | getConnectionID(), operation.getOperationID(), authDN, buffer, result); |
| | | } |
| | | |
| | | return result; |
| | |
| | | if (globalAcis != null) |
| | | { |
| | | aciList.addAci(DN.rootDN(), globalAcis); |
| | | logger.debug(INFO_ACI_ADD_LIST_GLOBAL_ACIS.get(globalAcis.size())); |
| | | logger.debug(INFO_ACI_ADD_LIST_GLOBAL_ACIS, globalAcis.size()); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | if (backend.getEntryCount() > 0 |
| | | && !backend.isIndexed(aciType, IndexType.PRESENCE)) |
| | | { |
| | | logger.warn(WARN_ACI_ATTRIBUTE_NOT_INDEXED.get(backend |
| | | .getBackendID(), "aci")); |
| | | logger.warn(WARN_ACI_ATTRIBUTE_NOT_INDEXED, backend.getBackendID(), "aci"); |
| | | } |
| | | |
| | | InternalClientConnection conn = |
| | |
| | | { |
| | | String saslMech = expr.substring(5); |
| | | if (DirectoryServer.getSASLMechanismHandler(saslMech) == null) { |
| | | logger.error(NOTE_ACI_SYNTAX_DUBIOUS_AUTHMETHOD_SASL_MECHANISM. |
| | | get(saslMech)); |
| | | logger.error(NOTE_ACI_SYNTAX_DUBIOUS_AUTHMETHOD_SASL_MECHANISM, saslMech); |
| | | } |
| | | return new AuthMethod(EnumAuthMethod.AUTHMETHOD_SASL, saslMech, type); |
| | | } |
| | |
| | | */ |
| | | protected void preload() |
| | | { |
| | | logger.info(NOTE_CACHE_PRELOAD_PROGRESS_START.get(jeb.getBackendID())); |
| | | logger.info(NOTE_CACHE_PRELOAD_PROGRESS_START, jeb.getBackendID()); |
| | | // Start collector thread first. |
| | | collector.start(); |
| | | // Kick off a single worker. |
| | |
| | | for (Thread thread : preloadThreads) { |
| | | thread.interrupt(); |
| | | } |
| | | logger.warn(WARN_CACHE_PRELOAD_INTERRUPTED.get(jeb.getBackendID())); |
| | | logger.warn(WARN_CACHE_PRELOAD_INTERRUPTED, jeb.getBackendID()); |
| | | } finally { |
| | | // Kill the timer task. |
| | | timer.cancel(); |
| | |
| | | } |
| | | id2subtree.open(); // No-op |
| | | |
| | | logger.info(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED.get(backend |
| | | .getBackendID())); |
| | | logger.info(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED, backend.getBackendID()); |
| | | } |
| | | |
| | | dn2uri = new DN2URI(databasePrefix + "_" + REFERRAL_DATABASE_NAME, |
| | |
| | | index.open(); |
| | | if(!index.isTrusted()) |
| | | { |
| | | logger.info(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(index.getName())); |
| | | logger.info(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD, index.getName()); |
| | | } |
| | | attrIndexMap.put(indexCfg.getAttribute(), index); |
| | | } |
| | |
| | | |
| | | if(!vlvIndex.isTrusted()) |
| | | { |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get( |
| | | vlvIndex.getName())); |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD, vlvIndex.getName()); |
| | | } |
| | | |
| | | vlvIndexMap.put(vlvIndexCfg.getName().toLowerCase(), vlvIndex); |
| | |
| | | state.putIndexTrustState(null, id2subtree, false); |
| | | id2subtree.open(); // No-op |
| | | |
| | | logger.error(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED |
| | | .get(cfg.getBackendId())); |
| | | logger.error(NOTE_JEB_SUBORDINATE_INDEXES_DISABLED, cfg.getBackendId()); |
| | | } |
| | | } |
| | | |
| | |
| | | id2children.open(); |
| | | if (!id2children.isTrusted()) |
| | | { |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2children |
| | | .getName())); |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD, id2children.getName()); |
| | | } |
| | | id2subtree = new Index(databasePrefix + "_" + ID2SUBTREE_DATABASE_NAME, |
| | | new ID2SIndexer(), state, config.getIndexEntryLimit(), 0, true, |
| | |
| | | id2subtree.open(); |
| | | if (!id2subtree.isTrusted()) |
| | | { |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD.get(id2subtree.getName())); |
| | | logger.error(NOTE_JEB_INDEX_ADD_REQUIRES_REBUILD, id2subtree.getName()); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD, name); |
| | | } |
| | | |
| | | if((rebuildRunning || trusted) && addedIDs != null && |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD, name); |
| | | } |
| | | |
| | | if((rebuildRunning || trusted) && addedIDs != null && addedIDs.size() > 0) |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD, name); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD, name); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | |
| | | setTrusted(txn, false); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD.get(name)); |
| | | logger.error(ERR_JEB_INDEX_CORRUPT_REQUIRES_REBUILD, name); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | if (oldThreadCount != threadCount) |
| | | { |
| | | logger.error( |
| | | NOTE_JEB_IMPORT_ADJUST_THREAD_COUNT.get(oldThreadCount, threadCount)); |
| | | logger.error(NOTE_JEB_IMPORT_ADJUST_THREAD_COUNT, oldThreadCount, threadCount); |
| | | } |
| | | |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TOT_MEM_BUF.get(availableMemory, phaseOneBufferCount)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TOT_MEM_BUF, availableMemory, phaseOneBufferCount); |
| | | if (tmpEnvCacheSize > 0) |
| | | { |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TMP_ENV_MEM.get(tmpEnvCacheSize)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_TMP_ENV_MEM, tmpEnvCacheSize); |
| | | } |
| | | envConfig.setConfigParam(MAX_MEMORY, Long.toString(dbCacheSize)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_DB_MEM_BUF_INFO.get(dbCacheSize, bufferSize)); |
| | | logger.info(NOTE_JEB_IMPORT_LDIF_DB_MEM_BUF_INFO, dbCacheSize, bufferSize); |
| | | } |
| | | |
| | | /** |
| | |
| | | StringBuilder failureReason = new StringBuilder(); |
| | | if (! LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get(backendID, failureReason)); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, failureReason); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e2); |
| | | |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK.get(backendID, |
| | | stackTraceToSingleLineString(e2))); |
| | | logger.warn(WARN_CONFIG_BACKEND_CANNOT_RELEASE_SHARED_LOCK, backendID, |
| | | stackTraceToSingleLineString(e2)); |
| | | // FIXME -- Do we need to send an admin alert? |
| | | } |
| | | |
| | |
| | | } |
| | | |
| | | |
| | | logger.info(NOTE_DIRECTORY_SERVER_STARTING.get(getVersionString(), |
| | | BUILD_ID, REVISION_NUMBER)); |
| | | logger.info(NOTE_DIRECTORY_SERVER_STARTING, getVersionString(), BUILD_ID, REVISION_NUMBER); |
| | | |
| | | // Acquire an exclusive lock for the Directory Server process. |
| | | if (! serverLocked) |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_CANNOT_BOOTSTRAP_SYNTAX.get(syntax.getClass().getName(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_CANNOT_BOOTSTRAP_SYNTAX, syntax.getClass().getName(), |
| | | stackTraceToSingleLineString(e)); |
| | | } |
| | | return syntax; |
| | | } |
| | |
| | | if (!cacheOrderMap.isEmpty()) { |
| | | if (cacheOrderMap.containsKey(configuration.getCacheLevel())) { |
| | | // Log error and skip this cache. |
| | | logger.error(ERR_CONFIG_ENTRYCACHE_CONFIG_LEVEL_NOT_ACCEPTABLE.get( |
| | | configuration.dn(), configuration.getCacheLevel())); |
| | | logger.error(ERR_CONFIG_ENTRYCACHE_CONFIG_LEVEL_NOT_ACCEPTABLE, |
| | | configuration.dn(), configuration.getCacheLevel()); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | filter = groupImplementation.getGroupDefinitionFilter(); |
| | | if (backend.getEntryCount() > 0 && ! backend.isIndexed(filter)) |
| | | { |
| | | logger.warn(WARN_GROUP_FILTER_NOT_INDEXED.get(filter, configEntryDN, backend.getBackendID())); |
| | | logger.warn(WARN_GROUP_FILTER_NOT_INDEXED, filter, configEntryDN, backend.getBackendID()); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | } |
| | | else if (! identityMappers.containsKey(mapperDN)) |
| | | { |
| | | logger.error(ERR_CONFIG_IDMAPPER_INVALID_PROXY_MAPPER_DN.get(mapperDN)); |
| | | logger.error(ERR_CONFIG_IDMAPPER_INVALID_PROXY_MAPPER_DN, mapperDN); |
| | | } |
| | | } |
| | | |
| | |
| | | ")"); |
| | | if (backend.getEntryCount() > 0 && ! backend.isIndexed(filter)) |
| | | { |
| | | logger.warn(WARN_SUBENTRY_FILTER_NOT_INDEXED.get(filter, backend.getBackendID())); |
| | | logger.warn(WARN_SUBENTRY_FILTER_NOT_INDEXED, filter, backend.getBackendID()); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | |
| | | |
| | | // Only log an error once, on first error |
| | | if (isAlreadyLogged.compareAndSet(false, true)) { |
| | | logger.error(ERR_PWPOLICY_REJECT_DUE_TO_UNKNOWN_VALIDATOR_LOG.get( |
| | | userEntry.getName().toNormalizedString(), pwPolicyName, |
| | | validatorName)); |
| | | logger.error(ERR_PWPOLICY_REJECT_DUE_TO_UNKNOWN_VALIDATOR_LOG, |
| | | userEntry.getName().toNormalizedString(), pwPolicyName, validatorName); |
| | | } |
| | | return false; |
| | | } |
| | |
| | | { |
| | | bindOperation.addAdditionalLogItem(AdditionalLogItem.quotedKeyValue( |
| | | getClass(), "trace", credString)); |
| | | logger.error(INFO_SASLANONYMOUS_TRACE. |
| | | get(bindOperation.getConnectionID(), bindOperation.getOperationID(), |
| | | credString)); |
| | | |
| | | logger.error(INFO_SASLANONYMOUS_TRACE, |
| | | bindOperation.getConnectionID(), bindOperation.getOperationID(), credString); |
| | | } |
| | | } |
| | | |
| | |
| | | f = new File(configFile + ".startok"); |
| | | if (! f.exists()) |
| | | { |
| | | logger.warn(WARN_CONFIG_FILE_NO_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | configFile)); |
| | | logger.warn(WARN_CONFIG_FILE_NO_STARTOK_FILE, f.getAbsolutePath(), configFile); |
| | | useLastKnownGoodConfig = false; |
| | | f = new File(configFile); |
| | | } |
| | | else |
| | | { |
| | | logger.info(NOTE_CONFIG_FILE_USING_STARTOK_FILE.get(f.getAbsolutePath(), |
| | | configFile)); |
| | | logger.info(NOTE_CONFIG_FILE_USING_STARTOK_FILE, f.getAbsolutePath(), configFile); |
| | | } |
| | | } |
| | | else |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_STARTOK_CANNOT_WRITE.get(configFile, tempFilePath, |
| | | getExceptionMessage(e))); |
| | | logger.error(ERR_STARTOK_CANNOT_WRITE, configFile, tempFilePath, getExceptionMessage(e)); |
| | | return; |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_WRITING.get(tempFilePath, |
| | | getExceptionMessage(e))); |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_WRITING, tempFilePath, getExceptionMessage(e)); |
| | | return; |
| | | } |
| | | finally |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_READING.get(configFile, |
| | | getExceptionMessage(e))); |
| | | logger.error(ERR_STARTOK_CANNOT_OPEN_FOR_READING, configFile, getExceptionMessage(e)); |
| | | return; |
| | | } |
| | | finally |
| | |
| | | } catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_STARTOK_CANNOT_RENAME.get(tempFilePath, startOKFilePath, |
| | | getExceptionMessage(e))); |
| | | logger.error(ERR_STARTOK_CANNOT_RENAME, tempFilePath, startOKFilePath, getExceptionMessage(e)); |
| | | return; |
| | | } |
| | | |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logger.error(ERR_DISK_SPACE_MONITOR_UPDATE_FAILED.get(directory.getPath(), e)); |
| | | logger.error(ERR_DISK_SPACE_MONITOR_UPDATE_FAILED, directory.getPath(), e); |
| | | logger.traceException(e); |
| | | } |
| | | } |
| | |
| | | public void handleStatusNotification( |
| | | AccountStatusNotification notification) |
| | | { |
| | | logger.info(NOTE_ERRORLOG_ACCTNOTHANDLER_NOTIFICATION.get(notification.getNotificationType().getName(), |
| | | logger.info(NOTE_ERRORLOG_ACCTNOTHANDLER_NOTIFICATION, |
| | | notification.getNotificationType().getName(), |
| | | notification.getUserDN(), |
| | | notification.getMessage().ordinal(), |
| | | notification.getMessage())); |
| | | notification.getMessage()); |
| | | } |
| | | |
| | | |
| | |
| | | // Remove cache entries specific to this backend. |
| | | clearBackend(DirectoryServer.getBackend(backend)); |
| | | // Log an error message. |
| | | logger.warn(WARN_FSCACHE_OFFLINE_STATE_FAIL.get(backend)); |
| | | logger.warn(WARN_FSCACHE_OFFLINE_STATE_FAIL, backend); |
| | | } |
| | | } |
| | | // Pop max entries limit. |
| | |
| | | principal.append("@").append(realm); |
| | | } |
| | | w.write(principal.toString()); |
| | | logger.error(INFO_GSSAPI_PRINCIPAL_NAME.get(principal)); |
| | | logger.error(INFO_GSSAPI_PRINCIPAL_NAME, principal); |
| | | w.write("\" isInitiator=false;"); |
| | | w.newLine(); |
| | | w.write("};"); |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get(storedPassword, e)); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword, e); |
| | | return false; |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL.get(o, e)); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL, o, e); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get(t.getName(), e)); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD, t.getName(), e); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | // This should not happen. The only recourse we have is to log a message |
| | | // and try again. |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get(Thread.currentThread().getName(), e)); |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION, Thread.currentThread().getName(), e); |
| | | return retryNextOperation(workerThread, numFailures + 1); |
| | | } |
| | | } |
| | |
| | | // and we will want to log a message. |
| | | if (stoppedByReducedThreadNumber) |
| | | { |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER, getName()); |
| | | } |
| | | else if (! workQueue.shutdownRequested()) |
| | | { |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT, getName()); |
| | | } |
| | | |
| | | |
| | |
| | | // 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. |
| | | logger.warn(WARN_EXTOP_PASSMOD_CANNOT_UPDATE_PWP_STATE.get(userDN, |
| | | logger.warn(WARN_EXTOP_PASSMOD_CANNOT_UPDATE_PWP_STATE, userDN, |
| | | modOp.getResultCode(), |
| | | modOp.getErrorMessage())); |
| | | modOp.getErrorMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get(storedPassword, e)); |
| | | logger.error(ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD, storedPassword, e); |
| | | return false; |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE.get( |
| | | notificationType.getName(), notification.getUserDN(), getExceptionMessage(e))); |
| | | logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE, |
| | | notificationType.getName(), notification.getUserDN(), getExceptionMessage(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL.get(o, e)); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_CANCEL, o, e); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD.get(t.getName(), e)); |
| | | logger.warn(WARN_QUEUE_UNABLE_TO_NOTIFY_THREAD, t.getName(), e); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | // 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. |
| | | logger.warn(WARN_WORKER_INTERRUPTED_WITHOUT_SHUTDOWN.get(Thread.currentThread().getName(), ie)); |
| | | logger.warn(WARN_WORKER_INTERRUPTED_WITHOUT_SHUTDOWN, Thread.currentThread().getName(), ie); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | |
| | | |
| | | // This should not happen. The only recourse we have is to log a message |
| | | // and try again. |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION.get(Thread.currentThread().getName(), e)); |
| | | logger.warn(WARN_WORKER_WAITING_UNCAUGHT_EXCEPTION, Thread.currentThread().getName(), e); |
| | | } |
| | | finally |
| | | { |
| | |
| | | // and we will want to log a message. |
| | | if (stoppedByReducedThreadNumber) |
| | | { |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER.get(getName())); |
| | | logger.debug(INFO_WORKER_STOPPED_BY_REDUCED_THREADNUMBER, getName()); |
| | | } |
| | | else if (! workQueue.shutdownRequested()) |
| | | { |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT.get(getName())); |
| | | logger.warn(WARN_UNEXPECTED_WORKER_THREAD_EXIT, getName()); |
| | | } |
| | | |
| | | |
| | |
| | | break; |
| | | |
| | | case NO_SUCH_OBJECT: |
| | | logger.debug(INFO_PLUGIN_REFERENT_SEARCH_NO_SUCH_OBJECT.get(baseDN)); |
| | | logger.debug(INFO_PLUGIN_REFERENT_SEARCH_NO_SUCH_OBJECT, baseDN); |
| | | return; |
| | | |
| | | default: |
| | | logger.error(ERR_PLUGIN_REFERENT_SEARCH_FAILED.get(operation.getErrorMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_SEARCH_FAILED, operation.getErrorMessage()); |
| | | return; |
| | | } |
| | | |
| | |
| | | conn.processModify(entryDN, mods); |
| | | if(modifyOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | logger.error(ERR_PLUGIN_REFERENT_MODIFY_FAILED.get(entryDN, modifyOperation.getErrorMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_MODIFY_FAILED, entryDN, modifyOperation.getErrorMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch (IOException io) |
| | | { |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE, io.getMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (IOException io) |
| | | { |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_CLOSE_LOGFILE, io.getMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | logFile.delete(); |
| | | logFile.createNewFile(); |
| | | } catch (IOException io) { |
| | | logger.error(ERR_PLUGIN_REFERENT_REPLACE_LOGFILE.get(io.getMessage())); |
| | | logger.error(ERR_PLUGIN_REFERENT_REPLACE_LOGFILE, io.getMessage()); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (final Exception e) |
| | | { |
| | | logger.info(ERR_PLUGIN_SAMBA_SYNC_ENCODING.get(e.getMessage()), e); |
| | | logger.info(ERR_PLUGIN_SAMBA_SYNC_ENCODING, e.getMessage(), e); |
| | | modifications = null; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (final DirectoryException e) |
| | | { |
| | | logger.info(ERR_PLUGIN_SAMBA_SYNC_MODIFICATION_PROCESSING.get(e.getMessage()), e); |
| | | logger.info(ERR_PLUGIN_SAMBA_SYNC_MODIFICATION_PROCESSING, e.getMessage(), e); |
| | | } |
| | | } |
| | | |
| | |
| | | // 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. |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_NOT_DIRECTORY.get( |
| | | ldifDirectory.getAbsolutePath(), configuration.dn())); |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_NOT_DIRECTORY, |
| | | ldifDirectory.getAbsolutePath(), configuration.dn()); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | // 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. |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_MISSING.get( |
| | | ldifDirectory.getAbsolutePath(), configuration.dn())); |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_MISSING, |
| | | ldifDirectory.getAbsolutePath(), configuration.dn()); |
| | | } |
| | | |
| | | this.currentConfig = configuration; |
| | |
| | | // error + alert about the horked config |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | currentConfig.dn(), getExceptionMessage(e))); |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION, |
| | | friendlyName, currentConfig.dn(), getExceptionMessage(e)); |
| | | |
| | | if (lastIterationFailed) |
| | | { |
| | |
| | | logger.trace("Starting HTTP server..."); |
| | | this.httpServer.start(); |
| | | logger.trace("HTTP server started"); |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING, handlerName); |
| | | } |
| | | |
| | | private HttpServer createHttpServer() |
| | |
| | | this.httpServer.shutdownNow(); |
| | | cleanUpHttpServer(); |
| | | logger.trace("HTTP server stopped"); |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING, handlerName); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | logger.error(ERR_INTERNAL_CANNOT_DECODE_DN.get(fullDNString, getExceptionMessage(de))); |
| | | logger.error(ERR_INTERNAL_CANNOT_DECODE_DN, fullDNString, getExceptionMessage(de)); |
| | | } |
| | | |
| | | connectionID = nextConnectionID.getAndDecrement(); |
| | |
| | | // 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". |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_NO_RESULT_CODE.get(operation.getOperationType(), |
| | | operation.getConnectionID(), operation.getOperationID())); |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_NO_RESULT_CODE, operation.getOperationType(), |
| | | operation.getConnectionID(), operation.getOperationID()); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | } |
| | | |
| | |
| | | // If this an LDAPv2 client, then we can't send this. |
| | | if (ldapVersion == 2) |
| | | { |
| | | logger.error(ERR_LDAPV2_SKIPPING_EXTENDED_RESPONSE.get( |
| | | getConnectionID(), operation.getOperationID(), operation)); |
| | | logger.error(ERR_LDAPV2_SKIPPING_EXTENDED_RESPONSE, |
| | | getConnectionID(), operation.getOperationID(), 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. |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_INVALID_OP.get(operation.getOperationType(), getConnectionID(), |
| | | operation.getOperationID(), operation)); |
| | | logger.error(ERR_LDAP_CLIENT_SEND_RESPONSE_INVALID_OP, operation.getOperationType(), getConnectionID(), |
| | | operation.getOperationID(), operation); |
| | | return null; |
| | | } |
| | | |
| | |
| | | cleanUpSelector(); |
| | | listening = false; |
| | | |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STOPPED_LISTENING, handlerName); |
| | | } |
| | | |
| | | StaticUtils.sleep(1000); |
| | |
| | | // administrative action before trying again. |
| | | if (numRegistered == 0) |
| | | { |
| | | logger.error(ERR_LDAP_CONNHANDLER_NO_ACCEPTORS.get(currentConfig.dn())); |
| | | logger.error(ERR_LDAP_CONNHANDLER_NO_ACCEPTORS, currentConfig.dn()); |
| | | |
| | | enabled = false; |
| | | continue; |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION.get(friendlyName, |
| | | currentConfig.dn(), getExceptionMessage(e))); |
| | | logger.error(ERR_CONNHANDLER_CANNOT_ACCEPT_CONNECTION, friendlyName, |
| | | currentConfig.dn(), getExceptionMessage(e)); |
| | | |
| | | if (lastIterationFailed) |
| | | { |
| | |
| | | channel.register(selector, SelectionKey.OP_ACCEPT); |
| | | numRegistered++; |
| | | |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING.get(handlerName)); |
| | | logger.info(NOTE_CONNHANDLER_STARTED_LISTENING, handlerName); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_LDAP_CONNHANDLER_CREATE_CHANNEL_FAILED.get(currentConfig.dn(), a.getHostAddress(), listenPort, |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_LDAP_CONNHANDLER_CREATE_CHANNEL_FAILED, currentConfig.dn(), a.getHostAddress(), listenPort, |
| | | stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | return numRegistered; |
| | |
| | | * Log an error for the repair tool |
| | | * that will need to re-synchronize the servers. |
| | | */ |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES, getBaseDNString()); |
| | | } |
| | | } catch (Exception e) |
| | | { |
| | |
| | | * Log an error for the repair tool |
| | | * that will need to re-synchronize the servers. |
| | | */ |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES.get(getBaseDNString())); |
| | | logger.error(ERR_CANNOT_RECOVER_CHANGES, getBaseDNString()); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (DirectoryException e) |
| | | { |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_LOADING_GENERATION_ID, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | } |
| | | |
| | | /* |
| | |
| | | // Should not happen as normally already called without problem in |
| | | // isConfigurationChangeAcceptable or isConfigurationAcceptable |
| | | // if we come up to this method |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(NOTE_ERR_FRACTIONAL, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | return; |
| | | } |
| | | |
| | |
| | | catch (ConfigException e) |
| | | { |
| | | // Should not happen |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(NOTE_ERR_FRACTIONAL, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | return; |
| | | } |
| | | |
| | |
| | | if (search.getResultCode() != ResultCode.SUCCESS |
| | | && search.getResultCode() != ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | logger.error(ERR_SEARCHING_GENERATION_ID.get( |
| | | search.getResultCode().getResultCodeName() + " " + |
| | | search.getErrorMessage(), |
| | | getBaseDNString())); |
| | | logger.error(ERR_SEARCHING_GENERATION_ID, |
| | | search.getResultCode().getResultCodeName() + " " + search.getErrorMessage(), |
| | | getBaseDNString()); |
| | | return false; |
| | | } |
| | | |
| | |
| | | } |
| | | if (attr.size() > 1) |
| | | { |
| | | logger.error(ERR_LOADING_GENERATION_ID.get(getBaseDNString(), |
| | | "#Values=" + attr.size() + " Must be exactly 1 in entry " |
| | | + resultEntry.toLDIFString())); |
| | | logger.error(ERR_LOADING_GENERATION_ID, |
| | | 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 |
| | | logger.error(NOTE_ERR_FRACTIONAL.get( |
| | | fractionalConfig.getBaseDn(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(NOTE_ERR_FRACTIONAL, fractionalConfig.getBaseDn(), 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 |
| | | logger.error(NOTE_ERR_FRACTIONAL.get( |
| | | fractionalConfig.getBaseDn(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(NOTE_ERR_FRACTIONAL, fractionalConfig.getBaseDn(), stackTraceToSingleLineString(e)); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch(DirectoryException e) |
| | | { |
| | | logger.error(NOTE_ERR_FRACTIONAL.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(NOTE_ERR_FRACTIONAL, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | return FRACTIONAL_HAS_NO_FRACTIONAL_FILTERED_ATTRIBUTES; |
| | | } |
| | | Set<ObjectClass> entryClasses = entryToModify.getObjectClasses().keySet(); |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get(op, curCSN)); |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING, op, curCSN); |
| | | return; |
| | | } |
| | | } |
| | |
| | | * It should never happen. |
| | | */ |
| | | pendingChanges.remove(curCSN); |
| | | logger.error(ERR_UNKNOWN_TYPE.get(op.getOperationType())); |
| | | logger.error(ERR_UNKNOWN_TYPE, op.getOperationType()); |
| | | return; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get(op, curCSN)); |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING, op, curCSN); |
| | | return; |
| | | } |
| | | // If assured replication is enabled, this will wait for the matching |
| | |
| | | } catch (TimeoutException ex) |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), getAssuredTimeout(), msg)); |
| | | logger.error(NOTE_DS_ACK_TIMEOUT, getBaseDNString(), getAssuredTimeout(), msg); |
| | | } |
| | | } |
| | | |
| | |
| | | ResultCode res = newOp.getResultCode(); |
| | | if (res != ResultCode.SUCCESS) |
| | | { |
| | | logger.error(ERR_COULD_NOT_SOLVE_CONFLICT.get(entryDN, res)); |
| | | logger.error(ERR_COULD_NOT_SOLVE_CONFLICT, entryDN, res); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op, ctx.getCSN(), result, op.getErrorMessage())); |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION, |
| | | op, ctx.getCSN(), result, op.getErrorMessage()); |
| | | return true; |
| | | } |
| | | } |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op, ctx.getCSN(), result, op.getErrorMessage())); |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION, |
| | | op, ctx.getCSN(), result, op.getErrorMessage()); |
| | | return true; |
| | | } |
| | | } |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // Log a message for the repair tool. |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op, ctx.getCSN(), result, op.getErrorMessage())); |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION, |
| | | op, ctx.getCSN(), result, op.getErrorMessage()); |
| | | return true; |
| | | } |
| | | } |
| | |
| | | { |
| | | // The other type of errors can not be caused by naming conflicts. |
| | | // log a message for the repair tool. |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION.get( |
| | | op, ctx.getCSN(), result, op.getErrorMessage())); |
| | | logger.error(ERR_ERROR_REPLAYING_OPERATION, |
| | | op, ctx.getCSN(), result, op.getErrorMessage()); |
| | | return true; |
| | | } |
| | | } |
| | |
| | | * not available, log an error and retry upon timeout |
| | | * should we stop the modifications ? |
| | | */ |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_LOADING_GENERATION_ID, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | return; |
| | | } |
| | | |
| | |
| | | |
| | | if (result != ResultCode.SUCCESS) |
| | | { |
| | | logger.error(ERR_UPDATING_GENERATION_ID.get( |
| | | result.getResultCodeName(), getBaseDNString())); |
| | | logger.error(ERR_UPDATING_GENERATION_ID, result.getResultCodeName(), getBaseDNString()); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | if (search.getResultCode() != ResultCode.NO_SUCH_OBJECT) |
| | | { |
| | | logger.error(ERR_SEARCHING_GENERATION_ID.get( |
| | | search.getResultCode().getResultCodeName() + " " + |
| | | search.getErrorMessage(), |
| | | getBaseDNString())); |
| | | logger.error(ERR_SEARCHING_GENERATION_ID, |
| | | search.getResultCode().getResultCodeName() + " " + search.getErrorMessage(), |
| | | getBaseDNString()); |
| | | } |
| | | } |
| | | else |
| | |
| | | Attribute attr = attrs.get(0); |
| | | if (attr.size()>1) |
| | | { |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), "#Values=" + attr.size() + |
| | | " Must be exactly 1 in entry " + resultEntry.toLDIFString())); |
| | | logger.error(ERR_LOADING_GENERATION_ID, |
| | | getBaseDNString(), |
| | | "#Values=" + attr.size() + " Must be exactly 1 in entry " + resultEntry.toLDIFString()); |
| | | } |
| | | else if (attr.size() == 1) |
| | | { |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logger.error(ERR_LOADING_GENERATION_ID.get( |
| | | getBaseDNString(), stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_LOADING_GENERATION_ID, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | catch(Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_CHECK_CREATE_REPL_BACKEND_FAILED.get( |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_CHECK_CREATE_REPL_BACKEND_FAILED, stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | throw new ConfigException(NOTE_ERR_UNABLE_TO_ENABLE_ECL.get( |
| | | "Replication Domain on " + getBaseDNString(), |
| | | stackTraceToSingleLineString(e)), e); |
| | | "Replication Domain on " + getBaseDNString(), stackTraceToSingleLineString(e)), e); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logger.error(NOTE_ERR_UNABLE_TO_ENABLE_ECL.get( |
| | | "Replication Domain on " + getBaseDNString(), |
| | | stackTraceToSingleLineString(de))); |
| | | logger.error(NOTE_ERR_UNABLE_TO_ENABLE_ECL, |
| | | "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); |
| | | logger.error(NOTE_FRACTIONAL_BAD_DATA_SET_NEED_RESYNC.get(getBaseDNString())); |
| | | logger.error(NOTE_FRACTIONAL_BAD_DATA_SET_NEED_RESYNC, getBaseDNString()); |
| | | return; // Do not send changes to the replication server |
| | | } |
| | | |
| | |
| | | } |
| | | } catch (Exception e) |
| | | { |
| | | logger.error(ERR_PUBLISHING_FAKE_OPS.get(getBaseDNString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_PUBLISHING_FAKE_OPS, getBaseDNString(), stackTraceToSingleLineString(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch (ConfigException e) |
| | | { |
| | | logger.error(ERR_COULD_NOT_START_REPLICATION.get(configuration.dn(), e.getLocalizedMessage() |
| | | + " " + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_COULD_NOT_START_REPLICATION, configuration.dn(), |
| | | e.getLocalizedMessage() + " " + stackTraceToSingleLineString(e)); |
| | | } |
| | | return null; |
| | | } |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDN(), serverId, status, event)); |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS, getBaseDN(), serverId, status, event); |
| | | // 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. |
| | |
| | | StatusMachineEvent event = StatusMachineEvent.statusToEvent(reqStatus); |
| | | if (event == StatusMachineEvent.INVALID_EVENT) |
| | | { |
| | | logger.error(ERR_RS_INVALID_NEW_STATUS.get(reqStatus, getBaseDN(), serverId)); |
| | | logger.error(ERR_RS_INVALID_NEW_STATUS, reqStatus, getBaseDN(), serverId); |
| | | return ServerStatus.INVALID_STATUS; |
| | | } |
| | | |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDN(), serverId, status, event)); |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS, getBaseDN(), serverId, status, event); |
| | | return ServerStatus.INVALID_STATUS; |
| | | } |
| | | |
| | |
| | | { |
| | | // An unexpected error happened. |
| | | // Log an error and close the connection. |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION.get(handler + " " + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION, handler + " " + stackTraceToSingleLineString(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION.get( |
| | | handler + " " + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_WRITER_UNEXPECTED_EXCEPTION, handler + " " + stackTraceToSingleLineString(e)); |
| | | mypsearch.cancel(); |
| | | } |
| | | } |
| | |
| | | // Adding 2 msgs with the same CSN is ok only when |
| | | // the 2 msgs are the same |
| | | bytesCount += (update.size() - msgSameCSN.size()); |
| | | logger.error(ERR_RSQUEUE_DIFFERENT_MSGS_WITH_SAME_CN.get( |
| | | msgSameCSN.getCSN(), msgSameCSN, update)); |
| | | logger.error(ERR_RSQUEUE_DIFFERENT_MSGS_WITH_SAME_CN, msgSameCSN.getCSN(), msgSameCSN, update); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | | {} |
| | | { |
| | | logger.traceException(e); |
| | | } |
| | | } |
| | | else |
| | | { |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_BACKEND_EXPORT_ENTRY.get(dnString, e)); |
| | | logger.error(ERR_BACKEND_EXPORT_ENTRY, dnString, e); |
| | | } |
| | | } |
| | | } |
| | |
| | | // error log with repeated messages. |
| | | if (!pendingMonitorDataServerIDs.contains(serverId)) |
| | | { |
| | | logger.info(NOTE_MONITOR_DATA_RECEIVED.get(baseDN, serverId)); |
| | | logger.info(NOTE_MONITOR_DATA_RECEIVED, baseDN, serverId); |
| | | } |
| | | } |
| | | |
| | |
| | | // error log with repeated messages. |
| | | if (!monitorDataLateServers.contains(serverId)) |
| | | { |
| | | logger.warn(WARN_MISSING_REMOTE_MONITOR_DATA.get(baseDN, serverId)); |
| | | logger.warn(WARN_MISSING_REMOTE_MONITOR_DATA, baseDN, serverId); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | // This is a response for an earlier request whose computing is |
| | | // already complete. |
| | | logger.debug(INFO_IGNORING_REMOTE_MONITOR_DATA.get(domain.getBaseDN().toNormalizedString(), msg.getSenderID())); |
| | | logger.debug(INFO_IGNORING_REMOTE_MONITOR_DATA, domain.getBaseDN().toNormalizedString(), msg.getSenderID()); |
| | | return; |
| | | } |
| | | |
| | |
| | | catch (RuntimeException e) |
| | | { |
| | | // FIXME: do we really expect these??? |
| | | logger.error(ERR_PROCESSING_REMOTE_MONITOR_DATA.get(e.getMessage() + " " |
| | | + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_PROCESSING_REMOTE_MONITOR_DATA, e.getMessage() + " " + stackTraceToSingleLineString(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | catch (IOException e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_COULD_NOT_CLOSE_THE_SOCKET.get(e)); |
| | | logger.error(ERR_COULD_NOT_CLOSE_THE_SOCKET, e); |
| | | } |
| | | catch (InterruptedException e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_COULD_NOT_STOP_LISTEN_THREAD.get(e)); |
| | | logger.error(ERR_COULD_NOT_STOP_LISTEN_THREAD, e); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logger.error(ERR_DELETE_REPL_BACKEND_FAILED.get(e.getLocalizedMessage())); |
| | | logger.error(ERR_DELETE_REPL_BACKEND_FAILED, e.getLocalizedMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | } else |
| | | { |
| | | // Unknown assured mode: should never happen |
| | | logger.error(ERR_RS_UNKNOWN_ASSURED_MODE.get( |
| | | localReplicationServer.getServerId(), assuredMode, baseDN, update)); |
| | | logger.error(ERR_RS_UNKNOWN_ASSURED_MODE, |
| | | localReplicationServer.getServerId(), assuredMode, baseDN, update); |
| | | assuredMessage = false; |
| | | } |
| | | } else |
| | |
| | | * job properly anymore and needs to close all its connections and |
| | | * shutdown itself. |
| | | */ |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | .get(stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR, stackTraceToSingleLineString(e)); |
| | | localReplicationServer.shutdown(); |
| | | return false; |
| | | } |
| | |
| | | if (safeDataLevel < (byte) 1) |
| | | { |
| | | // Should never happen |
| | | logger.error(ERR_UNKNOWN_ASSURED_SAFE_DATA_LEVEL.get( |
| | | localReplicationServer.getServerId(), safeDataLevel, baseDN, update)); |
| | | logger.error(ERR_UNKNOWN_ASSURED_SAFE_DATA_LEVEL, |
| | | localReplicationServer.getServerId(), safeDataLevel, baseDN, update); |
| | | } else if (sourceGroupId == groupId |
| | | // Assured feature does not cross different group IDS |
| | | && isSameGenerationId(sourceHandler.getGenerationId())) |
| | |
| | | if (msg instanceof ErrorMsg) |
| | | { |
| | | ErrorMsg errorMsg = (ErrorMsg) msg; |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED, 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. |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG.get(msg.getDestination())); |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG, msg.getDestination()); |
| | | } |
| | | } |
| | | } |
| | |
| | | RoutableMsg msg) |
| | | { |
| | | String msgClassname = msg.getClass().getCanonicalName(); |
| | | logger.info(NOTE_ERR_ROUTING_TO_SERVER.get(msgClassname)); |
| | | logger.info(NOTE_ERR_ROUTING_TO_SERVER, msgClassname); |
| | | |
| | | LocalizableMessageBuilder mb = new LocalizableMessageBuilder(); |
| | | mb.append(NOTE_ERR_ROUTING_TO_SERVER.get(msgClassname)); |
| | |
| | | * An error happened trying to send an error msg to this server. |
| | | * Log an error and close the connection to this server. |
| | | */ |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_ERROR.get(this), ignored); |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_ERROR, this, ignored); |
| | | stopServer(msgEmitter, false); |
| | | } |
| | | } |
| | |
| | | } |
| | | } catch (IOException e) |
| | | { |
| | | logger.error(ERR_EXCEPTION_FORWARDING_RESET_GEN_ID.get(baseDN.toNormalizedString(), e.getMessage())); |
| | | logger.error(ERR_EXCEPTION_FORWARDING_RESET_GEN_ID, baseDN.toNormalizedString(), e.getMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | dsHandler.changeStatusForResetGenId(newGenId); |
| | | } catch (IOException e) |
| | | { |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_AFTER_RESET_GEN_ID.get(baseDN.toNormalizedString(), |
| | | dsHandler.getServerId(), e.getMessage())); |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_AFTER_RESET_GEN_ID, baseDN.toNormalizedString(), |
| | | dsHandler.getServerId(), e.getMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | // treatment. |
| | | sendTopoInfoToAll(); |
| | | |
| | | logger.info(NOTE_RESET_GENERATION_ID.get(baseDN.toNormalizedString(), |
| | | newGenId)); |
| | | logger.info(NOTE_RESET_GENERATION_ID, baseDN.toNormalizedString(), newGenId); |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | logger.error(LocalizableMessage.raw( stackTraceToSingleLineString(e))); |
| | | logger.error(LocalizableMessage.raw(stackTraceToSingleLineString(e))); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (IOException e) |
| | | { |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_FROM_STATUS_ANALYZER.get( |
| | | baseDN.toNormalizedString(), dsHandler.getServerId(), e.getMessage())); |
| | | logger.error(ERR_EXCEPTION_CHANGING_STATUS_FROM_STATUS_ANALYZER, |
| | | baseDN.toNormalizedString(), dsHandler.getServerId(), e.getMessage()); |
| | | } |
| | | |
| | | if (newStatus == ServerStatus.INVALID_STATUS || newStatus == oldStatus) |
| | |
| | | } |
| | | catch (ChangelogException e) |
| | | { |
| | | logger.error(ERR_ERROR_CLEARING_DB.get(baseDN, e.getMessage()), e); |
| | | logger.error(ERR_ERROR_CLEARING_DB, baseDN, e.getMessage(), e); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (IOException e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG |
| | | .get("Replication Server " |
| | | + localReplicationServer.getReplicationPort() + " " |
| | | + baseDN + " " + localReplicationServer.getServerId())); |
| | | logger.error(ERR_CHANGELOG_ERROR_SENDING_MSG, |
| | | "Replication Server " + localReplicationServer.getReplicationPort() + " " |
| | | + baseDN + " " + localReplicationServer.getServerId()); |
| | | stopServer(rsHandler, false); |
| | | } |
| | | } |
| | |
| | | { |
| | | long referenceGenerationId = handler.getReferenceGenId(); |
| | | if (dsStatus == BAD_GEN_ID_STATUS) |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_BADGENID, handler.getReplicationServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | referenceGenerationId); |
| | | if (dsStatus == FULL_UPDATE_STATUS) |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_FULLUP, handler.getReplicationServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | | session.getReadableRemoteAddress()); |
| | | filtered = true; |
| | | } |
| | | } else |
| | |
| | | if (referenceGenerationId > 0 |
| | | && referenceGenerationId != handler.getGenerationId()) |
| | | { |
| | | logger.error( |
| | | WARN_IGNORING_UPDATE_FROM_RS.get( |
| | | logger.error(WARN_IGNORING_UPDATE_FROM_RS, |
| | | handler.getReplicationServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | referenceGenerationId); |
| | | filtered = true; |
| | | } |
| | | } |
| | |
| | | { |
| | | if (dsStatus == ServerStatus.BAD_GEN_ID_STATUS) |
| | | { |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_BADGENID, handler.getReplicationServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | referenceGenerationId); |
| | | } |
| | | else if (dsStatus == ServerStatus.FULL_UPDATE_STATUS) |
| | | { |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_FULLUP, handler.getReplicationServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | | session.getReadableRemoteAddress()); |
| | | } |
| | | continue; |
| | | } |
| | |
| | | || referenceGenerationId == -1 |
| | | || handler.getGenerationId() == -1) |
| | | { |
| | | logger.error(WARN_IGNORING_UPDATE_TO_RS.get( |
| | | logger.error(WARN_IGNORING_UPDATE_TO_RS, |
| | | handler.getReplicationServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | referenceGenerationId); |
| | | continue; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE, this, stackTraceToSingleLineString(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (Exception end) |
| | | { |
| | | logger.error(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH |
| | | .get(stackTraceToSingleLineString(end))); |
| | | logger.error(ERR_EXCEPTION_CHANGELOG_TRIM_FLUSH, stackTraceToSingleLineString(end)); |
| | | if (replicationServer != null) |
| | | { |
| | | replicationServer.shutdown(); |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_COULD_NOT_READ_DB.get(this.dbDirectory.getAbsolutePath(), |
| | | e.getLocalizedMessage())); |
| | | logger.error(ERR_COULD_NOT_READ_DB, this.dbDirectory.getAbsolutePath(), e.getLocalizedMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | logger.error(ERR_CHANGENUMBER_DATABASE.get(e.getLocalizedMessage())); |
| | | logger.error(ERR_CHANGENUMBER_DATABASE, e.getLocalizedMessage()); |
| | | } |
| | | } |
| | | return cnIndexDB; |
| | |
| | | } |
| | | catch (DatabaseException e) |
| | | { |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE.get(toString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.info(NOTE_EXCEPTION_CLOSING_DATABASE, this, stackTraceToSingleLineString(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | */ |
| | | void shutdownOnException(DatabaseException e) |
| | | { |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR |
| | | .get(stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_CHANGELOG_SHUTDOWN_DATABASE_ERROR, stackTraceToSingleLineString(e)); |
| | | replicationServer.shutdown(); |
| | | } |
| | | |
| | |
| | | if (gotOneFailure) |
| | | { |
| | | // Heartbeat is well overdue so the server is assumed to be dead. |
| | | logger.warn(WARN_HEARTBEAT_FAILURE.get(serverID, |
| | | replicationServerID, session.getReadableRemoteAddress(), |
| | | baseDN)); |
| | | logger.warn(WARN_HEARTBEAT_FAILURE, serverID, |
| | | replicationServerID, session.getReadableRemoteAddress(), baseDN); |
| | | |
| | | // Exit monitor and close session. |
| | | shutdown = true; |
| | |
| | | final int rsServerId = rs.rsInfo.getServerId(); |
| | | if (rsGenId == getGenerationID() || rsGenId == -1) |
| | | { |
| | | logger.info(NOTE_NOW_FOUND_SAME_GENERATION_CHANGELOG.get(serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID())); |
| | | logger.info(NOTE_NOW_FOUND_SAME_GENERATION_CHANGELOG, serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID()); |
| | | } |
| | | else |
| | | { |
| | | logger.warn(WARN_NOW_FOUND_BAD_GENERATION_CHANGELOG.get(serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID(), rsGenId)); |
| | | logger.warn(WARN_NOW_FOUND_BAD_GENERATION_CHANGELOG, serverId, rsServerId, baseDN.toNormalizedString(), |
| | | rs.replicationServer, getGenerationID(), rsGenId); |
| | | } |
| | | } |
| | | else |
| | |
| | | |
| | | if (replicationServerInfos.size() > 0) |
| | | { |
| | | logger.warn(WARN_COULD_NOT_FIND_CHANGELOG.get(serverId, baseDN.toNormalizedString(), |
| | | Utils.joinAsString(", ", replicationServerInfos.keySet()))); |
| | | logger.warn(WARN_COULD_NOT_FIND_CHANGELOG, serverId, baseDN.toNormalizedString(), |
| | | Utils.joinAsString(", ", replicationServerInfos.keySet())); |
| | | } |
| | | else |
| | | { |
| | | logger.warn(WARN_NO_AVAILABLE_CHANGELOGS.get(serverId, baseDN.toNormalizedString())); |
| | | logger.warn(WARN_NO_AVAILABLE_CHANGELOGS, serverId, baseDN.toNormalizedString()); |
| | | } |
| | | } |
| | | } |
| | |
| | | warn user and start heartbeat monitor to recover when a server |
| | | with the right group id shows up. |
| | | */ |
| | | logger.warn(WARN_CONNECTED_TO_SERVER_WITH_WRONG_GROUP_ID.get( |
| | | logger.warn(WARN_CONNECTED_TO_SERVER_WITH_WRONG_GROUP_ID, |
| | | groupId, rs.getServerId(), rsInfo.getServerURL(), rs.getGroupId(), |
| | | baseDN.toNormalizedString(), getServerId())); |
| | | baseDN.toNormalizedString(), getServerId()); |
| | | } |
| | | startRSHeartBeatMonitoring(rs); |
| | | if (rsInfo.getProtocolVersion() >= |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.error(ERR_COMPUTING_FAKE_OPS.get(baseDN.toNormalizedString(), rsInfo.getServerURL(), |
| | | e.getLocalizedMessage() + " " + stackTraceToSingleLineString(e))); |
| | | logger.error(ERR_COMPUTING_FAKE_OPS, baseDN.toNormalizedString(), rsInfo.getServerURL(), |
| | | e.getLocalizedMessage() + " " + stackTraceToSingleLineString(e)); |
| | | } |
| | | finally |
| | | { |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.warn(WARN_EXCEPTION_STARTING_SESSION_PHASE.get(getServerId(), server, getBaseDN().toNormalizedString(), |
| | | stackTraceToSingleLineString(e))); |
| | | logger.warn(WARN_EXCEPTION_STARTING_SESSION_PHASE, getServerId(), server, getBaseDN().toNormalizedString(), |
| | | stackTraceToSingleLineString(e)); |
| | | |
| | | rs.session.close(); |
| | | setConnectedRS(ConnectedRS.noConnectedRS()); |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.error(WARN_EXCEPTION_STARTING_SESSION_PHASE.get( |
| | | logger.error(WARN_EXCEPTION_STARTING_SESSION_PHASE, |
| | | getServerId(), electedRS.rsInfo.getServerURL(), |
| | | getBaseDN().toNormalizedString(), stackTraceToSingleLineString(e))); |
| | | getBaseDN().toNormalizedString(), stackTraceToSingleLineString(e)); |
| | | |
| | | setConnectedRS(ConnectedRS.noConnectedRS()); |
| | | return null; |
| | |
| | | if (rs.session == null || !rs.session.closeInitiated()) |
| | | { |
| | | // We did not initiate the close on our side, log an error message. |
| | | logger.error(WARN_REPLICATION_SERVER_BADLY_DISCONNECTED.get( |
| | | logger.error(WARN_REPLICATION_SERVER_BADLY_DISCONNECTED, |
| | | serverId, baseDN.toNormalizedString(), previousRsServerID, |
| | | rs.replicationServer)); |
| | | rs.replicationServer); |
| | | } |
| | | |
| | | if (!reconnectOnFailure) |
| | |
| | | // Sanity check: is it a valid initial status? |
| | | if (!isValidInitialStatus(initStatus)) |
| | | { |
| | | logger.error(ERR_DS_INVALID_INIT_STATUS.get(initStatus, getBaseDNString(), getServerId())); |
| | | logger.error(ERR_DS_INVALID_INIT_STATUS, initStatus, getBaseDNString(), getServerId()); |
| | | } |
| | | else |
| | | { |
| | |
| | | StatusMachineEvent event = StatusMachineEvent.statusToEvent(reqStatus); |
| | | if (event == StatusMachineEvent.INVALID_EVENT) |
| | | { |
| | | logger.error(ERR_DS_INVALID_REQUESTED_STATUS.get(reqStatus, getBaseDNString(), getServerId())); |
| | | logger.error(ERR_DS_INVALID_REQUESTED_STATUS, reqStatus, getBaseDNString(), getServerId()); |
| | | return; |
| | | } |
| | | |
| | |
| | | attempt of initialization while we have started a new one |
| | | on this side. |
| | | */ |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED, errorMsg.getDetails()); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | // Simply log - happen if import/export has been terminated |
| | | // on our side before receiving this ErrorMsg. |
| | | logger.error(ERR_ERROR_MSG_RECEIVED.get(errorMsg.getDetails())); |
| | | logger.error(ERR_ERROR_MSG_RECEIVED, errorMsg.getDetails()); |
| | | } |
| | | } |
| | | else if (msg instanceof ChangeStatusMsg) |
| | |
| | | Some problems detected: message did not correctly reach every |
| | | requested servers. Log problem |
| | | */ |
| | | logger.error(NOTE_DS_RECEIVED_ACK_ERROR.get( |
| | | getBaseDN(), getServerId(), update, ack.errorsToString())); |
| | | logger.error(NOTE_DS_RECEIVED_ACK_ERROR, getBaseDN(), getServerId(), update, ack.errorsToString()); |
| | | |
| | | List<Integer> failedServers = ack.getFailedServers(); |
| | | |
| | |
| | | |
| | | if (serverToInitialize == RoutableMsg.ALL_SERVERS) |
| | | { |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START_ALL.get( |
| | | countEntries(), getBaseDNString(), getServerId())); |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START_ALL, |
| | | countEntries(), getBaseDNString(), getServerId()); |
| | | |
| | | for (DSInfo dsi : getReplicasList()) |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START.get(countEntries(), |
| | | getBaseDNString(), getServerId(), serverToInitialize)); |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_START, countEntries(), |
| | | getBaseDNString(), getServerId(), serverToInitialize); |
| | | |
| | | ieCtx.startList.add(serverToInitialize); |
| | | |
| | |
| | | */ |
| | | try { Thread.sleep(1000); } |
| | | catch(Exception e){ /* do nothing */ } |
| | | logger.error(NOTE_RESENDING_INIT_TARGET.get( |
| | | exportRootException.getLocalizedMessage())); |
| | | |
| | | logger.error(NOTE_RESENDING_INIT_TARGET, exportRootException.getLocalizedMessage()); |
| | | continue; |
| | | } |
| | | |
| | |
| | | : exportRootException.getLocalizedMessage(); |
| | | if (serverToInitialize == RoutableMsg.ALL_SERVERS) |
| | | { |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END_ALL.get( |
| | | getBaseDNString(), getServerId(), cause)); |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END_ALL, |
| | | getBaseDNString(), getServerId(), cause); |
| | | } |
| | | else |
| | | { |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END.get( |
| | | getBaseDNString(), getServerId(), serverToInitialize, cause)); |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FOR_REMOTE_END, |
| | | getBaseDNString(), getServerId(), serverToInitialize, cause); |
| | | } |
| | | |
| | | |
| | |
| | | try |
| | | { |
| | | // Log starting |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FROM_REMOTE_START.get(getBaseDNString(), |
| | | initTargetMsgReceived.getSenderID(), getServerId())); |
| | | logger.error(NOTE_FULL_UPDATE_ENGAGED_FROM_REMOTE_START, getBaseDNString(), |
| | | initTargetMsgReceived.getSenderID(), getServerId()); |
| | | |
| | | // Go into full update status |
| | | setNewStatus(StatusMachineEvent.TO_FULL_UPDATE_STATUS_EVENT); |
| | |
| | | Restart the whole import protocol exchange by sending again |
| | | the request |
| | | */ |
| | | logger.error(NOTE_RESENDING_INIT_FROM_REMOTE_REQUEST.get( |
| | | ieCtx.getException().getLocalizedMessage())); |
| | | logger.error(NOTE_RESENDING_INIT_FROM_REMOTE_REQUEST, |
| | | 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. |
| | | */ |
| | | logger.error(ERR_SENDING_NEW_ATTEMPT_INIT_REQUEST.get( |
| | | e.getLocalizedMessage(), |
| | | ieCtx.getException().getLocalizedMessage())); |
| | | logger.error(ERR_SENDING_NEW_ATTEMPT_INIT_REQUEST, |
| | | e.getLocalizedMessage(), ieCtx.getException().getLocalizedMessage()); |
| | | } |
| | | } |
| | | |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | logger.error(ERR_DS_CANNOT_CHANGE_STATUS.get(getBaseDN(), getServerId(), status, event)); |
| | | logger.error(ERR_DS_CANNOT_CHANGE_STATUS, getBaseDN(), getServerId(), status, event); |
| | | return; |
| | | } |
| | | |
| | |
| | | } catch (TimeoutException ex) |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), getAssuredTimeout(), update)); |
| | | logger.error(NOTE_DS_ACK_TIMEOUT, getBaseDNString(), getAssuredTimeout(), update); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(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, SMR_CASE_IGNORE_IA5_OID, SYNTAX_ACI_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_AUTH_PASSWORD_EXACT_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_AUTH_PASSWORD_EXACT_NAME, SYNTAX_AUTH_PASSWORD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_AUTH_PASSWORD_EXACT_NAME, SYNTAX_AUTH_PASSWORD_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_BINARY_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_BIT_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_BIT_STRING_OID, SYNTAX_BIT_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_BOOLEAN_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_BOOLEAN_OID, SYNTAX_BOOLEAN_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_CERTIFICATE_EXACT_ASSERTION_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (CertificateException ce) |
| | | { |
| | | // There seems to be a problem while parsing the certificate. |
| | | logger.trace(WARN_CERTIFICATE_MATCH_PARSE_ERROR.get(ce.getMessage())); |
| | | logger.trace(WARN_CERTIFICATE_MATCH_PARSE_ERROR, ce.getMessage()); |
| | | |
| | | // return the raw bytes as a fall back |
| | | return value.toByteString(); |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_CERTLIST_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_CERTPAIR_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CERTIFICATE_EXACT_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CERTIFICATE_EXACT_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CERTIFICATE_EXACT_OID, SYNTAX_CERTIFICATE_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_OCTET_STRING_OID, SYNTAX_CERTIFICATE_NAME); |
| | | } |
| | | |
| | | this.config = configuration; |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_COUNTRY_STRING_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_COUNTRY_STRING_NAME); |
| | | } |
| | | |
| | | this.config = configuration; |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DELIVERY_METHOD_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DELIVERY_METHOD_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_DN_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_DN_OID, SYNTAX_DN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_DN_OID, SYNTAX_DN_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_DN_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_IGNORE_OID, SYNTAX_DN_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_OCTET_STRING_OID, SYNTAX_ENHANCED_GUIDE_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_IGNORE_OID, SYNTAX_FAXNUMBER_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_FAX_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_FAX_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_FAX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_FAX_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_GENERALIZED_TIME_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_GENERALIZED_TIME_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_GENERALIZED_TIME_OID, SYNTAX_GENERALIZED_TIME_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_GENERALIZED_TIME_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_GENERALIZED_TIME_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_GUIDE_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_IA5_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_IA5_STRING_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_IA5_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_IA5_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_IA5_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_IA5_OID, SYNTAX_IA5_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_INTEGER_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_INTEGER_OID, SYNTAX_INTEGER_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_INTEGER_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_INTEGER_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_INTEGER_OID, SYNTAX_INTEGER_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_EXACT_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_EXACT_OID, SYNTAX_INTEGER_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_EXACT_OID, SYNTAX_INTEGER_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_OCTET_STRING_OID, SYNTAX_JPEG_NAME); |
| | | } |
| | | |
| | | this.config = configuration; |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(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, OMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(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, SMR_CASE_IGNORE_OID, SYNTAX_LDAP_SYNTAX_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(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, OMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(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, SMR_CASE_IGNORE_OID, SYNTAX_MATCHING_RULE_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_UNIQUE_MEMBER_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_UNIQUE_MEMBER_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_UNIQUE_MEMBER_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_NAME_AND_OPTIONAL_UID_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_NUMERIC_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_NUMERIC_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_EXACT_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_NUMERIC_STRING_OID, SYNTAX_NUMERIC_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OID_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_OID_OID, SYNTAX_OID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_OID_OID, SYNTAX_OID_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_OID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_IGNORE_OID, SYNTAX_OID_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(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, OMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(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, SMR_OCTET_STRING_OID, SYNTAX_OCTET_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_LIST_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_LIST_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_LIST_OID, SYNTAX_OTHER_MAILBOX_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_DIRECTORY_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRESENTATION_ADDRESS_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PRINTABLE_STRING_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PRINTABLE_STRING_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getApproximateMatchingRule(AMR_DOUBLE_METAPHONE_OID); |
| | | if (defaultApproximateMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE.get( |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_APPROXIMATE_MATCHING_RULE, |
| | | AMR_DOUBLE_METAPHONE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME); |
| | | } |
| | | |
| | | defaultEqualityMatchingRule = |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_PROTOCOL_INFORMATION_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_SUBSTRING_ASSERTION_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | defaultEqualityMatchingRule = DirectoryServer |
| | | .getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = DirectoryServer |
| | | .getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = DirectoryServer |
| | | .getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUBTREE_SPECIFICATION_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_OCTET_STRING_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_OCTET_STRING_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_OCTET_STRING_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_OCTET_STRING_OID, SYNTAX_SUPPORTED_ALGORITHM_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_TELEPHONE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_TELEPHONE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_TELEPHONE_OID, SYNTAX_TELEPHONE_NAME); |
| | | } |
| | | |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get( |
| | | EMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, |
| | | EMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get( |
| | | OMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, |
| | | OMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get( |
| | | SMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, |
| | | SMR_CASE_IGNORE_OID, SYNTAX_TELETEX_TERM_ID_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_CASE_IGNORE_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_CASE_IGNORE_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE.get(SMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_IGNORE_OID, SYNTAX_TELEX_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_GENERALIZED_TIME_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(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, EMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_GENERALIZED_TIME_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(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, OMR_GENERALIZED_TIME_OID, SYNTAX_UTC_TIME_NAME); |
| | | } |
| | | |
| | | defaultSubstringMatchingRule = |
| | | DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); |
| | | if (defaultSubstringMatchingRule == null) |
| | | { |
| | | logger.error(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, SMR_CASE_IGNORE_OID, SYNTAX_UTC_TIME_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | DirectoryServer.getEqualityMatchingRule(EMR_UUID_OID); |
| | | if (defaultEqualityMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE.get(EMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_UUID_OID, SYNTAX_UUID_NAME); |
| | | } |
| | | |
| | | defaultOrderingMatchingRule = |
| | | DirectoryServer.getOrderingMatchingRule(OMR_UUID_OID); |
| | | if (defaultOrderingMatchingRule == null) |
| | | { |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE.get(OMR_UUID_OID, SYNTAX_UUID_NAME)); |
| | | logger.error(ERR_ATTR_SYNTAX_UNKNOWN_ORDERING_MATCHING_RULE, OMR_UUID_OID, SYNTAX_UUID_NAME); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | catch (InitializationException e) |
| | | { |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD.get(e.getMessage())); |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD, e.getMessage()); |
| | | returnCode = 1; |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD |
| | | .get(getExceptionMessage(e))); |
| | | logger.error(ERR_REBUILDINDEX_ERROR_DURING_REBUILD, getExceptionMessage(e)); |
| | | returnCode = 1; |
| | | } |
| | | finally |
| | |
| | | final StringBuilder failureReason = new StringBuilder(); |
| | | if (!LockFileManager.releaseLock(lockFile, failureReason)) |
| | | { |
| | | logger.warn(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend.getBackendID(), failureReason)); |
| | | logger.warn(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), failureReason); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.error(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND.get(backend |
| | | .getBackendID(), getExceptionMessage(e))); |
| | | logger.error(WARN_REBUILDINDEX_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | final String[] commandLineArgs = |
| | | args.toArray(new String[args.size()]); |
| | | // Displays info about command line args for log only. |
| | | logger.debug(INFO_UPGRADE_REBUILD_INDEX_ARGUMENTS.get( |
| | | Arrays.toString(commandLineArgs))); |
| | | logger.debug(INFO_UPGRADE_REBUILD_INDEX_ARGUMENTS, Arrays.toString(commandLineArgs)); |
| | | |
| | | /* |
| | | * The rebuild-index process just display a status ok / fails. The |
| | |
| | | { |
| | | final LocalizableMessage msg = INFO_UPGRADE_REBUILD_INDEX_NO_BACKEND_FOUND.get(); |
| | | logger.debug(msg); |
| | | logger.debug(INFO_UPGRADE_REBUILD_INDEX_DECLINED.get( |
| | | Arrays.toString(indexesListToRebuild.toArray()))); |
| | | logger.debug(INFO_UPGRADE_REBUILD_INDEX_DECLINED, indexesListToRebuild); |
| | | context.notifyProgress(pnc.setProgress(100)); |
| | | } |
| | | } |
| | |
| | | { |
| | | if (changeCount != 0) |
| | | { |
| | | logger.debug(INFO_UPGRADE_CHANGE_DONE_IN_SPECIFIC_FILE.get(fileName, changeCount)); |
| | | logger.debug(INFO_UPGRADE_CHANGE_DONE_IN_SPECIFIC_FILE, fileName, changeCount); |
| | | } |
| | | else |
| | | { |
| | | logger.debug(INFO_UPGRADE_NO_CHANGE_DONE_IN_SPECIFIC_FILE.get(fileName)); |
| | | logger.debug(INFO_UPGRADE_NO_CHANGE_DONE_IN_SPECIFIC_FILE, fileName); |
| | | } |
| | | } |
| | | |
| | |
| | | // 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. |
| | | logger.error(ERR_SCHEMA_CANNOT_WRITE_CONCAT_SCHEMA_FILE.get(concatFilePath, getExceptionMessage(e))); |
| | | logger.error(ERR_SCHEMA_CANNOT_WRITE_CONCAT_SCHEMA_FILE, concatFilePath, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (objectClasses.containsKey(objectClass)) |
| | | { |
| | | logger.warn(WARN_LDIF_DUPLICATE_OBJECTCLASS.get( |
| | | entryDN, lastEntryLineNumber, ocName)); |
| | | logger.warn(WARN_LDIF_DUPLICATE_OBJECTCLASS, entryDN, lastEntryLineNumber, ocName); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | logger.info(NOTE_INSTALL_DIRECTORY.get(installDir)); |
| | | logger.info(NOTE_INSTALL_DIRECTORY, installDir); |
| | | } |
| | | String instanceDir = toCanonicalPath(DirectoryServer.getInstanceRoot()); |
| | | if (instanceDir == null) |
| | |
| | | } |
| | | else |
| | | { |
| | | logger.info(NOTE_INSTANCE_DIRECTORY.get(instanceDir)); |
| | | logger.info(NOTE_INSTANCE_DIRECTORY, instanceDir); |
| | | } |
| | | logger.info(NOTE_JVM_INFO.get(System.getProperty("java.runtime.version"), |
| | | logger.info(NOTE_JVM_INFO, System.getProperty("java.runtime.version"), |
| | | System.getProperty("java.vendor"), |
| | | getArch(),Runtime.getRuntime().maxMemory())); |
| | | getArch(),Runtime.getRuntime().maxMemory()); |
| | | long physicalMemorySize = getPhysicalMemorySize(); |
| | | if (physicalMemorySize != -1) |
| | | { |
| | | logger.info(NOTE_JVM_HOST.get(getHostName(), getOSInfo(), |
| | | physicalMemorySize, Runtime.getRuntime().availableProcessors())); |
| | | logger.info(NOTE_JVM_HOST, getHostName(), getOSInfo(), |
| | | physicalMemorySize, Runtime.getRuntime().availableProcessors()); |
| | | } |
| | | else |
| | | { |
| | | logger.info(NOTE_JVM_HOST_WITH_UNKNOWN_PHYSICAL_MEM.get(getHostName(), |
| | | getOSInfo(), Runtime.getRuntime().availableProcessors())); |
| | | logger.info(NOTE_JVM_HOST_WITH_UNKNOWN_PHYSICAL_MEM, getHostName(), |
| | | getOSInfo(), Runtime.getRuntime().availableProcessors()); |
| | | } |
| | | logger.info(NOTE_JVM_ARGS.get(getInputArguments())); |
| | | logger.info(NOTE_JVM_ARGS, getInputArguments()); |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_ADD_ERROR_NOTIFYING_CHANGE_LISTENER |
| | | .get(getExceptionMessage(e))); |
| | | logger.error(ERR_ADD_ERROR_NOTIFYING_CHANGE_LISTENER, getExceptionMessage(e)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logger.error(ERR_ADD_SYNCH_CONFLICT_RESOLUTION_FAILED.get( |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_ADD_SYNCH_CONFLICT_RESOLUTION_FAILED, |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de)); |
| | | throw de; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (DirectoryException de) |
| | | { |
| | | logger.error(ERR_ADD_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_ADD_SYNCH_PREOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | throw de; |
| | | } |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | logger.error(ERR_ADD_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_ADD_SYNCH_POSTOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | break; |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_DELETE_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | logger.error(ERR_DELETE_SYNCH_CONFLICT_RESOLUTION_FAILED, |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return false; |
| | | } |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_DELETE_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_DELETE_SYNCH_POSTOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return; |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_DELETE_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_DELETE_SYNCH_PREOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return false; |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODDN_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | logger.error(ERR_MODDN_SYNCH_CONFLICT_RESOLUTION_FAILED, |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de)); |
| | | |
| | | setResponseData(de); |
| | | return false; |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODDN_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_MODDN_SYNCH_PREOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return false; |
| | | } |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODDN_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_MODDN_SYNCH_POSTOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return; |
| | | } |
| | |
| | | if (!syntax.isHumanReadable() || syntax.isBinary()) |
| | | { |
| | | // Value is not human-readable |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX_NO_VALUE.get(entryDN, attr.getName(), invalidReason)); |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX_NO_VALUE, entryDN, attr.getName(), invalidReason); |
| | | } |
| | | else |
| | | { |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX.get( |
| | | entryDN, attr.getName(), v.getValue(), invalidReason)); |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX, |
| | | entryDN, attr.getName(), v.getValue(), invalidReason); |
| | | } |
| | | invalidReason = new LocalizableMessageBuilder(); |
| | | } |
| | |
| | | if (!syntax.isHumanReadable() || syntax.isBinary()) |
| | | { |
| | | // Value is not human-readable |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX_NO_VALUE.get( |
| | | entryDN, attr.getName(), invalidReason)); |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX_NO_VALUE, |
| | | entryDN, attr.getName(), invalidReason); |
| | | } |
| | | else |
| | | { |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX.get( |
| | | entryDN, attr.getName(), v.getValue(), invalidReason)); |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX, |
| | | entryDN, attr.getName(), v.getValue(), invalidReason); |
| | | } |
| | | invalidReason = new LocalizableMessageBuilder(); |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODIFY_SYNCH_CONFLICT_RESOLUTION_FAILED.get(getConnectionID(), getOperationID(), |
| | | getExceptionMessage(de))); |
| | | logger.error(ERR_MODIFY_SYNCH_CONFLICT_RESOLUTION_FAILED, |
| | | getConnectionID(), getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return false; |
| | | } |
| | |
| | | } |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODIFY_SYNCH_PREOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_MODIFY_SYNCH_PREOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return false; |
| | | } |
| | |
| | | provider.doPostOperation(this); |
| | | } catch (DirectoryException de) { |
| | | logger.traceException(de); |
| | | logger.error(ERR_MODIFY_SYNCH_POSTOP_FAILED.get(getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de))); |
| | | logger.error(ERR_MODIFY_SYNCH_POSTOP_FAILED, getConnectionID(), |
| | | getOperationID(), getExceptionMessage(de)); |
| | | setResponseData(de); |
| | | return; |
| | | } |