Removed now useless calls to .toString() on arguments of ArgN.get(...).
| | |
| | | */ |
| | | private String getAverageHeader(MonitoringAttributes attr) |
| | | { |
| | | return getHeader(INFO_CTRL_PANEL_AVERAGE_HEADER.get( |
| | | attr.getMessage().toString()), 15); |
| | | return getHeader(INFO_CTRL_PANEL_AVERAGE_HEADER.get(attr.getMessage()), 15); |
| | | } |
| | | |
| | | /** |
| | |
| | | args.add(getNoPropertiesFileArgument()); |
| | | printEquivalentCommandLine( |
| | | getConfigCommandLinePath(baseDN.getBackend()), |
| | | args, INFO_CTRL_PANEL_EQUIVALENT_CMD_TO_DELETE_DOMAIN.get( |
| | | baseDN.getDn().toString())); |
| | | args, INFO_CTRL_PANEL_EQUIVALENT_CMD_TO_DELETE_DOMAIN.get(baseDN.getDn())); |
| | | } |
| | | }); |
| | | } |
| | |
| | | { |
| | | getProgressDialog().appendProgressHtml( |
| | | Utilities.getProgressWithPoints( |
| | | INFO_CTRL_PANEL_DELETING_DOMAIN.get( |
| | | baseDN.getDn().toString()), |
| | | INFO_CTRL_PANEL_DELETING_DOMAIN.get(baseDN.getDn()), |
| | | ColorAndFontConstants.progressFont)); |
| | | } |
| | | }); |
| | |
| | | getProgressDialog().setSummary( |
| | | LocalizableMessage.raw( |
| | | Utilities.applyFont( |
| | | INFO_CTRL_PANEL_DELETING_ENTRY_SUMMARY.get( |
| | | lastDn.toString()).toString(), |
| | | INFO_CTRL_PANEL_DELETING_ENTRY_SUMMARY.get(lastDn), |
| | | ColorAndFontConstants.defaultFont))); |
| | | } |
| | | }); |
| | |
| | | getProgressDialog().setSummary( |
| | | LocalizableMessage.raw( |
| | | Utilities.applyFont( |
| | | INFO_CTRL_PANEL_DELETING_ENTRY_SUMMARY.get( |
| | | lastDn.toString()).toString(), |
| | | INFO_CTRL_PANEL_DELETING_ENTRY_SUMMARY.get(lastDn), |
| | | ColorAndFontConstants.defaultFont))); |
| | | } |
| | | }); |
| | |
| | | INFO_CTRL_PANEL_EQUIVALENT_CMD_TO_STOP_SERVER.get()); |
| | | dlg.setSummary(LocalizableMessage.raw( |
| | | Utilities.applyFont( |
| | | INFO_CTRL_PANEL_STOPPING_SERVER_SUMMARY.get().toString(), |
| | | INFO_CTRL_PANEL_STOPPING_SERVER_SUMMARY.get(), |
| | | ColorAndFontConstants.defaultFont))); |
| | | } |
| | | }); |
| | |
| | | |
| | | dlg.setSummary(LocalizableMessage.raw( |
| | | Utilities.applyFont( |
| | | INFO_CTRL_PANEL_STARTING_SERVER_SUMMARY.get().toString(), |
| | | INFO_CTRL_PANEL_STARTING_SERVER_SUMMARY.get(), |
| | | ColorAndFontConstants.defaultFont))); |
| | | } |
| | | }); |
| | |
| | | Task taskToBeLaunched) |
| | | { |
| | | return INFO_CTRL_PANEL_INCOMPATIBLE_TASKS.get( |
| | | taskRunning.getTaskDescription().toString(), |
| | | taskToBeLaunched.getTaskDescription().toString()); |
| | | taskRunning.getTaskDescription(), taskToBeLaunched.getTaskDescription()); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (LDAPException le) |
| | | { |
| | | errors.add(INFO_CTRL_PANEL_INVALID_FILTER_DETAILS.get( |
| | | le.getMessageObject().toString())); |
| | | errors.add(INFO_CTRL_PANEL_INVALID_FILTER_DETAILS.get(le.getMessageObject())); |
| | | setPrimaryInvalid(lFilter); |
| | | } |
| | | if (errors.isEmpty()) |
| | |
| | | catch (NamingException ne) |
| | | { |
| | | errorTitle = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_DETAILS.get(); |
| | | errorDetails = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_SUMMARY.get( |
| | | ne.toString()); |
| | | errorDetails = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_SUMMARY.get(ne); |
| | | displayErrorPane = true; |
| | | } |
| | | catch (ConfigReadException cre) |
| | | { |
| | | errorTitle = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_DETAILS.get(); |
| | | errorDetails = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_SUMMARY.get( |
| | | cre.getMessageObject().toString()); |
| | | errorDetails = INFO_CTRL_PANEL_ERROR_CONNECT_BROWSE_SUMMARY.get(cre.getMessageObject()); |
| | | displayErrorPane = true; |
| | | } |
| | | } |
| | |
| | | confirm = displayConfirmationDialog( |
| | | INFO_CTRL_PANEL_VLV_INDEXES_NOT_DEFINED_CONFIRMATION_TITLE.get(), |
| | | INFO_CTRL_PANEL_VLV_INDEXES_NOT_DEFINED_CONFIRMATION_MSG.get( |
| | | getBackend().getBackendID(), sb.toString())); |
| | | getBackend().getBackendID(), sb)); |
| | | } |
| | | } |
| | | catch (Throwable t) |
| | |
| | | } |
| | | catch (OpenDsException oe) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_INVALID_BASE_DN_FOR_VLV_PROVIDED.get( |
| | | oe.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_INVALID_BASE_DN_FOR_VLV_PROVIDED.get(oe.getMessageObject())); |
| | | setPrimaryInvalid(lBaseDN); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (LDAPException le) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_INVALID_FILTER_FOR_VLV_PROVIDED.get( |
| | | le.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_INVALID_FILTER_FOR_VLV_PROVIDED.get(le.getMessageObject())); |
| | | setPrimaryInvalid(lFilter); |
| | | } |
| | | } |
| | |
| | | catch (OpenDsException ode) |
| | | { |
| | | errors.add(INFO_CTRL_PANEL_INVALID_DN_DETAILS.get(groupDn, |
| | | ode.getMessageObject().toString())); |
| | | ode.getMessageObject())); |
| | | } |
| | | } |
| | | } |
| | |
| | | else |
| | | { |
| | | initMsg = INFO_CTRL_PANEL_RUN_BACKUP_SUMMARY.get( |
| | | backends.getSelectedItem().toString()); |
| | | backends.getSelectedItem()); |
| | | } |
| | | launchOperation(newTask, |
| | | initMsg, |
| | |
| | | } |
| | | catch (OpenDsException ode) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_INVALID_BASE_DN_PROVIDED.get( |
| | | ode.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_INVALID_BASE_DN_PROVIDED.get(ode.getMessageObject())); |
| | | } |
| | | } |
| | | |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ATTRIBUTE_NAME_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ATTRIBUTE_NAME_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lName); |
| | | } |
| | | } |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lOID); |
| | | } |
| | | } |
| | |
| | | NewAttributePanel.getSchemaElementType(alias, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lAliases); |
| | | } |
| | | } |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lName); |
| | | } |
| | | } |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lOID); |
| | | } |
| | | } |
| | |
| | | NewAttributePanel.getSchemaElementType(alias, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lAliases); |
| | | } |
| | | } |
| | |
| | | { |
| | | LocalizableMessage title = INFO_CTRL_PANEL_ERROR_SEARCHING_ENTRY_TITLE.get(); |
| | | LocalizableMessage details = |
| | | ERR_CTRL_PANEL_ERROR_SEARCHING_ENTRY.get(node.getDN(), |
| | | throwable.toString()); |
| | | ERR_CTRL_PANEL_ERROR_SEARCHING_ENTRY.get(node.getDN(), throwable); |
| | | displayErrorMessage(title, details); |
| | | } |
| | | else |
| | |
| | | if (t instanceof OpenDsException) |
| | | { |
| | | details = ERR_CTRL_PANEL_ERROR_SEARCHING_ENTRY.get(dn, |
| | | ((OpenDsException)t).getMessageObject().toString()); |
| | | ((OpenDsException)t).getMessageObject()); |
| | | } |
| | | else |
| | | { |
| | | details = ERR_CTRL_PANEL_ERROR_SEARCHING_ENTRY.get(dn, |
| | | t.toString()); |
| | | details = ERR_CTRL_PANEL_ERROR_SEARCHING_ENTRY.get(dn, t); |
| | | } |
| | | updateErrorPane(errorPane, title, ColorAndFontConstants.errorTitleFont, |
| | | details, ColorAndFontConstants.defaultFont); |
| | |
| | | } |
| | | else if (ex instanceof NameNotFoundException) |
| | | { |
| | | msg = |
| | | ERR_CTRL_PANEL_COULD_NOT_FIND_PROVIDED_ENTRY_IN_REFERRAL.get( |
| | | arg.toString(), hostPort); |
| | | msg = ERR_CTRL_PANEL_COULD_NOT_FIND_PROVIDED_ENTRY_IN_REFERRAL.get(arg, hostPort); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | else if (ex instanceof NameNotFoundException) |
| | | { |
| | | msg = |
| | | ERR_CTRL_PANEL_COULD_NOT_FIND_PROVIDED_ENTRY_IN_REFERRAL_NO_HOST.get( |
| | | arg.toString()); |
| | | msg = ERR_CTRL_PANEL_COULD_NOT_FIND_PROVIDED_ENTRY_IN_REFERRAL_NO_HOST.get(arg); |
| | | } |
| | | else |
| | | { |
| | |
| | | if ((errors.isEmpty()) && confirmed) |
| | | { |
| | | launchOperation(newTask, |
| | | INFO_CTRL_PANEL_EXPORTING_LDIF_SUMMARY.get( |
| | | backends.getSelectedItem().toString()), |
| | | INFO_CTRL_PANEL_EXPORTING_LDIF_SUMMARY.get(backends.getSelectedItem()), |
| | | INFO_CTRL_PANEL_EXPORTING_LDIF_SUCCESSFUL_SUMMARY.get(), |
| | | INFO_CTRL_PANEL_EXPORTING_LDIF_SUCCESSFUL_DETAILS.get(), |
| | | ERR_CTRL_PANEL_EXPORTING_LDIF_ERROR_SUMMARY.get(), |
| | |
| | | * |
| | | * |
| | | * Copyright 2008-2009 Sun Microsystems, Inc. |
| | | * Portions Copyright 2014 ForgeRock AS |
| | | */ |
| | | |
| | | package org.opends.guitools.controlpanel.ui; |
| | | |
| | | import static org.opends.messages.AdminToolMessages.*; |
| | |
| | | if (panel.getTitle() != null) |
| | | { |
| | | setTitle(INFO_CTRL_PANEL_GENERIC_TITLE.get( |
| | | DynamicConstants.PRODUCT_NAME, |
| | | panel.getTitle().toString()).toString()); |
| | | DynamicConstants.PRODUCT_NAME, panel.getTitle()).toString()); |
| | | } |
| | | } |
| | | |
| | |
| | | * |
| | | * |
| | | * Copyright 2009 Sun Microsystems, Inc. |
| | | * Portions Copyright 2014 ForgeRock AS |
| | | */ |
| | | |
| | | package org.opends.guitools.controlpanel.ui; |
| | | |
| | | import static org.opends.messages.AdminToolMessages.*; |
| | |
| | | { |
| | | setTitle(INFO_CTRL_PANEL_GENERIC_TITLE.get( |
| | | DynamicConstants.PRODUCT_NAME, |
| | | panel.getTitle().toString()).toString()); |
| | | panel.getTitle()).toString()); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | newTask.setInitializeAll(initializeAll); |
| | | launchOperation(newTask, |
| | | INFO_CTRL_PANEL_IMPORTING_LDIF_SUMMARY.get( |
| | | backends.getSelectedItem().toString()), |
| | | INFO_CTRL_PANEL_IMPORTING_LDIF_SUMMARY.get(backends.getSelectedItem()), |
| | | INFO_CTRL_PANEL_IMPORTING_LDIF_SUCCESSFUL_SUMMARY.get(), |
| | | INFO_CTRL_PANEL_IMPORTING_LDIF_SUCCESSFUL_DETAILS.get(), |
| | | ERR_CTRL_PANEL_IMPORTING_LDIF_ERROR_SUMMARY.get(), |
| | |
| | | } |
| | | catch (LDAPException le) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_INVALID_FILTER_DETAILS_WITH_VALUE.get(s, |
| | | le.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_INVALID_FILTER_DETAILS_WITH_VALUE.get(s, le.getMessageObject())); |
| | | setPrimaryInvalid(lFilter); |
| | | } |
| | | } |
| | |
| | | File javaFile = getJavaFile(file); |
| | | if (!javaFile.exists()) |
| | | { |
| | | javaHomeErrors.add(ERR_CTRL_PANEL_JAVA_BINARY_NOT_FOUND.get( |
| | | javaFile.toString())); |
| | | javaHomeErrors.add(ERR_CTRL_PANEL_JAVA_BINARY_NOT_FOUND.get(javaFile)); |
| | | } |
| | | } |
| | | } |
| | |
| | | { |
| | | confirmationMessage = |
| | | INFO_CTRL_PANEL_CONFIRM_NOT_WORKING_ARGUMENTS_DETAILS.get( |
| | | javaFile.toString(), |
| | | javaFile, |
| | | Utilities.getStringFromCollection(notWorkingArgs, "<br>-")); |
| | | } |
| | | else |
| | | { |
| | | confirmationMessage = |
| | | INFO_CTRL_PANEL_CONFIRM_NOT_WORKING_FALLBACK_ARGUMENTS_DETAILS.get( |
| | | javaFile.toString(), |
| | | javaFile, |
| | | Utilities.getStringFromCollection(notWorkingArgs, "<br>-")); |
| | | } |
| | | confirmationMessages.add(confirmationMessage); |
| | |
| | | } |
| | | catch (OpenDsException ode) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_INVALID_ENTRY.get( |
| | | ode.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_INVALID_ENTRY.get(ode.getMessageObject())); |
| | | } |
| | | if (errors.size() > 0) |
| | | { |
| | |
| | | LocalizableMessage elementType = getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ATTRIBUTE_NAME_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ATTRIBUTE_NAME_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lName); |
| | | } |
| | | } |
| | |
| | | LocalizableMessage elementType = getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lOID); |
| | | } |
| | | } |
| | |
| | | LocalizableMessage elementType = getSchemaElementType(alias, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, elementType)); |
| | | setPrimaryInvalid(lAliases); |
| | | } |
| | | } |
| | |
| | | { |
| | | if (backendName.equalsIgnoreCase(backend.getBackendID())) |
| | | { |
| | | errors.add(ERR_BASE_DN_ANCESTOR_EXISTS.get( |
| | | baseDN.getDn().toString())); |
| | | errors.add(ERR_BASE_DN_ANCESTOR_EXISTS.get(baseDN.getDn())); |
| | | setPrimaryInvalid(lDirectoryBaseDN); |
| | | baseDNAlreadyDefined = true; |
| | | break; |
| | |
| | | { |
| | | if (backendName.equalsIgnoreCase(backend.getBackendID())) |
| | | { |
| | | errors.add(ERR_BASE_DN_DN_IS_ANCESTOR_OF.get( |
| | | baseDN.getDn().toString())); |
| | | errors.add(ERR_BASE_DN_DN_IS_ANCESTOR_OF.get(baseDN.getDn())); |
| | | setPrimaryInvalid(lDirectoryBaseDN); |
| | | baseDNAlreadyDefined = true; |
| | | break; |
| | |
| | | } |
| | | catch (OpenDsException oe) |
| | | { |
| | | errors.add(INFO_CTRL_PANEL_INVALID_DN_DETAILS.get(dn, |
| | | oe.getMessageObject().toString())); |
| | | errors.add(INFO_CTRL_PANEL_INVALID_DN_DETAILS.get(dn, oe.getMessageObject())); |
| | | setPrimaryInvalid(lDirectoryBaseDN); |
| | | } |
| | | } |
| | |
| | | catch (OpenDsException ode) |
| | | { |
| | | errorFound = true; |
| | | errors.add(ERR_CTRL_PANEL_MEMBER_VALUE_NOT_VALID.get(member, |
| | | ode.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_MEMBER_VALUE_NOT_VALID.get(member, ode.getMessageObject())); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (OpenDsException ode) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_GROUP_FILTER_NOT_VALID.get( |
| | | ode.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_GROUP_FILTER_NOT_VALID.get(ode.getMessageObject())); |
| | | } |
| | | } |
| | | if (errorFound) |
| | |
| | | catch (OpenDsException ode) |
| | | { |
| | | errorFound = true; |
| | | errors.add(ERR_CTRL_PANEL_REFERENCE_GROUP_NOT_VALID.get( |
| | | ode.getMessageObject().toString())); |
| | | errors.add(ERR_CTRL_PANEL_REFERENCE_GROUP_NOT_VALID.get(ode.getMessageObject())); |
| | | } |
| | | if (errorFound) |
| | | { |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OBJECTCLASS_NAME_ALREADY_IN_USE.get(n, elementType)); |
| | | } |
| | | } |
| | | |
| | |
| | | LocalizableMessage elementType = NewAttributePanel.getSchemaElementType(n, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_OID_ALREADY_IN_USE.get(n, elementType)); |
| | | } |
| | | } |
| | | } |
| | |
| | | alias, schema); |
| | | if (elementType != null) |
| | | { |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, |
| | | elementType.toString())); |
| | | errors.add(ERR_CTRL_PANEL_ALIAS_ALREADY_IN_USE.get(n, elementType)); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | errorPane.setVisible(true); |
| | | errorPane.setText(Utilities.applyFont( |
| | | INFO_CTRL_PANEL_PLEASE_WAIT_SUMMARY.get().toString(), |
| | | INFO_CTRL_PANEL_PLEASE_WAIT_SUMMARY.get(), |
| | | ColorAndFontConstants.defaultFont)); |
| | | |
| | | gbc.anchor = GridBagConstraints.WEST; |
| | |
| | | */ |
| | | protected static LocalizableMessage getLabel(MonitoringAttributes attr) |
| | | { |
| | | return INFO_CTRL_PANEL_OPERATION_NAME_AS_LABEL.get( |
| | | attr.getMessage().toString()); |
| | | return INFO_CTRL_PANEL_OPERATION_NAME_AS_LABEL.get(attr.getMessage()); |
| | | } |
| | | |
| | | /** |
| | |
| | | // is 2nd (or 1st depending of the year) of Mars. |
| | | if (calendar.get(Calendar.MONTH) != m) |
| | | { |
| | | errorMessages.add(ERR_CTRL_PANEL_INVALID_DAY_IN_MONTH.get(d, |
| | | month.getSelectedItem().toString())); |
| | | errorMessages.add(ERR_CTRL_PANEL_INVALID_DAY_IN_MONTH.get(d, month.getSelectedItem())); |
| | | setPrimaryInvalid(lDay); |
| | | setPrimaryInvalid(lMonth); |
| | | } |
| | |
| | | GridBagConstraints gbc = new GridBagConstraints(); |
| | | |
| | | JEditorPane explanation = Utilities.makeHtmlPane( |
| | | INFO_CTRL_PANEL_CRON_HELP.get().toString(), |
| | | INFO_CTRL_PANEL_CRON_HELP.get(), |
| | | ColorAndFontConstants.inlineHelpFont); |
| | | gbc.gridx = 0; |
| | | gbc.gridy = 0; |
| | |
| | | } |
| | | else |
| | | { |
| | | returnValue = INFO_CTRL_PANEL_CONTENTS_OF_FILE.get( |
| | | value.getFile().toString()); |
| | | returnValue = INFO_CTRL_PANEL_CONTENTS_OF_FILE.get(value.getFile()); |
| | | } |
| | | return returnValue; |
| | | } |
| | |
| | | if (parentDN == null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_FILE_UNKNOWN_PARENT.get( |
| | | entryDN.toString(), |
| | | reader.getLastEntryLineNumber(), |
| | | f.getAbsolutePath()); |
| | | entryDN, reader.getLastEntryLineNumber(), f.getAbsolutePath()); |
| | | throw new InitializationException(message); |
| | | } |
| | | else |
| | |
| | | * @param font the font to be used in the message. |
| | | * @return a JEditorPane that displays a message. |
| | | */ |
| | | public static JEditorPane makeHtmlPane(String text, Font font) |
| | | public static JEditorPane makeHtmlPane(CharSequence text, Font font) |
| | | { |
| | | JEditorPane pane = new JEditorPane(); |
| | | pane.setContentType("text/html"); |
| | |
| | | * @return a string that represents the original HTML with the font specified |
| | | * as parameter. |
| | | */ |
| | | public static String applyFont(String html, Font font) |
| | | public static String applyFont(CharSequence html, Font font) |
| | | { |
| | | StringBuilder buf = new StringBuilder(); |
| | | |
| | |
| | | */ |
| | | public static String getProgressDone(Font progressFont) |
| | | { |
| | | return applyFont(INFO_CTRL_PANEL_PROGRESS_DONE.get().toString(), |
| | | return applyFont(INFO_CTRL_PANEL_PROGRESS_DONE.get(), |
| | | progressFont.deriveFont(Font.BOLD)); |
| | | } |
| | | |
| | |
| | | { |
| | | l.setText(INFO_CTRL_PANEL_NOT_AVAILABLE_LONG_LABEL.get().toString()); |
| | | l.setHelpIconVisible(true); |
| | | l.setHelpTooltip( |
| | | INFO_NOT_AVAILABLE_AUTHENTICATION_REQUIRED_TOOLTIP.get() |
| | | .toString()); |
| | | l.setHelpTooltip(INFO_NOT_AVAILABLE_AUTHENTICATION_REQUIRED_TOOLTIP.get().toString()); |
| | | } |
| | | |
| | | /** |
| | |
| | | { |
| | | l.setText(INFO_CTRL_PANEL_NOT_AVAILABLE_LONG_LABEL.get().toString()); |
| | | l.setHelpIconVisible(true); |
| | | l.setHelpTooltip( |
| | | INFO_NOT_AVAILABLE_AUTHENTICATION_REQUIRED_TOOLTIP.get() |
| | | .toString()); |
| | | l.setHelpTooltip(INFO_NOT_AVAILABLE_AUTHENTICATION_REQUIRED_TOOLTIP.get().toString()); |
| | | } |
| | | |
| | | /** |
| | |
| | | returnValue = askConfirmation( |
| | | ERR_UNINSTALL_READING_REGISTERED_SERVERS_CONFIRM_UPDATE_REMOTE.get( |
| | | Utils.getMessageFromCollection(exceptionMsgs, |
| | | Constants.LINE_SEPARATOR).toString()), true, logger); |
| | | Constants.LINE_SEPARATOR)), true, logger); |
| | | } |
| | | catch (CLIException ce) |
| | | { |
| | |
| | | "--"+ToolConstants.OPTION_LONG_BINDPWD_FILE, |
| | | "--"+parser.forceOnErrorArg.getLongIdentifier(), |
| | | Utils.getMessageFromCollection(exceptionMsgs, |
| | | Constants.LINE_SEPARATOR).toString()); |
| | | Constants.LINE_SEPARATOR)); |
| | | throw new ApplicationException(ReturnCode.APPLICATION_ERROR, msg, |
| | | null); |
| | | } |
| | |
| | | { |
| | | LocalizableMessage confirmationMsg = |
| | | ERR_UNINSTALL_READING_REGISTERED_SERVERS_CONFIRM_UPDATE_REMOTE.get( |
| | | getMessageFromCollection(exceptionMsgs, "\n").toString()); |
| | | getMessageFromCollection(exceptionMsgs, "\n")); |
| | | stopProcessing = !qs.displayConfirmation(confirmationMsg, |
| | | INFO_CONFIRMATION_TITLE.get()); |
| | | } |
| | |
| | | "--"+ToolConstants.OPTION_LONG_BINDPWD, |
| | | "--"+ToolConstants.OPTION_LONG_BINDPWD_FILE, |
| | | "--"+parser.forceOnErrorArg.getLongIdentifier(), |
| | | ae.getMessageObject().toString()); |
| | | ae.getMessageObject()); |
| | | throw new ApplicationException(ae.getType(), msg, ae); |
| | | } |
| | | else |
| | |
| | | "Error removing references in replication server on "+ |
| | | serverDisplay+": "+t, t)); |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | serverDisplay, t); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | t); |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, t); |
| | | } |
| | | ADSContext adsContext = new ADSContext(ctx); |
| | | |
| | |
| | | { |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_REMOTE_ADS_EXCEPTION.get( |
| | | serverDisplay, ace.toString()), ace); |
| | | INFO_REMOTE_ADS_EXCEPTION.get(serverDisplay, ace), |
| | | ace); |
| | | } |
| | | else |
| | | { |
| | |
| | | adminProperties.put(ADSContext.AdministratorProperty.PASSWORD, |
| | | userData.getGlobalAdministratorPassword()); |
| | | adminProperties.put(ADSContext.AdministratorProperty.DESCRIPTION, |
| | | INFO_GLOBAL_ADMINISTRATOR_DESCRIPTION.get().toString()); |
| | | INFO_GLOBAL_ADMINISTRATOR_DESCRIPTION.get()); |
| | | return adminProperties; |
| | | } |
| | | |
| | |
| | | qs.displayFieldInvalid(FieldName.REMOTE_SERVER_PORT, true); |
| | | qs.displayFieldInvalid(FieldName.REMOTE_SERVER_DN, true); |
| | | qs.displayFieldInvalid(FieldName.REMOTE_SERVER_PWD, true); |
| | | errorMsgs.add(INFO_CANNOT_CONNECT_TO_REMOTE_GENERIC.get( |
| | | host+":"+port, t.toString())); |
| | | errorMsgs.add(INFO_CANNOT_CONNECT_TO_REMOTE_GENERIC.get(host+":"+port, t)); |
| | | } |
| | | } |
| | | else if (t instanceof NamingException) |
| | |
| | | } |
| | | else if (t instanceof ADSContextException) |
| | | { |
| | | errorMsgs.add(INFO_REMOTE_ADS_EXCEPTION.get( |
| | | host+":"+port, t.toString())); |
| | | errorMsgs.add(INFO_REMOTE_ADS_EXCEPTION.get(host+":"+port, t)); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get(serverDisplay, t), |
| | | t); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get(serverDisplay, t), |
| | | t); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get(serverDisplay, t), |
| | | t); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get(serverDisplay, t), |
| | | t); |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (Throwable t) |
| | | { |
| | | LocalizableMessage errorMessage = INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get( |
| | | serverDisplay, t.toString()); |
| | | throw new ApplicationException( |
| | | ReturnCode.CONFIGURATION_ERROR, errorMessage, |
| | | ReturnCode.CONFIGURATION_ERROR, |
| | | INFO_ERROR_CONFIGURING_REMOTE_GENERIC.get(serverDisplay, t), |
| | | t); |
| | | } |
| | | } |
| | |
| | | } |
| | | |
| | | final LocalizableMessage message = ERR_PWPSTATE_CANNOT_DECODE_BOOLEAN |
| | | .get(valueString, attributeType.getNameOrOID(), entry.getName() |
| | | .toString()); |
| | | .get(valueString, attributeType.getNameOrOID(), entry.getName()); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | } |
| | |
| | | if(dn == DN.rootDN()) { |
| | | msgDN=configDN; |
| | | } |
| | | LocalizableMessage message = WARN_ACI_ADD_LIST_FAILED_DECODE.get( |
| | | value.getValue().toString(), |
| | | String.valueOf(msgDN), |
| | | ex.getMessage()); |
| | | failedACIMsgs.add(message); |
| | | failedACIMsgs.add(WARN_ACI_ADD_LIST_FAILED_DECODE.get( |
| | | value.getValue(), msgDN, ex.getMessage())); |
| | | } |
| | | } |
| | | } |
| | |
| | | break; |
| | | } |
| | | default: { |
| | | LocalizableMessage message = WARN_ACI_SYNTAX_INVALID_BIND_RULE_KEYWORD.get( |
| | | keyword.toString()); |
| | | throw new AciException(message); |
| | | throw new AciException(WARN_ACI_SYNTAX_INVALID_BIND_RULE_KEYWORD.get(keyword)); |
| | | } |
| | | } |
| | | return rule; |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_NO_EQUAL.get( |
| | | dnString, attributeName.toString(), c); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_NO_EQUAL.get(dnString, attributeName, c)); |
| | | } |
| | | |
| | | // Skip over any spaces after the equal sign. |
| | |
| | | // because that would be invalid. |
| | | if (pos >= length) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | validOID = false; |
| | | } |
| | | |
| | | |
| | | if (! validOID) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get(dnString, attributeName)); |
| | | } |
| | | } |
| | | |
| | | |
| | | return pos; |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | backupBaseDN.toString(), getExceptionMessage(e)); |
| | | backupBaseDN, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | // map. |
| | | if (baseDNs == null || baseDNs.length != 1) |
| | | { |
| | | LocalizableMessage message = ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get( |
| | | currentConfig.dn().toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get(currentConfig.dn())); |
| | | } |
| | | |
| | | for (DN dn : baseDNs) |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | dn.toString(), getExceptionMessage(e)); |
| | | dn, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ERROR_CREATING_FILE.get( |
| | | tempFile.getAbsolutePath(), |
| | | currentConfig.dn().toString(), |
| | | currentConfig.dn(), |
| | | stackTraceToSingleLineString(e)); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_BACKEND_CANNOT_WRITE_UPDATE, m); |
| | |
| | | |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ERROR_WRITING_FILE.get( |
| | | tempFile.getAbsolutePath(), |
| | | currentConfig.dn().toString(), |
| | | currentConfig.dn(), |
| | | stackTraceToSingleLineString(e)); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_BACKEND_CANNOT_WRITE_UPDATE, m); |
| | |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ERROR_RENAMING_FILE.get( |
| | | tempFile.getAbsolutePath(), |
| | | ldifFile.getAbsolutePath(), |
| | | currentConfig.dn().toString(), |
| | | currentConfig.dn(), |
| | | stackTraceToSingleLineString(e)); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_LDIF_BACKEND_CANNOT_WRITE_UPDATE, m); |
| | |
| | | parentDN = parentDN.getParentDNInSuffix(); |
| | | } |
| | | |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MODDN_NO_SUCH_SOURCE_ENTRY.get( |
| | | currentDN.toString()); |
| | | throw new DirectoryException(ResultCode.NO_SUCH_OBJECT, m, matchedDN, |
| | | null); |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MODDN_NO_SUCH_SOURCE_ENTRY.get(currentDN); |
| | | throw new DirectoryException(ResultCode.NO_SUCH_OBJECT, m, matchedDN, null); |
| | | } |
| | | |
| | | if (entryMap.containsKey(newDN)) |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MODDN_TARGET_ENTRY_ALREADY_EXISTS.get( |
| | | newDN.toString()); |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MODDN_TARGET_ENTRY_ALREADY_EXISTS.get(newDN); |
| | | throw new DirectoryException(ResultCode.ENTRY_ALREADY_EXISTS, m); |
| | | } |
| | | |
| | |
| | | DN entryDN = e.getName(); |
| | | if (entryMap.containsKey(entryDN)) |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_DUPLICATE_ENTRY.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | LocalizableMessage m = |
| | | ERR_LDIF_BACKEND_DUPLICATE_ENTRY.get(ldifFilePath, currentConfig.dn(), entryDN); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | |
| | | |
| | | if (! isBelowBaseDN) |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ENTRY_OUT_OF_SCOPE.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_ENTRY_OUT_OF_SCOPE.get( |
| | | ldifFilePath, currentConfig.dn(), entryDN); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | |
| | | DN parentDN = entryDN.getParentDNInSuffix(); |
| | | if (parentDN == null || !entryMap.containsKey(parentDN)) |
| | | { |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MISSING_PARENT.get(ldifFilePath, |
| | | currentConfig.dn().toString(), entryDN.toString()); |
| | | LocalizableMessage m = ERR_LDIF_BACKEND_MISSING_PARENT.get( |
| | | ldifFilePath, currentConfig.dn(), entryDN); |
| | | logger.error(m); |
| | | reader.rejectLastEntry(m); |
| | | continue; |
| | |
| | | currentConfig.getBaseDN().toArray(baseDNs); |
| | | if (baseDNs.length != 1) |
| | | { |
| | | throw new ConfigException(ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get( |
| | | currentConfig.dn().toString())); |
| | | throw new ConfigException(ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get(currentConfig.dn())); |
| | | } |
| | | |
| | | baseDNSet = new HashSet<DN>(); |
| | |
| | | // Make sure that there is only a single base DN. |
| | | if (configuration.getBaseDN().size() != 1) |
| | | { |
| | | unacceptableReasons.add(ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get( |
| | | configuration.dn().toString())); |
| | | unacceptableReasons.add(ERR_LDIF_BACKEND_MULTIPLE_BASE_DNS.get(configuration.dn())); |
| | | configAcceptable = false; |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | dn.toString(), getExceptionMessage(e)); |
| | | dn, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | logger.traceException(e); |
| | | |
| | | final LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | baseMonitorDN.toString(), getExceptionMessage(e)); |
| | | baseMonitorDN, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | dn.toString(), getExceptionMessage(e)); |
| | | dn, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | StringBuilder basesStr = new StringBuilder(); |
| | | StringBuilder basesStr = new StringBuilder("{ "); |
| | | for (DN dn : subordinateBaseDNs.keySet()) |
| | | { |
| | | if (basesStr.length() > 0) |
| | | { |
| | | basesStr.append(", "); |
| | | } |
| | | else |
| | | { |
| | | basesStr.append("{ "); |
| | | } |
| | | |
| | | basesStr.append(dn); |
| | | } |
| | | |
| | | basesStr.append(" }"); |
| | | |
| | | LocalizableMessage message = INFO_ROOTDSE_USING_NEW_SUBORDINATE_BASE_DNS.get( |
| | | basesStr.toString()); |
| | | messages.add(message); |
| | | messages.add(INFO_ROOTDSE_USING_NEW_SUBORDINATE_BASE_DNS.get(basesStr)); |
| | | } |
| | | |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | baseDN.toString(), getExceptionMessage(e)); |
| | | baseDN, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_ATTRTYPE.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_NAME_FORM.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_DCR.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_DSR.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_MR_USE.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | |
| | | LocalizableMessage message = |
| | | ERR_SCHEMA_MODIFY_CANNOT_DECODE_LDAP_SYNTAX.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_ATTRTYPE.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_NAME_FORM.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_DCR.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_DSR.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_MR_USE.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | |
| | | LocalizableMessage message = |
| | | ERR_SCHEMA_MODIFY_CANNOT_DECODE_LDAP_SYNTAX.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, de); |
| | | } |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_ATTRTYPE.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, |
| | | de); |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_OBJECTCLASS.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, |
| | | de); |
| | |
| | | buffer.append("\t"); |
| | | } |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_REMOVE_OC_IN_NF.get( |
| | | removeClass.getNameOrOID(), buffer.toString()); |
| | | removeClass.getNameOrOID(), buffer); |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_NAME_FORM.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, |
| | | de); |
| | |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = ERR_SCHEMA_MODIFY_CANNOT_DECODE_DSR.get( |
| | | v.getValue().toString(), de.getMessageObject()); |
| | | v.getValue(), de.getMessageObject()); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message, |
| | | de); |
| | |
| | | parentID = dn2id.get(txn, parentDN, LockMode.DEFAULT); |
| | | if (parentID == null) |
| | | { |
| | | LocalizableMessage message = ERR_JEB_ADD_NO_SUCH_OBJECT.get( |
| | | entry.getName().toString()); |
| | | LocalizableMessage message = ERR_JEB_ADD_NO_SUCH_OBJECT.get(entry.getName()); |
| | | DN matchedDN = getMatchedDN(baseDN); |
| | | throw new DirectoryException(ResultCode.NO_SUCH_OBJECT, |
| | | message, matchedDN, null); |
| | |
| | | if (!currentDN.equals(entry.getName()) && |
| | | dn2id.get(txn, entry.getName(), LockMode.DEFAULT) != null) |
| | | { |
| | | LocalizableMessage message = ERR_JEB_MODIFYDN_ALREADY_EXISTS.get( |
| | | entry.getName().toString()); |
| | | throw new DirectoryException(ResultCode.ENTRY_ALREADY_EXISTS, |
| | | message); |
| | | LocalizableMessage message = ERR_JEB_MODIFYDN_ALREADY_EXISTS.get(entry.getName()); |
| | | throw new DirectoryException(ResultCode.ENTRY_ALREADY_EXISTS, message); |
| | | } |
| | | |
| | | EntryID oldApexID = dn2id.get(txn, currentDN, LockMode.DEFAULT); |
| | |
| | | EntryID newSuperiorID = dn2id.get(txn, newSuperiorDN, LockMode.DEFAULT); |
| | | if (newSuperiorID == null) |
| | | { |
| | | LocalizableMessage msg = |
| | | ERR_JEB_NEW_SUPERIOR_NO_SUCH_OBJECT.get( |
| | | newSuperiorDN.toString()); |
| | | LocalizableMessage msg = ERR_JEB_NEW_SUPERIOR_NO_SUCH_OBJECT.get(newSuperiorDN); |
| | | DN matchedDN = getMatchedDN(baseDN); |
| | | throw new DirectoryException(ResultCode.NO_SUCH_OBJECT, |
| | | msg, matchedDN, null); |
| | |
| | | { |
| | | if (!dn2id.insert(txn, newEntry.getName(), newID)) |
| | | { |
| | | LocalizableMessage message = ERR_JEB_MODIFYDN_ALREADY_EXISTS.get( |
| | | newEntry.getName().toString()); |
| | | throw new DirectoryException(ResultCode.ENTRY_ALREADY_EXISTS, |
| | | message); |
| | | LocalizableMessage message = ERR_JEB_MODIFYDN_ALREADY_EXISTS.get(newEntry.getName()); |
| | | throw new DirectoryException(ResultCode.ENTRY_ALREADY_EXISTS, message); |
| | | } |
| | | id2entry.put(txn, newID, newEntry); |
| | | dn2uri.addEntry(txn, newEntry); |
| | |
| | | |
| | | if (!pluginResult.continueProcessing()) |
| | | { |
| | | LocalizableMessage message = ERR_JEB_MODIFYDN_ABORTED_BY_SUBORDINATE_PLUGIN.get( |
| | | oldDN.toString(), newDN.toString()); |
| | | throw new DirectoryException( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | ERR_JEB_MODIFYDN_ABORTED_BY_SUBORDINATE_PLUGIN.get(oldDN, newDN)); |
| | | } |
| | | |
| | | if (! modifications.isEmpty()) |
| | |
| | | invalidReason)) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_JEB_MODIFYDN_ABORTED_BY_SUBORDINATE_SCHEMA_ERROR.get( |
| | | oldDN.toString(), |
| | | newDN.toString(), |
| | | invalidReason.toString()); |
| | | ERR_JEB_MODIFYDN_ABORTED_BY_SUBORDINATE_SCHEMA_ERROR.get(oldDN, newDN, invalidReason); |
| | | throw new DirectoryException( |
| | | DirectoryServer.getServerErrorResultCode(), message); |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | final LocalizableMessage m = ERR_JEB_COMPSCHEMA_CANNOT_STORE_STATUS.get(status |
| | | .toString()); |
| | | throw new DirectoryException( |
| | | DirectoryServer.getServerErrorResultCode(), m); |
| | | final LocalizableMessage m = ERR_JEB_COMPSCHEMA_CANNOT_STORE_STATUS.get(status); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), m); |
| | | } |
| | | } |
| | | catch (final LockConflictException ce) |
| | |
| | | // another to be opened. |
| | | if (ec1 != null) |
| | | { |
| | | LocalizableMessage m = ERR_JEB_ENTRY_CONTAINER_ALREADY_REGISTERED.get( |
| | | ec1.getDatabasePrefix(), baseDN.toString()); |
| | | throw new InitializationException(m); |
| | | throw new InitializationException(ERR_JEB_ENTRY_CONTAINER_ALREADY_REGISTERED.get( |
| | | ec1.getDatabasePrefix(), baseDN)); |
| | | } |
| | | |
| | | this.entryContainers.put(baseDN, entryContainer); |
| | |
| | | @Override |
| | | public ConfigChangeResult applyConfigurationChange(LocalDBBackendCfg cfg) |
| | | { |
| | | ConfigChangeResult ccr; |
| | | boolean adminActionRequired = false; |
| | | ArrayList<LocalizableMessage> messages = new ArrayList<LocalizableMessage>(); |
| | | |
| | |
| | | { |
| | | if(!backendDirectory.mkdirs()) |
| | | { |
| | | messages.add(ERR_JEB_CREATE_FAIL.get( |
| | | backendDirectory.getPath())); |
| | | ccr = new ConfigChangeResult( |
| | | messages.add(ERR_JEB_CREATE_FAIL.get(backendDirectory.getPath())); |
| | | return new ConfigChangeResult( |
| | | DirectoryServer.getServerErrorResultCode(), |
| | | adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | } |
| | | } |
| | | //Make sure the directory is valid. |
| | | else if (!backendDirectory.isDirectory()) |
| | | { |
| | | messages.add(ERR_JEB_DIRECTORY_INVALID.get( |
| | | backendDirectory.getPath())); |
| | | ccr = new ConfigChangeResult( |
| | | messages.add(ERR_JEB_DIRECTORY_INVALID.get(backendDirectory.getPath())); |
| | | return new ConfigChangeResult( |
| | | DirectoryServer.getServerErrorResultCode(), |
| | | adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | } |
| | | |
| | | adminActionRequired = true; |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | messages.add(ERR_CONFIG_BACKEND_MODE_INVALID.get( |
| | | config.dn().toString())); |
| | | ccr = new ConfigChangeResult( |
| | | messages.add(ERR_CONFIG_BACKEND_MODE_INVALID.get(config.dn())); |
| | | return new ConfigChangeResult( |
| | | DirectoryServer.getServerErrorResultCode(), |
| | | adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | } |
| | | |
| | | //Make sure the mode will allow the server itself access to |
| | |
| | | { |
| | | messages.add(ERR_CONFIG_BACKEND_INSANE_MODE.get( |
| | | cfg.getDBDirectoryPermissions())); |
| | | ccr = new ConfigChangeResult( |
| | | return new ConfigChangeResult( |
| | | DirectoryServer.getServerErrorResultCode(), |
| | | adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | } |
| | | |
| | | // Get the backend database backendDirectory permissions and apply |
| | |
| | | catch (Exception e) |
| | | { |
| | | messages.add(LocalizableMessage.raw(stackTraceToSingleLineString(e))); |
| | | ccr = new ConfigChangeResult(DirectoryServer.getServerErrorResultCode(), |
| | | return new ConfigChangeResult(DirectoryServer.getServerErrorResultCode(), |
| | | adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | } |
| | | |
| | | |
| | | ccr = new ConfigChangeResult(ResultCode.SUCCESS, adminActionRequired, |
| | | messages); |
| | | return ccr; |
| | | return new ConfigChangeResult(ResultCode.SUCCESS, adminActionRequired, messages); |
| | | } |
| | | |
| | | /** |
| | |
| | | suffix = Suffix.createSuffixContext(entryContainer, null, null, null); |
| | | if (suffix == null) |
| | | { |
| | | LocalizableMessage msg = |
| | | ERR_JEB_REBUILD_SUFFIX_ERROR.get(rebuildConfig.getBaseDN() |
| | | .toString()); |
| | | throw new InitializationException(msg); |
| | | throw new InitializationException( |
| | | ERR_JEB_REBUILD_SUFFIX_ERROR.get(rebuildConfig.getBaseDN())); |
| | | } |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | taskRootDN.toString(), getExceptionMessage(e)); |
| | | taskRootDN, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | |
| | | if (! valueIsAcceptable(value, rejectReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue().toString(), name, rejectReason.toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue(), name, rejectReason)); |
| | | } |
| | | |
| | | |
| | |
| | | value = iterator.next(); |
| | | if (! valueIsAcceptable(value, rejectReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue().toString(), name, rejectReason.toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue(), name, rejectReason)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | if (tempValues.contains(value)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_ADD_VALUES_ALREADY_EXISTS.get( |
| | | name, value.getValue().toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_ADD_VALUES_ALREADY_EXISTS.get( |
| | | name, value.getValue())); |
| | | } |
| | | |
| | | if (! valueIsAcceptable(value, rejectReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue().toString(), name, rejectReason.toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_REJECTED_VALUE.get( |
| | | value.getValue(), name, rejectReason)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (conflictingChild != null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ENTRY_CONFLICTING_CHILD.get( |
| | | conflictingChild.getDN().toString(), entry.getName().toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ENTRY_CONFLICTING_CHILD.get( |
| | | conflictingChild.getDN(), entry.getName())); |
| | | } |
| | | } |
| | | |
| | |
| | | ConfigEntry childEntry = children.get(childDN); |
| | | if (childEntry == null) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ENTRY_NO_SUCH_CHILD.get( |
| | | childDN.toString(), entry.getName().toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ENTRY_NO_SUCH_CHILD.get( |
| | | childDN, entry.getName())); |
| | | } |
| | | |
| | | if (childEntry.hasChildren()) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ENTRY_CANNOT_REMOVE_NONLEAF.get( |
| | | childDN.toString(), entry.getName().toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ENTRY_CANNOT_REMOVE_NONLEAF.get( |
| | | childDN, entry.getName())); |
| | | } |
| | | |
| | | children.remove(childDN); |
| | |
| | | logger.traceException(e); |
| | | |
| | | rejectReason.append(ERR_CONFIG_ATTR_DN_CANNOT_PARSE.get( |
| | | value.getValue().toString(), getName(), |
| | | String.valueOf(e))); |
| | | value.getValue(), getName(), e)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_DN_CANNOT_PARSE.get( |
| | | v.getValue().toString(), getName(), String.valueOf(e)); |
| | | v.getValue(), getName(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | { |
| | | // This is illegal -- only the pending option is allowed for |
| | | // configuration attributes. |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_ATTR_OPTIONS_NOT_ALLOWED.get(a.getName()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException( |
| | | ERR_CONFIG_ATTR_OPTIONS_NOT_ALLOWED.get(a.getName())); |
| | | } |
| | | } |
| | | else |
| | |
| | | if (activeValues!= null) |
| | | { |
| | | // We cannot have multiple active value sets. |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_ATTR_MULTIPLE_ACTIVE_VALUE_SETS.get(a.getName()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException( |
| | | ERR_CONFIG_ATTR_MULTIPLE_ACTIVE_VALUE_SETS.get(a.getName())); |
| | | } |
| | | |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_DN_CANNOT_PARSE.get( |
| | | v.getValue().toString(), getName(), String.valueOf(e)); |
| | | v.getValue(), getName(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_INT_COULD_NOT_PARSE.get( |
| | | v.getValue().toString(), a.getName(), String.valueOf(e)); |
| | | v.getValue(), a.getName(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_INT_COULD_NOT_PARSE.get( |
| | | v.getValue().toString(), a.getName(), String.valueOf(e)); |
| | | v.getValue(), a.getName(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | if (! valueIsAcceptable(valueString.toLowerCase(), rejectReason)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_INVALID_VALUE_WITH_UNIT.get( |
| | | valueString, getName(), |
| | | rejectReason.toString()); |
| | | |
| | | valueString, getName(), rejectReason); |
| | | if (allowFailures) |
| | | { |
| | | logger.error(message); |
| | |
| | | |
| | | buffer.append(")"); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_JMX_NO_METHOD.get( |
| | | buffer.toString(), configEntryDN.toString()); |
| | | LocalizableMessage message = ERR_CONFIG_JMX_NO_METHOD.get(buffer, configEntryDN); |
| | | throw new MBeanException( |
| | | new DirectoryException(ResultCode.NO_SUCH_OPERATION, |
| | | message)); |
| | | new DirectoryException(ResultCode.NO_SUCH_OPERATION, message)); |
| | | } |
| | | |
| | | |
| | |
| | | if (! allowedValues.contains(lowerValue)) |
| | | { |
| | | // This is illegal -- the value is not allowed. |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_VALUE_NOT_ALLOWED.get( |
| | | v.getValue().toString(), a.getName()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_VALUE_NOT_ALLOWED.get( |
| | | v.getValue(), a.getName())); |
| | | } |
| | | |
| | | pendingValues.add(v.getValue().toString()); |
| | |
| | | if (! allowedValues.contains(lowerValue)) |
| | | { |
| | | // This is illegal -- the value is not allowed. |
| | | LocalizableMessage message = ERR_CONFIG_ATTR_VALUE_NOT_ALLOWED.get( |
| | | v.getValue().toString(), a.getName()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_CONFIG_ATTR_VALUE_NOT_ALLOWED.get( |
| | | v.getValue(), a.getName())); |
| | | } |
| | | |
| | | activeValues.add(v.getValue().toString()); |
| | |
| | | LocalizableMessage message = |
| | | ERR_CANNOT_DECODE_CONTROL_VALUE.get( |
| | | getOID() + " x=" + value.toHexString() + " v=" |
| | | + mdssValue , getExceptionMessage(e).toString()); |
| | | + mdssValue , getExceptionMessage(e)); |
| | | throw new DirectoryException(ResultCode.PROTOCOL_ERROR, message, e); |
| | | } |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_AUTHZ_CONFIG_NOT_ACCEPTABLE.get( |
| | | // Bug: where in a section where configuration is null |
| | | // WAS: String.valueOf( configuration.dn()) |
| | | // Now: |
| | | "null" |
| | | , buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException(ERR_CONFIG_AUTHZ_CONFIG_NOT_ACCEPTABLE.get( |
| | | null /* WAS: configuration.dn() */, buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_AUTHZ_UNABLE_TO_INSTANTIATE_HANDLER. |
| | | get(className, String.valueOf(configuration.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | get(className, configuration.dn(), stackTraceToSingleLineString(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_ACCTNOTHANDLER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_ACCTNOTHANDLER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_ACCTNOTHANDLER_INITIALIZATION_FAILED.get( |
| | | className, |
| | | String.valueOf(configuration.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | className, configuration.dn(), stackTraceToSingleLineString(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | /** |
| | | * Remove a notification handler that has been installed in the server. |
| | | * |
| | | * @param configEntryDN the DN of the configuration enry associated to |
| | | * @param configEntryDN the DN of the configuration entry associated to |
| | | * the notification handler to remove |
| | | */ |
| | | private void uninstallNotificationHandler( |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_ALERTHANDLER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_ALERTHANDLER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_SCHEMA_SYNTAX_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_SCHEMA_SYNTAX_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_SCHEMA_SYNTAX_CANNOT_INITIALIZE. |
| | | get(className, String.valueOf(configuration.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | get(className, configuration.dn(), stackTraceToSingleLineString(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_CERTMAPPER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_CERTMAPPER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_CERTMAPPER_INITIALIZATION_FAILED. |
| | | get(className, String.valueOf(configuration.dn()), |
| | | stackTraceToSingleLineString(e)); |
| | | get(className, configuration.dn(), stackTraceToSingleLineString(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | { |
| | | // The port was already specified: this is a configuration error, |
| | | // log a message. |
| | | LocalizableMessage message = |
| | | ERR_HOST_PORT_ALREADY_SPECIFIED.get(c.getConnectionHandlerName(), |
| | | listener.toString()); |
| | | LocalizableMessage message = ERR_HOST_PORT_ALREADY_SPECIFIED.get( |
| | | c.getConnectionHandlerName(), listener); |
| | | logger.error(message); |
| | | errorMessages.add(message); |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_ENTRYCACHE_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_ENTRYCACHE_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_EXTENSION_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_EXTENSION_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_IDMAPPER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_IDMAPPER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_KEYMANAGER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_KEYMANAGER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | messages.add(ERR_CONFIG_RETENTION_POLICY_CANNOT_CREATE_POLICY.get( |
| | | String.valueOf(config.dn().toString()), |
| | | stackTraceToSingleLineString(e))); |
| | | config.dn(),stackTraceToSingleLineString(e))); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | } |
| | | |
| | |
| | | theClass = pd.loadClass(className, RetentionPolicy.class); |
| | | theClass.newInstance(); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get(className, |
| | | config.dn().toString(), |
| | | String.valueOf(e)); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add( |
| | | ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get(className, config.dn(), e)); |
| | | return false; |
| | | } |
| | | // Check that the implementation class implements the correct interface. |
| | |
| | | theClass.getMethod("initializeLogRetentionPolicy", config |
| | | .configurationClass()); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get(className, |
| | | config.dn().toString(), |
| | | String.valueOf(e)); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add( |
| | | ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get(className, config.dn(), e)); |
| | | return false; |
| | | } |
| | | // The class is valid as far as we can tell. |
| | |
| | | // Rethrow the exceptions thrown be the invoked method. |
| | | Throwable e = ite.getTargetException(); |
| | | LocalizableMessage message = ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get( |
| | | className, config.dn().toString(), stackTraceToSingleLineString(e)); |
| | | className, config.dn(), stackTraceToSingleLineString(e)); |
| | | throw new ConfigException(message, e); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_RETENTION_POLICY_INVALID_CLASS.get( |
| | | className, config.dn().toString(), String.valueOf(e)); |
| | | className, config.dn(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | } catch (Exception e) { |
| | | logger.traceException(e); |
| | | |
| | | messages.add(ERR_CONFIG_ROTATION_POLICY_CANNOT_CREATE_POLICY.get( |
| | | String.valueOf(config.dn().toString()), |
| | | messages.add(ERR_CONFIG_ROTATION_POLICY_CANNOT_CREATE_POLICY.get(config.dn(), |
| | | stackTraceToSingleLineString(e))); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | } |
| | |
| | | theClass = pd.loadClass(className, RotationPolicy.class); |
| | | theClass.newInstance(); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get(className, |
| | | config.dn().toString(), |
| | | String.valueOf(e)); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add( |
| | | ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get(className, config.dn(), e)); |
| | | return false; |
| | | } |
| | | // Check that the implementation class implements the correct interface. |
| | |
| | | theClass.getMethod("initializeLogRotationPolicy", config |
| | | .configurationClass()); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get(className, |
| | | config.dn().toString(), |
| | | String.valueOf(e)); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add( |
| | | ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get(className, config.dn(), e)); |
| | | return false; |
| | | } |
| | | // The class is valid as far as we can tell. |
| | |
| | | // Rethrow the exceptions thrown be the invoked method. |
| | | Throwable e = ite.getTargetException(); |
| | | LocalizableMessage message = ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get( |
| | | className, config.dn().toString(), stackTraceToSingleLineString(e)); |
| | | className, config.dn(), stackTraceToSingleLineString(e)); |
| | | throw new ConfigException(message, e); |
| | | } catch (Exception e) { |
| | | LocalizableMessage message = ERR_CONFIG_ROTATION_POLICY_INVALID_CLASS.get( |
| | | className, config.dn().toString(), String.valueOf(e)); |
| | | className, config.dn(), e); |
| | | throw new ConfigException(message, e); |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_SCHEMA_MR_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_SCHEMA_MR_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_PWGENERATOR_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_PWGENERATOR_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_PWSCHEME_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_PWSCHEME_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_PWVALIDATOR_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_PWVALIDATOR_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_PLUGIN_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_PLUGIN_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_SASL_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_SASL_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_LDAP_SYNTAX.get( |
| | | schemaFile, |
| | | v.getValue().toString() + ": " + getExceptionMessage(e)); |
| | | v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_ATTR_TYPE.get( |
| | | schemaFile, v.getValue().toString() + ": " + |
| | | getExceptionMessage(e)); |
| | | schemaFile, v.getValue() + ": " + getExceptionMessage(e)); |
| | | if (failOnError) |
| | | { |
| | | throw new ConfigException(message, e); |
| | |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_OC.get( |
| | | schemaFile, |
| | | v.getValue().toString() + ": " + getExceptionMessage(e)); |
| | | v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_NAME_FORM.get( |
| | | schemaFile, v.getValue().toString() + ": " + |
| | | getExceptionMessage(e)); |
| | | schemaFile, v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_DCR.get( |
| | | schemaFile,v.getValue().toString() + ": " + |
| | | getExceptionMessage(e)); |
| | | schemaFile,v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_DSR.get( |
| | | schemaFile, v.getValue().toString() + ": " + |
| | | getExceptionMessage(e)); |
| | | schemaFile, v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | |
| | | LocalizableMessage message = WARN_CONFIG_SCHEMA_CANNOT_PARSE_MRU.get( |
| | | schemaFile, |
| | | v.getValue().toString() + ": " + |
| | | getExceptionMessage(e)); |
| | | v.getValue() + ": " + getExceptionMessage(e)); |
| | | |
| | | if (failOnError) |
| | | { |
| | |
| | | break; |
| | | } |
| | | } |
| | | LocalizableMessage message = ERR_PWPOLICY_NO_PWDPOLICY_OC.get(subentry.getDN() |
| | | .toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PWPOLICY_NO_PWDPOLICY_OC.get(subentry.getDN())); |
| | | } |
| | | else if (!objectClasses.containsKey(pwdPolicyOC)) |
| | | { |
| | | LocalizableMessage message = ERR_PWPOLICY_NO_PWDPOLICY_OC.get(subentry.getDN() |
| | | .toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PWPOLICY_NO_PWDPOLICY_OC.get(subentry.getDN())); |
| | | } |
| | | |
| | | // Subentry DN for this password policy. |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, |
| | | ERR_PWPOLICY_UNDEFINED_PASSWORD_ATTRIBUTE.get( |
| | | this.passwordPolicySubentryDN.toNormalizedString(), |
| | | value.toString())); |
| | | this.passwordPolicySubentryDN.toNormalizedString(), value)); |
| | | } |
| | | |
| | | // Check the syntax. |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_MINAGE, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_MAXAGE, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_INHISTORY, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_CHECKQUALITY, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_MINLENGTH, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | |
| | |
| | | else |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_BOOLEAN_VALUE.get(PWD_ATTR_LOCKOUT, |
| | | value.toString())); |
| | | ERR_CONFIG_ATTR_INVALID_BOOLEAN_VALUE.get(PWD_ATTR_LOCKOUT, value)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_EXPIREWARNING, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_GRACEAUTHNLIMIT, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_LOCKOUTDURATION, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get(PWD_ATTR_MAXFAILURE, |
| | | value.toString(), ne.getLocalizedMessage())); |
| | | value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_BOOLEAN_VALUE.get(PWD_ATTR_MUSTCHANGE, |
| | | value.toString())); |
| | | value)); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_BOOLEAN_VALUE.get(PWD_ATTR_ALLOWUSERCHANGE, |
| | | value.toString())); |
| | | value)); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_BOOLEAN_VALUE.get(PWD_ATTR_SAFEMODIFY, |
| | | value.toString())); |
| | | value)); |
| | | } |
| | | } |
| | | else |
| | |
| | | { |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_CONFIG_ATTR_INVALID_INT_VALUE.get( |
| | | PWD_ATTR_FAILURECOUNTINTERVAL, value.toString(), |
| | | ne.getLocalizedMessage())); |
| | | PWD_ATTR_FAILURECOUNTINTERVAL, value, ne.getLocalizedMessage())); |
| | | } |
| | | } |
| | | else |
| | |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PWPOLICY_UNKNOWN_VALIDATOR.get( |
| | | this.passwordPolicySubentryDN.toNormalizedString(), |
| | | validatorDN.toString(), PWD_ATTR_VALIDATOR)); |
| | | validatorDN, PWD_ATTR_VALIDATOR)); |
| | | } |
| | | pValidatorNames.add(validatorDN); |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_TRUSTMANAGER_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_TRUSTMANAGER_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | LocalizableMessage message = |
| | | ERR_REGISTER_WORKFLOW_BASE_DN_ALREADY_EXISTS.get( |
| | | workflowID, networkGroupID, node.getWorkflowImpl() |
| | | .getWorkflowId(), workflowNode.getWorkflowImpl() |
| | | .getBaseDN().toString()); |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, |
| | | message); |
| | | .getWorkflowId(), workflowNode.getWorkflowImpl().getBaseDN()); |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_NETWORKGROUP_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_NETWORKGROUP_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | if (ResultCode.SUCCESS != addOperation.getResultCode()) { |
| | | throw new DirectoryException( |
| | | addOperation.getResultCode(), |
| | | ERR_CRYPTOMGR_FAILED_TO_INITIATE_INSTANCE_KEY_GENERATION.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_FAILED_TO_INITIATE_INSTANCE_KEY_GENERATION.get(entry.getName())); |
| | | } |
| | | } |
| | | else { |
| | |
| | | logger.traceException(ex); |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_FAILED_TO_RETRIEVE_INSTANCE_CERTIFICATE.get( |
| | | entryDN.toString(), getExceptionMessage(ex)), ex); |
| | | entryDN, getExceptionMessage(ex)), ex); |
| | | } |
| | | //The certificate can never be null. The LocalizableMessage digest code that will |
| | | //use it later throws a NPE if the certificate is null. |
| | |
| | | if (ResultCode.SUCCESS != addOperation.getResultCode()) { |
| | | throw new DirectoryException( |
| | | addOperation.getResultCode(), |
| | | ERR_CRYPTOMGR_FAILED_TO_ADD_INSTANCE_KEY_ENTRY_TO_ADS.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_FAILED_TO_ADD_INSTANCE_KEY_ENTRY_TO_ADS.get(entry.getName())); |
| | | } |
| | | } |
| | | } catch (DirectoryException ex) { |
| | |
| | | logger.traceException(ex); |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_FAILED_TO_RETRIEVE_ADS_TRUSTSTORE_CERTS.get( |
| | | instanceKeysDN.toString(), |
| | | getExceptionMessage(ex)), ex); |
| | | instanceKeysDN, getExceptionMessage(ex)), ex); |
| | | } |
| | | return(certificateMap); |
| | | } |
| | |
| | | if (symmetricKey == null) |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_DECODE.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_DECODE.get(entry.getName())); |
| | | } |
| | | secretKey = decodeSymmetricKeyAttribute(symmetricKey); |
| | | CipherKeyEntry.importCipherKeyEntry(this, keyID, transformation, |
| | |
| | | if (internalModify.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_ADD_KEY.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_ADD_KEY.get(entry.getName())); |
| | | } |
| | | } |
| | | catch (DirectoryException ex) |
| | |
| | | logger.traceException(ex); |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_OTHER.get( |
| | | entry.getName().toString(), ex.getMessage()), ex); |
| | | entry.getName(), ex.getMessage()), ex); |
| | | } |
| | | } |
| | | |
| | |
| | | if (symmetricKey == null) |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_DECODE.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_DECODE.get(entry.getName())); |
| | | } |
| | | secretKey = decodeSymmetricKeyAttribute(symmetricKey); |
| | | MacKeyEntry.importMacKeyEntry(this, keyID, algorithm, |
| | |
| | | if (internalModify.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_ADD_KEY.get( |
| | | entry.getName().toString())); |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_TO_ADD_KEY.get(entry.getName())); |
| | | } |
| | | } |
| | | else |
| | |
| | | logger.traceException(ex); |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_IMPORT_KEY_ENTRY_FAILED_OTHER.get( |
| | | entry.getName().toString(), ex.getMessage()), ex); |
| | | entry.getName(), ex.getMessage()), ex); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_SYMMETRIC_KEY_ENTRY_ADD_FAILED.get( |
| | | entry.getName().toString(), |
| | | addOperation.getErrorMessage())); |
| | | entry.getName(), addOperation.getErrorMessage())); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | throw new CryptoManagerException( |
| | | ERR_CRYPTOMGR_SYMMETRIC_KEY_ENTRY_ADD_FAILED.get( |
| | | entry.getName().toString(), |
| | | addOperation.getErrorMessage())); |
| | | entry.getName(), addOperation.getErrorMessage())); |
| | | } |
| | | } |
| | | |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_PWSCHEME_CANNOT_BASE64_DECODE_STORED_PASSWORD.get( |
| | | storedPassword.toString(), String.valueOf(e)); |
| | | throw new DirectoryException(ResultCode.INVALID_CREDENTIALS, message, |
| | | e); |
| | | storedPassword, e); |
| | | throw new DirectoryException(ResultCode.INVALID_CREDENTIALS, message, e); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | invalidReason |
| | | .append(ERR_CHARSET_VALIDATOR_TOO_FEW_OPTIONAL_CHAR_SETS |
| | | .get(requiredOptionalCharacterSets, |
| | | builder.toString())); |
| | | invalidReason.append( |
| | | ERR_CHARSET_VALIDATOR_TOO_FEW_OPTIONAL_CHAR_SETS.get( |
| | | requiredOptionalCharacterSets, builder)); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | DN configRootDN = DN.valueOf(DN_CONFIG_ROOT); |
| | | if (! entry.getName().equals(configRootDN)) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_FILE_INVALID_BASE_DN.get( |
| | | f.getAbsolutePath(), entry.getName().toString(), |
| | | DN_CONFIG_ROOT); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException(ERR_CONFIG_FILE_INVALID_BASE_DN.get( |
| | | f.getAbsolutePath(), entry.getName(), DN_CONFIG_ROOT)); |
| | | } |
| | | } |
| | | catch (InitializationException ie) |
| | |
| | | { |
| | | close(reader); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_DUPLICATE_ENTRY.get( |
| | | entryDN.toString(), |
| | | String.valueOf(reader.getLastEntryLineNumber()), |
| | | f.getAbsolutePath()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException(ERR_CONFIG_FILE_DUPLICATE_ENTRY.get( |
| | | entryDN, reader.getLastEntryLineNumber(), f.getAbsolutePath())); |
| | | } |
| | | |
| | | |
| | |
| | | { |
| | | close(reader); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_UNKNOWN_PARENT.get( |
| | | entryDN.toString(), |
| | | reader.getLastEntryLineNumber(), |
| | | f.getAbsolutePath()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException(ERR_CONFIG_FILE_UNKNOWN_PARENT.get( |
| | | entryDN, reader.getLastEntryLineNumber(), f.getAbsolutePath())); |
| | | } |
| | | |
| | | ConfigEntry parentEntry = configEntries.get(parentDN); |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_FILE_WRITE_ERROR.get( |
| | | configEntry.getDN().toString(), String.valueOf(e)); |
| | | configEntry.getDN(), e); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | message, e); |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | throw new ConfigException(ERR_EXACTMAP_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), |
| | | b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | } |
| | | } |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | unacceptableReasons.add(ERR_EXACTMAP_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), |
| | | b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | LocalizableMessage message = WARN_SATUACM_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID()); |
| | | messages.add(message); |
| | | logger.error(message); |
| | | } |
| | |
| | | |
| | | buffer.append(")"); |
| | | |
| | | LocalizableMessage message = ERR_CONFIG_JMX_NO_METHOD.get( |
| | | buffer.toString(), String.valueOf(configEntryDN)); |
| | | LocalizableMessage message = ERR_CONFIG_JMX_NO_METHOD.get(buffer, configEntryDN); |
| | | throw new MBeanException(new ConfigException(message)); |
| | | } |
| | | |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | throw new ConfigException(ERR_REGEXMAP_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), |
| | | b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | } |
| | | } |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | unacceptableReasons.add(ERR_REGEXMAP_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), |
| | | b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (PatternSyntaxException pse) |
| | | { |
| | | LocalizableMessage message = ERR_REGEXMAP_INVALID_MATCH_PATTERN.get( |
| | | configuration.getMatchPattern(), |
| | | pse.getMessage()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_REGEXMAP_INVALID_MATCH_PATTERN.get( |
| | | configuration.getMatchPattern(), pse.getMessage())); |
| | | configAcceptable = false; |
| | | } |
| | | |
| | |
| | | import org.opends.server.config.ConfigException; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.forgerock.util.Utils; |
| | | import org.opends.server.types.AccountStatusNotification; |
| | | import org.opends.server.types.AccountStatusNotificationProperty; |
| | | import org.opends.server.types.AccountStatusNotificationType; |
| | |
| | | List<Properties> propList = DirectoryServer.getMailServerPropertySets(); |
| | | if ((propList == null) || propList.isEmpty()) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get( |
| | | configuration.dn().toString())); |
| | | throw new ConfigException(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get(configuration.dn())); |
| | | } |
| | | |
| | | // Make sure that either an explicit recipient list or a set of email |
| | |
| | | if (((mailAttrs == null) || mailAttrs.isEmpty()) && |
| | | ((recipients == null) || recipients.isEmpty())) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_NO_RECIPIENTS.get( |
| | | configuration.dn().toString())); |
| | | throw new ConfigException(ERR_SMTP_ASNH_NO_RECIPIENTS.get(configuration.dn())); |
| | | } |
| | | } |
| | | |
| | |
| | | int colonPos = s.indexOf(':'); |
| | | if (colonPos < 0) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_NO_COLON.get(s, |
| | | configuration.dn().toString())); |
| | | throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_NO_COLON.get(s, configuration.dn())); |
| | | } |
| | | |
| | | String notificationTypeName = s.substring(0, colonPos).trim(); |
| | |
| | | AccountStatusNotificationType.typeForName(notificationTypeName); |
| | | if (t == null) |
| | | { |
| | | throw new ConfigException( |
| | | ERR_SMTP_ASNH_SUBJECT_INVALID_NOTIFICATION_TYPE.get( |
| | | s, configuration.dn().toString(), |
| | | notificationTypeName)); |
| | | throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_INVALID_NOTIFICATION_TYPE.get( |
| | | s, configuration.dn(), notificationTypeName)); |
| | | } |
| | | else if (map.containsKey(t)) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_DUPLICATE_TYPE.get( |
| | | configuration.dn().toString(), |
| | | notificationTypeName)); |
| | | configuration.dn(), notificationTypeName)); |
| | | } |
| | | |
| | | map.put(t, s.substring(colonPos+1).trim()); |
| | |
| | | int colonPos = s.indexOf(':'); |
| | | if (colonPos < 0) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_NO_COLON.get(s, |
| | | configuration.dn().toString())); |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_NO_COLON.get(s, configuration.dn())); |
| | | } |
| | | |
| | | String notificationTypeName = s.substring(0, colonPos).trim(); |
| | |
| | | AccountStatusNotificationType.typeForName(notificationTypeName); |
| | | if (t == null) |
| | | { |
| | | throw new ConfigException( |
| | | ERR_SMTP_ASNH_TEMPLATE_INVALID_NOTIFICATION_TYPE.get( |
| | | s, configuration.dn().toString(), |
| | | notificationTypeName)); |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_INVALID_NOTIFICATION_TYPE.get( |
| | | s, configuration.dn(), notificationTypeName)); |
| | | } |
| | | else if (map.containsKey(t)) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_DUPLICATE_TYPE.get( |
| | | configuration.dn().toString(), |
| | | notificationTypeName)); |
| | | configuration.dn(), notificationTypeName)); |
| | | } |
| | | |
| | | String path = s.substring(colonPos+1).trim(); |
| | |
| | | if (! f.exists()) |
| | | { |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_NO_SUCH_FILE.get( |
| | | path, configuration.dn().toString())); |
| | | path, configuration.dn())); |
| | | } |
| | | |
| | | map.put(t, parseTemplateFile(f)); |
| | |
| | | logger.traceException(e); |
| | | |
| | | throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_CANNOT_PARSE.get( |
| | | f.getAbsolutePath(), |
| | | currentConfig.dn().toString(), |
| | | getExceptionMessage(e))); |
| | | f.getAbsolutePath(), currentConfig.dn(), getExceptionMessage(e))); |
| | | } |
| | | finally |
| | | { |
| | | try |
| | | { |
| | | if (reader != null) |
| | | { |
| | | reader.close(); |
| | | } |
| | | } catch (Exception e) {} |
| | | Utils.closeSilently(reader); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE.get(notificationType.getName(), |
| | | notification.getUserDN().toString(), |
| | | getExceptionMessage(e))); |
| | | logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE.get( |
| | | notificationType.getName(), notification.getUserDN(), getExceptionMessage(e))); |
| | | } |
| | | } |
| | | |
| | |
| | | List<Properties> propList = DirectoryServer.getMailServerPropertySets(); |
| | | if ((propList == null) || propList.isEmpty()) |
| | | { |
| | | unacceptableReasons.add(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get( |
| | | configuration.dn().toString())); |
| | | unacceptableReasons.add(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get(configuration.dn())); |
| | | configAcceptable = false; |
| | | } |
| | | |
| | |
| | | if (((mailAttrs == null) || mailAttrs.isEmpty()) && |
| | | ((recipients == null) || recipients.isEmpty())) |
| | | { |
| | | unacceptableReasons.add(ERR_SMTP_ASNH_NO_RECIPIENTS.get( |
| | | configuration.dn().toString())); |
| | | unacceptableReasons.add(ERR_SMTP_ASNH_NO_RECIPIENTS.get(configuration.dn())); |
| | | configAcceptable = false; |
| | | } |
| | | |
| | |
| | | buffer.append(iterator.next()); |
| | | } |
| | | } |
| | | LocalizableMessage message = ERR_SOFTREFCACHE_CANNOT_INITIALIZE.get( |
| | | buffer.toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_SOFTREFCACHE_CANNOT_INITIALIZE.get(buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | if (modifyOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage msg = ERR_STATICGROUP_ADD_MEMBER_UPDATE_FAILED.get( |
| | | String.valueOf(nestedGroupDN), |
| | | String.valueOf(groupEntryDN), |
| | | modifyOperation.getErrorMessage().toString()); |
| | | throw new DirectoryException(modifyOperation.getResultCode(), |
| | | msg); |
| | | nestedGroupDN, groupEntryDN, modifyOperation.getErrorMessage()); |
| | | throw new DirectoryException(modifyOperation.getResultCode(), msg); |
| | | } |
| | | |
| | | |
| | |
| | | if (modifyOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = ERR_STATICGROUP_ADD_MEMBER_UPDATE_FAILED. |
| | | get(String.valueOf(userDN), String.valueOf(groupEntryDN), |
| | | modifyOperation.getErrorMessage().toString()); |
| | | get(userDN, groupEntryDN, modifyOperation.getErrorMessage()); |
| | | throw new DirectoryException(modifyOperation.getResultCode(), message); |
| | | } |
| | | |
| | |
| | | if (modifyOperation.getResultCode() != ResultCode.SUCCESS) |
| | | { |
| | | LocalizableMessage message = ERR_STATICGROUP_REMOVE_MEMBER_UPDATE_FAILED. |
| | | get(String.valueOf(userDN), String.valueOf(groupEntryDN), |
| | | modifyOperation.getErrorMessage().toString()); |
| | | get(userDN, groupEntryDN, modifyOperation.getErrorMessage()); |
| | | throw new DirectoryException(modifyOperation.getResultCode(), message); |
| | | } |
| | | |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | LocalizableMessage message = WARN_SATUACM_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID()); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID()); |
| | | messages.add(message); |
| | | logger.error(message); |
| | | } |
| | |
| | | { |
| | | logger.traceException(e); |
| | | messages.add(ERR_CONFIG_LOGGER_CANNOT_CREATE_LOGGER.get( |
| | | String.valueOf(config.dn().toString()), |
| | | stackTraceToSingleLineString(e))); |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | } |
| | | } |
| | |
| | | File[] files = fileNamingPolicy.listFiles(); |
| | | if(files == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get( |
| | | fileNamingPolicy.getInitialName().toString()); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | message); |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get(fileNamingPolicy.getInitialName())); |
| | | } |
| | | |
| | | ArrayList<File> filesToDelete = new ArrayList<File>(); |
| | | |
| | | if (files.length <= numFiles) |
| | | { |
| | | return new File[0]; |
| | |
| | | // Sort files based on last modified time. |
| | | Arrays.sort(files, new FileComparator()); |
| | | |
| | | ArrayList<File> filesToDelete = new ArrayList<File>(); |
| | | for (int j = numFiles; j < files.length; j++) |
| | | { |
| | | filesToDelete.add(files[j]); |
| | | } |
| | | |
| | | return filesToDelete.toArray(new File[0]); |
| | | } |
| | | |
| | |
| | | File[] files = fileNamingPolicy.listFiles(); |
| | | if(files == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get( |
| | | fileNamingPolicy.getInitialName().toString()); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | message); |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get(fileNamingPolicy.getInitialName())); |
| | | } |
| | | |
| | | List<File> filesToDelete = new ArrayList<File>(); |
| | | |
| | | if(files.length <= 0) |
| | | { |
| | | return new File[0]; |
| | |
| | | // Sort files based on last modified time. |
| | | Arrays.sort(files, new FileComparator()); |
| | | |
| | | List<File> filesToDelete = new ArrayList<File>(); |
| | | long freedSpace = 0; |
| | | for (int j = files.length - 1; j < 1; j--) |
| | | { |
| | |
| | | break; |
| | | } |
| | | } |
| | | |
| | | return filesToDelete.toArray(new File[filesToDelete.size()]); |
| | | } |
| | | |
| | |
| | | { |
| | | if(!writeErroroccurred) |
| | | { |
| | | LocalizableMessage msg = ERR_LOGGER_ERROR_WRITING_RECORD.get( |
| | | publisherConfigDN.toString(), |
| | | stackTraceToSingleLineString(ex)); |
| | | System.err.println(msg); |
| | | System.err.println(ERR_LOGGER_ERROR_WRITING_RECORD.get( |
| | | publisherConfigDN, stackTraceToSingleLineString(ex))); |
| | | writeErroroccurred = true; |
| | | } |
| | | } |
| | |
| | | */ |
| | | public void handleCloseError(Throwable ex) |
| | | { |
| | | LocalizableMessage msg = ERR_LOGGER_ERROR_CLOSING_FILE.get( |
| | | publisherConfigDN.toString(), |
| | | stackTraceToSingleLineString(ex)); |
| | | System.err.println(msg); |
| | | System.err.println(ERR_LOGGER_ERROR_CLOSING_FILE.get( |
| | | publisherConfigDN, stackTraceToSingleLineString(ex))); |
| | | } |
| | | |
| | | /** |
| | |
| | | */ |
| | | public void handleFlushError(Throwable ex) |
| | | { |
| | | LocalizableMessage msg = ERR_LOGGER_ERROR_FLUSHING_BUFFER.get( |
| | | publisherConfigDN.toString(), |
| | | stackTraceToSingleLineString(ex)); |
| | | System.err.println(msg); |
| | | System.err.println(ERR_LOGGER_ERROR_FLUSHING_BUFFER.get( |
| | | publisherConfigDN, stackTraceToSingleLineString(ex))); |
| | | } |
| | | |
| | | /** |
| | | * Handle an exception which occured while trying to list log files |
| | | * Handle an exception which occurred while trying to list log files |
| | | * in a directory. |
| | | * @param retentionPolicy - the retention policy being enforced when |
| | | * the exception occured. |
| | | * the exception occurred. |
| | | * @param ex - the exception occurred. |
| | | */ |
| | | public void handleDeleteError(RetentionPolicy retentionPolicy, Throwable ex) |
| | | { |
| | | LocalizableMessage msg = ERR_LOGGER_ERROR_ENFORCING_RETENTION_POLICY.get( |
| | | retentionPolicy.toString(), publisherConfigDN.toString(), |
| | | retentionPolicy, publisherConfigDN, |
| | | stackTraceToSingleLineString(ex)); |
| | | System.err.println(msg); |
| | | } |
| | |
| | | File[] files = fileNamingPolicy.listFiles(); |
| | | if(files == null) |
| | | { |
| | | LocalizableMessage message = |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get( |
| | | fileNamingPolicy.getInitialName().toString()); |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | message); |
| | | ERR_LOGGER_ERROR_LISTING_FILES.get(fileNamingPolicy.getInitialName())); |
| | | } |
| | | |
| | | long totalLength = 0; |
| | |
| | | } |
| | | catch (final Exception e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), stackTraceToSingleLineString(e)); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | |
| | | messages.add(ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, messages); |
| | |
| | | } |
| | | catch (final DirectoryException e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg |
| | | .dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg.dn(), e), e); |
| | | } |
| | | catch (final IOException e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get( |
| | | logFile.toString(), cfg.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile, cfg.dn(), e), e); |
| | | |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(config.dn() |
| | | .toString(), stackTraceToSingleLineString(e)); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | |
| | | messages.add(ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, messages); |
| | |
| | | } |
| | | catch (DirectoryException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg.dn() |
| | | .toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg.dn(), e), e); |
| | | } |
| | | catch (IOException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile |
| | | .toString(), cfg.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile, cfg.dn(), e), e); |
| | | } |
| | | |
| | | initializeFilters(cfg); |
| | |
| | | } |
| | | catch(DirectoryException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(config.dn(), e), e); |
| | | } |
| | | catch(IOException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get( |
| | | logFile.toString(), config.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile, config.dn(), e), e); |
| | | } |
| | | |
| | | |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), |
| | | stackTraceToSingleLineString(e)); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | |
| | | messages.add(ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, messages); |
| | |
| | | } |
| | | catch(DirectoryException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(config.dn(), e), e); |
| | | } |
| | | catch(IOException e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get( |
| | | logFile.toString(), config.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile, config.dn(), e), e); |
| | | } |
| | | |
| | | Set<ErrorLogPublisherCfgDefn.DefaultSeverity> defSevs = |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), |
| | | stackTraceToSingleLineString(e)); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | messages.add(ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, messages); |
| | |
| | | } |
| | | catch (final Exception e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn().toString(), stackTraceToSingleLineString(e)); |
| | | resultCode = DirectoryServer.getServerErrorResultCode(); |
| | | messages.add(message); |
| | | messages.add(ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get( |
| | | config.dn(), stackTraceToSingleLineString(e))); |
| | | } |
| | | |
| | | return new ConfigChangeResult(resultCode, adminActionRequired, messages); |
| | |
| | | subtract(fields, ALL_SUPPORTED_FIELDS); |
| | | if (!unsupportedFields.isEmpty()) |
| | | { // there are some unsupported fields. List them. |
| | | return WARN_CONFIG_LOGGING_UNSUPPORTED_FIELDS_IN_LOG_FORMAT.get(cfg.dn() |
| | | .toString(), collectionToString(unsupportedFields, ", ")); |
| | | return WARN_CONFIG_LOGGING_UNSUPPORTED_FIELDS_IN_LOG_FORMAT.get( |
| | | cfg.dn(), collectionToString(unsupportedFields, ", ")); |
| | | } |
| | | if (fields.size() == unsupportedFields.size()) |
| | | { // all fields are unsupported |
| | |
| | | } |
| | | catch (final DirectoryException e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg |
| | | .dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_CREATE_WRITER.get(cfg.dn(), e), e); |
| | | } |
| | | catch (final IOException e) |
| | | { |
| | | final LocalizableMessage message = ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get( |
| | | logFile.toString(), cfg.dn().toString(), String.valueOf(e)); |
| | | throw new InitializationException(message, e); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_LOGGING_CANNOT_OPEN_FILE.get(logFile, cfg.dn(), e), e); |
| | | } |
| | | |
| | | this.cfg = cfg; |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_CHANGE_NUMBER_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_CHANGE_NUMBER_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_ENTRYUUID_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_ENTRYUUID_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_LASTMOD_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_LASTMOD_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_PWPIMPORT_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_PWPIMPORT_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | |
| | | default: |
| | | isAcceptable = false; |
| | | unacceptableReasons.add(ERR_PLUGIN_REFERENT_INVALID_PLUGIN_TYPE.get( |
| | | t.toString())); |
| | | unacceptableReasons.add(ERR_PLUGIN_REFERENT_INVALID_PLUGIN_TYPE.get(t)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | isAcceptable = false; |
| | | unacceptableReasons.add(ERR_PLUGIN_REFERENT_ATTR_UNINDEXED.get( |
| | | pluginCfg.dn().toString(), |
| | | type.getNameOrOID(), |
| | | b.getBackendID())); |
| | | pluginCfg.dn(), type.getNameOrOID(), b.getBackendID())); |
| | | } |
| | | } |
| | | } |
| | |
| | | return PluginResult.PreOperation.stopProcessing( |
| | | ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PLUGIN_REFERENT_NAMINGCONTEXT_MISMATCH.get( |
| | | valueEntryDN.toString(), |
| | | attr.getName(), |
| | | entryDN.toString() |
| | | ) |
| | | valueEntryDN, attr.getName(), entryDN) |
| | | ); |
| | | } |
| | | |
| | |
| | | return PluginResult.PreOperation.stopProcessing( |
| | | ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PLUGIN_REFERENT_ENTRY_MISSING.get( |
| | | valueEntryDN.toString(), |
| | | attr.getName(), |
| | | entryDN.toString() |
| | | )); |
| | | valueEntryDN, attr.getName(), entryDN)); |
| | | } |
| | | |
| | | /* Verify that the value entry conforms to the filter. |
| | |
| | | return PluginResult.PreOperation.stopProcessing( |
| | | ResultCode.CONSTRAINT_VIOLATION, |
| | | ERR_PLUGIN_REFERENT_FILTER_MISMATCH.get( |
| | | valueEntry.getName().toString(), |
| | | attr.getName(), |
| | | entryDN.toString(), |
| | | filter.toString()) |
| | | ); |
| | | valueEntry.getName(), attr.getName(), entryDN, filter)); |
| | | } |
| | | } |
| | | } |
| | |
| | | |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_7BIT_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_7BIT_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | throw new ConfigException(ERR_PLUGIN_UNIQUEATTR_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), |
| | | b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | } |
| | | } |
| | | } |
| | |
| | | uniqueAttrValue2Dn.remove(v2); |
| | | } |
| | | LocalizableMessage msg = ERR_PLUGIN_UNIQUEATTR_ATTR_NOT_UNIQUE.get( |
| | | t.getNameOrOID(), v.getValue().toString(), |
| | | conflictDN.toString()); |
| | | t.getNameOrOID(), v.getValue(), conflictDN); |
| | | return PluginResult.PreOperation.stopProcessing( |
| | | ResultCode.CONSTRAINT_VIOLATION, msg); |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | |
| | | LocalizableMessage message = |
| | | ERR_PLUGIN_UNIQUEATTR_INTERNAL_ERROR.get( |
| | | de.getResultCode().toString(), |
| | | de.getMessageObject()); |
| | | LocalizableMessage message = ERR_PLUGIN_UNIQUEATTR_INTERNAL_ERROR.get( |
| | | de.getResultCode(), de.getMessageObject()); |
| | | |
| | | // Try some cleanup before returning, to avoid memory leaks |
| | | for (AttributeValue v2 : recordedValues) |
| | |
| | | t.getNameOrOID(), |
| | | operation.getConnectionID(), |
| | | operation.getOperationID(), |
| | | v.getValue().toString(), |
| | | updatedEntryDN.toString(), |
| | | conflictDN.toString()); |
| | | v.getValue(), |
| | | updatedEntryDN, |
| | | conflictDN); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_UNIQUE_ATTR_SYNC_CONFLICT, |
| | | message); |
| | |
| | | LocalizableMessage message = ERR_PLUGIN_UNIQUEATTR_INTERNAL_ERROR_SYNC.get( |
| | | operation.getConnectionID(), |
| | | operation.getOperationID(), |
| | | updatedEntryDN.toString(), |
| | | de.getResultCode().toString(), |
| | | updatedEntryDN, |
| | | de.getResultCode(), |
| | | de.getMessageObject()); |
| | | DirectoryServer.sendAlertNotification(this, |
| | | ALERT_TYPE_UNIQUE_ATTR_SYNC_ERROR, message); |
| | |
| | | break; |
| | | |
| | | default: |
| | | LocalizableMessage message = ERR_PLUGIN_UNIQUEATTR_INVALID_PLUGIN_TYPE.get( |
| | | pluginType.toString()); |
| | | unacceptableReasons.add(message); |
| | | unacceptableReasons.add(ERR_PLUGIN_UNIQUEATTR_INVALID_PLUGIN_TYPE.get(pluginType)); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | if ((b != null) && (! b.isIndexed(t, IndexType.EQUALITY))) |
| | | { |
| | | unacceptableReasons.add(ERR_PLUGIN_UNIQUEATTR_ATTR_UNINDEXED.get( |
| | | configuration.dn().toString(), |
| | | t.getNameOrOID(), b.getBackendID())); |
| | | configuration.dn(), t.getNameOrOID(), b.getBackendID())); |
| | | configAcceptable = false; |
| | | } |
| | | } |
| | |
| | | // 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().toString())); |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_NOT_DIRECTORY.get( |
| | | 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().toString())); |
| | | logger.warn(WARN_LDIF_CONNHANDLER_LDIF_DIRECTORY_MISSING.get( |
| | | ldifDirectory.getAbsolutePath(), configuration.dn())); |
| | | } |
| | | |
| | | this.currentConfig = configuration; |
| | |
| | | |
| | | LocalizableMessage m = INFO_LDIF_CONNHANDLER_RESULT_CODE.get( |
| | | operation.getResultCode().getIntValue(), |
| | | operation.getResultCode().toString()); |
| | | operation.getResultCode()); |
| | | writer.writeComment(m, 78); |
| | | |
| | | LocalizableMessageBuilder errorMessage = operation.getErrorMessage(); |
| | |
| | | break; |
| | | |
| | | default: |
| | | LocalizableMessage message = |
| | | ERR_PLUGIN_FRACTIONAL_LDIF_IMPORT_INVALID_PLUGIN_TYPE.get( |
| | | t.toString()); |
| | | throw new ConfigException(message); |
| | | throw new ConfigException(ERR_PLUGIN_FRACTIONAL_LDIF_IMPORT_INVALID_PLUGIN_TYPE.get(t)); |
| | | } |
| | | } |
| | | } |
| | |
| | | getStaticReplicationDomainFractionalConfig(entry); |
| | | } catch (Exception ex) |
| | | { |
| | | LocalizableMessage message = ERR_FRACTIONAL_COULD_NOT_RETRIEVE_CONFIG.get( |
| | | entry.toString()); |
| | | return PluginResult.ImportLDIF.stopEntryProcessing(message); |
| | | return PluginResult.ImportLDIF.stopEntryProcessing( |
| | | ERR_FRACTIONAL_COULD_NOT_RETRIEVE_CONFIG.get(entry)); |
| | | } |
| | | } else |
| | | { |
| | |
| | | // 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().toString(), |
| | | fractionalConfig.getBaseDn(), |
| | | stackTraceToSingleLineString(e))); |
| | | return false; |
| | | } |
| | |
| | | // from valid configuration in local variables so both should have already |
| | | // been checked |
| | | logger.error(NOTE_ERR_FRACTIONAL.get( |
| | | fractionalConfig.getBaseDn().toString(), |
| | | fractionalConfig.getBaseDn(), |
| | | stackTraceToSingleLineString(e))); |
| | | return false; |
| | | } |
| | |
| | | if (fractionalFilterOperation(addOperation, false)) |
| | | { |
| | | LocalizableMessage msg = NOTE_ERR_FRACTIONAL_FORBIDDEN_OPERATION.get( |
| | | getBaseDNString(), addOperation.toString()); |
| | | getBaseDNString(), addOperation); |
| | | return new SynchronizationProviderResult.StopProcessing( |
| | | ResultCode.UNWILLING_TO_PERFORM, msg); |
| | | } |
| | |
| | | if (fractionalFilterOperation(modifyDNOperation, false)) |
| | | { |
| | | LocalizableMessage msg = NOTE_ERR_FRACTIONAL_FORBIDDEN_OPERATION.get( |
| | | getBaseDNString(), modifyDNOperation.toString()); |
| | | getBaseDNString(), modifyDNOperation); |
| | | return new SynchronizationProviderResult.StopProcessing( |
| | | ResultCode.UNWILLING_TO_PERFORM, msg); |
| | | } |
| | |
| | | // Some attributes not compliant with fractional configuration : |
| | | // forbid the operation |
| | | LocalizableMessage msg = NOTE_ERR_FRACTIONAL_FORBIDDEN_OPERATION.get( |
| | | getBaseDNString(), modifyOperation.toString()); |
| | | getBaseDNString(), modifyOperation); |
| | | return new SynchronizationProviderResult.StopProcessing( |
| | | ResultCode.UNWILLING_TO_PERFORM, msg); |
| | | } |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | op.toString(), curCSN.toString())); |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get(op, curCSN)); |
| | | return; |
| | | } |
| | | } |
| | |
| | | } |
| | | catch (NoSuchElementException e) |
| | | { |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get( |
| | | op.toString(), curCSN.toString())); |
| | | logger.error(ERR_OPERATION_NOT_FOUND_IN_PENDING.get(op, curCSN)); |
| | | return; |
| | | } |
| | | // If assured replication is enabled, this will wait for the matching |
| | |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | Long.toString(getAssuredTimeout()), msg.toString())); |
| | | Long.toString(getAssuredTimeout()), msg)); |
| | | } |
| | | } |
| | | |
| | |
| | | ResultCode res = newOp.getResultCode(); |
| | | if (res != ResultCode.SUCCESS) |
| | | { |
| | | logger.error(ERR_COULD_NOT_SOLVE_CONFLICT.get( |
| | | entryDN.toString(), res.toString())); |
| | | logger.error(ERR_COULD_NOT_SOLVE_CONFLICT.get(entryDN, res)); |
| | | } |
| | | } |
| | | } |
| | |
| | | */ |
| | | LocalizableMessage message = |
| | | ERR_EXCEPTION_REPLAYING_OPERATION.get( |
| | | stackTraceToSingleLineString(e), op.toString()); |
| | | stackTraceToSingleLineString(e), op); |
| | | replayErrorMsg = message.toString(); |
| | | updateError(csn); |
| | | } else |
| | |
| | | // 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.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | 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.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | 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.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | 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.toString(), ctx.getCSN().toString(), |
| | | result.toString(), op.getErrorMessage().toString())); |
| | | op, ctx.getCSN(), result, op.getErrorMessage())); |
| | | return true; |
| | | } |
| | | } |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | LocalizableMessage msg = ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | Integer.toString(serverId), status.toString(), event.toString()); |
| | | logger.error(msg); |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS.get(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. |
| | |
| | | ServerStatus newStatus = StatusMachine.computeNewStatus(status, event); |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | LocalizableMessage msg = ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | Integer.toString(serverId), status.toString(), event.toString()); |
| | | logger.error(msg); |
| | | logger.error(ERR_RS_CANNOT_CHANGE_STATUS.get(getBaseDN(), serverId, status, event)); |
| | | return ServerStatus.INVALID_STATUS; |
| | | } |
| | | |
| | | status = newStatus; |
| | | |
| | | return status; |
| | | } |
| | | |
| | |
| | | // Sanity check: is it a valid initial status? |
| | | if (!isValidInitialStatus(this.status)) |
| | | { |
| | | LocalizableMessage message = ERR_RS_INVALID_INIT_STATUS.get( |
| | | this.status.toString(), |
| | | getBaseDNString(), |
| | | Integer.toString(serverId)); |
| | | throw new DirectoryException(ResultCode.OTHER, message); |
| | | throw new DirectoryException(ResultCode.OTHER, |
| | | ERR_RS_INVALID_INIT_STATUS.get( this.status, getBaseDN(), serverId)); |
| | | } |
| | | |
| | | this.refUrls = startSessionMsg.getReferralsURLs(); |
| | |
| | | } |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, |
| | | ERR_RESYNC_REQUIRED_UNKNOWN_DOMAIN_IN_PROVIDED_COOKIE.get( |
| | | startStatesFromProvidedCookie.toString(), sb.toString())); |
| | | startStatesFromProvidedCookie, sb)); |
| | | } |
| | | |
| | | return results; |
| | |
| | | // Adding 2 msgs with the same CSN is ok only when |
| | | // the 2 msgs are the same |
| | | bytesCount += (update.size() - msgSameCSN.size()); |
| | | LocalizableMessage errMsg = ERR_RSQUEUE_DIFFERENT_MSGS_WITH_SAME_CN.get( |
| | | msgSameCSN.getCSN().toString(), |
| | | msgSameCSN.toString(), update.toString()); |
| | | logger.error(errMsg); |
| | | logger.error(ERR_RSQUEUE_DIFFERENT_MSGS_WITH_SAME_CN.get( |
| | | msgSameCSN.getCSN(), msgSameCSN, update)); |
| | | } |
| | | } |
| | | catch(Exception e) |
| | |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_BACKEND_CANNOT_REGISTER_BASEDN.get( |
| | | dn.toString(), getExceptionMessage(e)); |
| | | dn, getExceptionMessage(e)); |
| | | throw new InitializationException(message, e); |
| | | } |
| | | } |
| | |
| | | } else |
| | | { |
| | | // Unknown assured mode: should never happen |
| | | LocalizableMessage errorMsg = ERR_RS_UNKNOWN_ASSURED_MODE.get( |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | assuredMode.toString(), baseDN.toNormalizedString(), |
| | | update.toString()); |
| | | logger.error(errorMsg); |
| | | logger.error(ERR_RS_UNKNOWN_ASSURED_MODE.get( |
| | | localReplicationServer.getServerId(), assuredMode, baseDN, update)); |
| | | assuredMessage = false; |
| | | } |
| | | } else |
| | |
| | | if (safeDataLevel < (byte) 1) |
| | | { |
| | | // Should never happen |
| | | LocalizableMessage errorMsg = ERR_UNKNOWN_ASSURED_SAFE_DATA_LEVEL.get( |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | Byte.toString(safeDataLevel), baseDN.toNormalizedString(), |
| | | update.toString()); |
| | | logger.error(errorMsg); |
| | | logger.error(ERR_UNKNOWN_ASSURED_SAFE_DATA_LEVEL.get( |
| | | localReplicationServer.getServerId(), Byte.toString(safeDataLevel), baseDN, update)); |
| | | } else if (sourceGroupId == groupId |
| | | // Assured feature does not cross different group IDS |
| | | && isSameGenerationId(sourceHandler.getGenerationId())) |
| | |
| | | mb.append(ERR_RS_ERROR_SENDING_ACK.get( |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | Integer.toString(origServer.getServerId()), |
| | | csn.toString(), baseDN.toNormalizedString())); |
| | | csn, baseDN.toNormalizedString())); |
| | | mb.append(" "); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logger.error(mb.toMessage()); |
| | |
| | | mb.append(ERR_RS_ERROR_SENDING_ACK.get( |
| | | Integer.toString(localReplicationServer.getServerId()), |
| | | Integer.toString(origServer.getServerId()), |
| | | csn.toString(), baseDN.toNormalizedString())); |
| | | csn, baseDN.toNormalizedString())); |
| | | mb.append(" "); |
| | | mb.append(stackTraceToSingleLineString(e)); |
| | | logger.error(mb.toMessage()); |
| | |
| | | long referenceGenerationId = handler.getReferenceGenId(); |
| | | if (dsStatus == BAD_GEN_ID_STATUS) |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | | if (dsStatus == FULL_UPDATE_STATUS) |
| | | logger.warn(WARN_IGNORING_UPDATE_FROM_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | | filtered = true; |
| | | } |
| | |
| | | logger.error( |
| | | WARN_IGNORING_UPDATE_FROM_RS.get( |
| | | handler.getReplicationServerId(), |
| | | updateMsg.getCSN().toString(), |
| | | handler.getBaseDNString(), |
| | | handler.getServerId(), |
| | | updateMsg.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | |
| | | } |
| | | catch(Exception e) |
| | | { |
| | | errMessage = |
| | | ERR_RECEIVED_CHANGE_STATUS_NOT_FROM_DS.get( |
| | | handler.getBaseDNString(), |
| | | Integer.toString(handler.getServerId()), |
| | | csMsg.toString()); |
| | | errMessage = ERR_RECEIVED_CHANGE_STATUS_NOT_FROM_DS.get( |
| | | handler.getBaseDN(), handler.getServerId(), csMsg); |
| | | logger.error(errMessage); |
| | | } |
| | | } else if (msg instanceof ChangeTimeHeartbeatMsg) |
| | |
| | | * The remote server has sent an unknown message, |
| | | * close the connection. |
| | | */ |
| | | errMessage = NOTE_READER_EXCEPTION.get( |
| | | handler.toString(), stackTraceToSingleLineString(e)); |
| | | errMessage = NOTE_READER_EXCEPTION.get(handler, stackTraceToSingleLineString(e)); |
| | | logger.error(errMessage); |
| | | } |
| | | finally |
| | |
| | | if (dsStatus == ServerStatus.BAD_GEN_ID_STATUS) |
| | | { |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_BADGENID.get(handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | |
| | | else if (dsStatus == ServerStatus.FULL_UPDATE_STATUS) |
| | | { |
| | | logger.warn(WARN_IGNORING_UPDATE_TO_DS_FULLUP.get(handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | | handler.getBaseDNString(), handler.getServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress())); |
| | | } |
| | | continue; |
| | |
| | | || referenceGenerationId == -1 |
| | | || handler.getGenerationId() == -1) |
| | | { |
| | | logger.error( |
| | | WARN_IGNORING_UPDATE_TO_RS.get( |
| | | logger.error(WARN_IGNORING_UPDATE_TO_RS.get( |
| | | handler.getReplicationServerId(), |
| | | update.getCSN().toString(), |
| | | handler.getBaseDNString(), |
| | | handler.getServerId(), |
| | | update.getCSN(), handler.getBaseDN(), handler.getServerId(), |
| | | session.getReadableRemoteAddress(), |
| | | handler.getGenerationId(), |
| | | referenceGenerationId)); |
| | |
| | | serverId, previousRsServerID, rs.replicationServer, |
| | | bestRsServerId, |
| | | baseDN.toNormalizedString(), |
| | | evals.getEvaluation(previousRsServerID).toString(), |
| | | evals.getEvaluation(bestRsServerId).toString()); |
| | | evals.getEvaluation(previousRsServerID), |
| | | evals.getEvaluation(bestRsServerId)); |
| | | } |
| | | logger.error(message); |
| | | if (logger.isTraceEnabled()) |
| | |
| | | requested servers. Log problem |
| | | */ |
| | | logger.error(NOTE_DS_RECEIVED_ACK_ERROR.get( |
| | | getBaseDNString(), Integer.toString(getServerId()), |
| | | update.toString(), ack.errorsToString())); |
| | | getBaseDN(), getServerId(), update, ack.errorsToString())); |
| | | |
| | | List<Integer> failedServers = ack.getFailedServers(); |
| | | |
| | |
| | | throw new DirectoryException( |
| | | ResultCode.OTHER, |
| | | ERR_INIT_NO_SUCCESS_START_FROM_SERVERS.get( |
| | | ieCtx.failureList.toString())); |
| | | ieCtx.failureList)); |
| | | } |
| | | |
| | | exportBackend(new BufferedOutputStream(new ReplOutputStream(this))); |
| | |
| | | exportRootException = new DirectoryException(ResultCode.OTHER, |
| | | ERR_INIT_NO_SUCCESS_END_FROM_SERVERS.get( |
| | | Long.toString(getGenerationID()), |
| | | ieCtx.failureList.toString())); |
| | | ieCtx.failureList)); |
| | | } |
| | | |
| | | // Don't forget to release IEcontext acquired at beginning. |
| | |
| | | if (newStatus == ServerStatus.INVALID_STATUS) |
| | | { |
| | | logger.error(ERR_DS_CANNOT_CHANGE_STATUS.get(getBaseDNString(), |
| | | String.valueOf(getServerId()), status.toString(), event.toString())); |
| | | String.valueOf(getServerId()), status, event)); |
| | | return; |
| | | } |
| | | |
| | |
| | | else if (getAssuredMode() != AssuredMode.SAFE_DATA_MODE) |
| | | { |
| | | logger.error(ERR_DS_UNKNOWN_ASSURED_MODE.get(String.valueOf(getServerId()), |
| | | msg.getAssuredMode().toString(), getBaseDNString(), |
| | | msg.toString())); |
| | | msg.getAssuredMode(), getBaseDNString(), |
| | | msg)); |
| | | } |
| | | // Nothing to do in Assured safe data mode, only RS ack updates. |
| | | } |
| | |
| | | { |
| | | // This exception may only be raised if assured replication is enabled |
| | | logger.error(NOTE_DS_ACK_TIMEOUT.get(getBaseDNString(), |
| | | Long.toString(getAssuredTimeout()), update.toString())); |
| | | Long.toString(getAssuredTimeout()), update)); |
| | | } |
| | | } |
| | | |
| | |
| | | else if(!((ch>='0' && ch<='9') || (ch>='A' && ch<='Z') || |
| | | (ch>='a' && ch<='z'))) |
| | | { |
| | | LocalizableMessage msg = ERR_ATTR_SYNTAX_ATTR_ILLEGAL_CHAR.get( |
| | | value.toString(), ch, index); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_ATTR_SYNTAX_ATTR_ILLEGAL_CHAR.get(value, ch, index)); |
| | | } |
| | | break; |
| | | } |
| | |
| | | int length = valueString.length(); |
| | | if (length < 3) |
| | | { |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_BIT_STRING_TOO_SHORT.get( |
| | | value.toString()); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logger.error(message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | | return ByteString.valueOf(valueString); |
| | | return reportInvalidSyntax(valueString, |
| | | WARN_ATTR_SYNTAX_BIT_STRING_TOO_SHORT.get(value)); |
| | | } |
| | | } |
| | | |
| | | |
| | | if ((valueString.charAt(0) != '\'') || |
| | | (valueString.charAt(length-2) != '\'') || |
| | | (valueString.charAt(length-1) != 'B')) |
| | | { |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_BIT_STRING_NOT_QUOTED.get( |
| | | value.toString()); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logger.error( |
| | | message); |
| | | return ByteString.valueOf(valueString); |
| | | default: |
| | | return ByteString.valueOf(valueString); |
| | | return reportInvalidSyntax(valueString, |
| | | WARN_ATTR_SYNTAX_BIT_STRING_NOT_QUOTED.get(value)); |
| | | } |
| | | } |
| | | |
| | | |
| | | for (int i=1; i < (length-2); i++) |
| | | { |
| | |
| | | break; |
| | | default: |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_BIT_STRING_INVALID_BIT.get( |
| | | value.toString(), String.valueOf(valueString.charAt(i))); |
| | | return reportInvalidSyntax(valueString, |
| | | WARN_ATTR_SYNTAX_BIT_STRING_INVALID_BIT.get(value, valueString.charAt(i))); |
| | | } |
| | | } |
| | | |
| | | return ByteString.valueOf(valueString); |
| | | } |
| | | |
| | | private ByteString reportInvalidSyntax(String valueString, LocalizableMessage message) |
| | | throws DirectoryException |
| | | { |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logger.error(message); |
| | | return ByteString.valueOf(valueString); |
| | |
| | | } |
| | | } |
| | | |
| | | return ByteString.valueOf(valueString); |
| | | } |
| | | } |
| | | |
| | |
| | | break; |
| | | default: |
| | | invalidReason.append(WARN_ATTR_SYNTAX_BIT_STRING_INVALID_BIT.get( |
| | | value.toString(), String.valueOf(valueString.charAt(i)))); |
| | | value, valueString.charAt(i))); |
| | | return false; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | |
| | | if (! returnValue) |
| | | { |
| | | invalidReason.append(WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get( |
| | | value.toString())); |
| | | invalidReason.append(WARN_ATTR_SYNTAX_ILLEGAL_BOOLEAN.get(value)); |
| | | } |
| | | |
| | | return returnValue; |
| | |
| | | */ |
| | | public static AttributeValue createBooleanValue(boolean b) |
| | | { |
| | | if (b) |
| | | { |
| | | return AttributeValues.create(ServerConstants.TRUE_VALUE, |
| | | ServerConstants.TRUE_VALUE); |
| | | } |
| | | else |
| | | { |
| | | return AttributeValues.create(ServerConstants.FALSE_VALUE, |
| | | ServerConstants.FALSE_VALUE); |
| | | } |
| | | ByteString value = b |
| | | ? ServerConstants.TRUE_VALUE |
| | | : ServerConstants.FALSE_VALUE; |
| | | return AttributeValues.create(value, value); |
| | | } |
| | | |
| | | |
| | |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | value.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(value, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is not a valid character for an IA5 string. If strict syntax |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | value.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(value, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is not a valid character for an IA5 string. If strict syntax |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | substring.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(substring, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | value.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(value, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is not a valid character for an IA5 string. If strict syntax |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | value.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(value, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is not a valid character for an IA5 string. If strict syntax |
| | | // enforcement is enabled, then we'll throw an exception. Otherwise, |
| | | // we'll get rid of the character. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | substring.toString(), String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(substring, c); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_AUXILIARY_CLASS.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_AUXILIARY_CLASS.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | else if (oc.getObjectClassType() != ObjectClassType.AUXILIARY) |
| | |
| | | // requires an attribute type that we don't know anything about. |
| | | if (allowUnknownElements) |
| | | { |
| | | attr = DirectoryServer.getDefaultAttributeType( |
| | | woidBuffer.toString()); |
| | | attr = DirectoryServer.getDefaultAttributeType(woidBuffer.toString()); |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_REQUIRED_ATTR.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_OPTIONAL_ATTR.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DCR_UNKNOWN_PROHIBITED_ATTR.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DCR_UNKNOWN_PROHIBITED_ATTR.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | nameForm = schema.getNameForm(woidBuffer.toString()); |
| | | if ((nameForm == null) && (! allowUnknownElements)) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DSR_UNKNOWN_NAME_FORM.get( |
| | | valueStr, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DSR_UNKNOWN_NAME_FORM.get(valueStr, woidBuffer)); |
| | | } |
| | | } |
| | | else if (lowerTokenName.equals("sup")) |
| | |
| | | StringTokenizer tokenizer = new StringTokenizer(stringValue, " $"); |
| | | if (! tokenizer.hasMoreTokens()) |
| | | { |
| | | invalidReason.append(ERR_ATTR_SYNTAX_DELIVERY_METHOD_NO_ELEMENTS.get( |
| | | value.toString())); |
| | | invalidReason.append(ERR_ATTR_SYNTAX_DELIVERY_METHOD_NO_ELEMENTS.get(value)); |
| | | return false; |
| | | } |
| | | |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | import static org.opends.server.util.StaticUtils.*; |
| | |
| | | import java.util.Collection; |
| | | import java.util.Collections; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | |
| | | import org.opends.server.types.DirectoryException; |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | |
| | | |
| | | /** |
| | | * This class defines the distinguishedNameMatch matching rule defined in X.520 |
| | | * and referenced in RFC 2252. |
| | |
| | | if (DirectoryServer.getSyntaxEnforcementPolicy() == |
| | | AcceptRejectWarn.REJECT) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID.get( |
| | | value.toString(), String.valueOf(e)); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID.get(value, e)); |
| | | } |
| | | else |
| | | { |
| | |
| | | * Portions Copyright 2012-2014 ForgeRock AS |
| | | */ |
| | | package org.opends.server.schema; |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | |
| | | |
| | | |
| | | import org.opends.server.admin.std.server.AttributeSyntaxCfg; |
| | | import org.opends.server.api.ApproximateMatchingRule; |
| | | import org.opends.server.api.AttributeSyntax; |
| | |
| | | import org.opends.server.core.DirectoryServer; |
| | | import org.forgerock.opendj.ldap.ByteSequence; |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | | |
| | | |
| | | /** |
| | | * This class implements the IA5 string attribute syntax, which is simply a |
| | | * set of ASCII characters. By default, they will be treated in a |
| | |
| | | b = value.byteAt(i); |
| | | if ((b & 0x7F) != b) |
| | | { |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get( |
| | | value.toString(), String.valueOf(b)); |
| | | invalidReason.append(message); |
| | | invalidReason.append(WARN_ATTR_SYNTAX_IA5_ILLEGAL_CHARACTER.get(value, b)); |
| | | return false; |
| | | } |
| | | } |
| | | |
| | | return true; |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is OK as long as the first character isn't a dash. |
| | | if (buffer.charAt(0) == '-') |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_MISPLACED_DASH.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_MISPLACED_DASH.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | break; |
| | | default: |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INVALID_CHARACTER.get( |
| | | value.toString(), |
| | | ((char) value.byteAt(i)), i); |
| | | value, ((char) value.byteAt(i)), i); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | |
| | | if (buffer.length() == 0) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_EMPTY_VALUE.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_EMPTY_VALUE.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | } |
| | | else if ((buffer.length() == 1) && (buffer.charAt(0) == '-')) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE.get(value); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | } |
| | | else |
| | | { |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | // This is OK as long as the first character isn't a dash. |
| | | if (buffer.charAt(0) == '-') |
| | | { |
| | | |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INITIAL_ZERO.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_MISPLACED_DASH.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_MISPLACED_DASH.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | break; |
| | | default: |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_INVALID_CHARACTER.get( |
| | | value.toString(), |
| | | ((char) value.byteAt(i)), i); |
| | | value, ((char) value.byteAt(i)), i); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | |
| | | if (buffer.length() == 0) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_EMPTY_VALUE.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_EMPTY_VALUE.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logger.error( |
| | | message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | buffer.append("0"); |
| | |
| | | } |
| | | else if ((buffer.length() == 1) && (buffer.charAt(0) == '-')) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE.get( |
| | | value.toString()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_INTEGER_DASH_NEEDS_VALUE.get(value); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | if (! logged) |
| | | { |
| | | logged = true; |
| | | logger.error( |
| | | message); |
| | | logger.error(message); |
| | | } |
| | | |
| | | buffer.setCharAt(0, '0'); |
| | |
| | | ByteString entry = ByteString.valueOf(v); |
| | | if (entries.contains(entry)) |
| | | { |
| | | LocalizableMessage message = |
| | | WARN_ATTR_SYNTAX_LDAPSYNTAX_ENUM_DUPLICATE_VALUE.get( |
| | | valueStr, entry.toString(),pos); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | WARN_ATTR_SYNTAX_LDAPSYNTAX_ENUM_DUPLICATE_VALUE.get( |
| | | valueStr, entry,pos)); |
| | | } |
| | | entries.add(entry); |
| | | } |
| | |
| | | { |
| | | //The value is acceptable if it belongs to the set. |
| | | boolean isAllowed = entries.contains(value); |
| | | |
| | | if(!isAllowed) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_LDAPSYNTAX_ENUM_INVALID_VALUE.get( |
| | | value.toString(),oid); |
| | | invalidReason.append(message); |
| | | invalidReason.append(WARN_ATTR_SYNTAX_LDAPSYNTAX_ENUM_INVALID_VALUE.get(value,oid)); |
| | | } |
| | | |
| | | return isAllowed; |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR.get( |
| | | oid, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR.get(oid, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR.get( |
| | | oid, woidBuffer.toString()); |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, |
| | | message); |
| | | ERR_ATTR_SYNTAX_MRUSE_UNKNOWN_ATTR.get(oid, woidBuffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | // This is an illegal character. Either log it or reject it. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_NUMERIC_STRING_ILLEGAL_CHAR.get( |
| | | value.toString(), String.valueOf(c), pos); |
| | | value, c, pos); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | { |
| | | // This is an illegal character. Either log it or reject it. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_NUMERIC_STRING_ILLEGAL_CHAR.get( |
| | | value.toString(), String.valueOf(c), pos); |
| | | value, c, pos); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | { |
| | | // This is an illegal character. Either log it or reject it. |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_NUMERIC_STRING_ILLEGAL_CHAR.get( |
| | | value.toString(), String.valueOf(c), pos); |
| | | value, c, pos); |
| | | |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | |
| | | else if(!((ch>='0' && ch<='9') || (ch>='A' && ch<='Z') || |
| | | (ch>='a' && ch<='z'))) |
| | | { |
| | | LocalizableMessage msg = ERR_OC_SYNTAX_ATTR_ILLEGAL_CHAR.get( |
| | | value.toString(), ch, index); |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_OC_SYNTAX_ATTR_ILLEGAL_CHAR.get(value, ch, index)); |
| | | } |
| | | break; |
| | | } |
| | |
| | | */ |
| | | package org.opends.server.schema; |
| | | |
| | | |
| | | |
| | | import static org.opends.messages.SchemaMessages.*; |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import static org.opends.server.schema.SchemaConstants.*; |
| | |
| | | import java.util.Collection; |
| | | import java.util.Collections; |
| | | |
| | | import org.forgerock.i18n.LocalizableMessage; |
| | | import org.forgerock.i18n.LocalizableMessageBuilder; |
| | | import org.opends.server.api.EqualityMatchingRule; |
| | | import org.opends.server.api.MatchingRule; |
| | |
| | | import org.opends.server.types.ObjectClass; |
| | | import org.opends.server.types.ResultCode; |
| | | |
| | | |
| | | |
| | | /** |
| | | * This class defines the objectIdentifierMatch matching rule defined in X.520 |
| | | * and referenced in RFC 2252. This expects to work on OIDs and will match |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_OID_INVALID_VALUE.get( |
| | | lowerValue, invalidReason.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_OID_INVALID_VALUE.get( |
| | | lowerValue, invalidReason)); |
| | | } |
| | | |
| | | case WARN: |
| | |
| | | case 's': |
| | | if(second >0) |
| | | { |
| | | message = |
| | | WARN_ATTR_DUPLICATE_SECOND_ASSERTION_FORMAT.get( |
| | | value.toString(),date); |
| | | message = WARN_ATTR_DUPLICATE_SECOND_ASSERTION_FORMAT.get(value, date); |
| | | } |
| | | else |
| | | { |
| | |
| | | case 'm': |
| | | if(minute >0) |
| | | { |
| | | message = |
| | | WARN_ATTR_DUPLICATE_MINUTE_ASSERTION_FORMAT.get( |
| | | value.toString(),date); |
| | | message = WARN_ATTR_DUPLICATE_MINUTE_ASSERTION_FORMAT.get(value, date); |
| | | } |
| | | else |
| | | { |
| | |
| | | case 'h': |
| | | if(hour >0) |
| | | { |
| | | message = |
| | | WARN_ATTR_DUPLICATE_HOUR_ASSERTION_FORMAT.get( |
| | | value.toString(),date); |
| | | message = WARN_ATTR_DUPLICATE_HOUR_ASSERTION_FORMAT.get(value, date); |
| | | } |
| | | else |
| | | { |
| | |
| | | case 'D': |
| | | if(number == 0) |
| | | { |
| | | message = |
| | | WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT.get( |
| | | value.toString(), number); |
| | | message = WARN_ATTR_INVALID_DATE_ASSERTION_FORMAT.get(value, number); |
| | | } |
| | | else if(date > 0) |
| | | { |
| | | message = |
| | | WARN_ATTR_DUPLICATE_DATE_ASSERTION_FORMAT.get( |
| | | value.toString(),date); |
| | | message = WARN_ATTR_DUPLICATE_DATE_ASSERTION_FORMAT.get(value, date); |
| | | } |
| | | else |
| | | { |
| | |
| | | { |
| | | if (value.length() != 36) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_INVALID_LENGTH.get( |
| | | value.toString(), value.length()); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | message); |
| | | case WARN: |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | | } |
| | | return reportInvalidAttrSyntax(value, |
| | | WARN_ATTR_SYNTAX_UUID_INVALID_LENGTH.get(value, value.length())); |
| | | } |
| | | |
| | | StringBuilder builder = new StringBuilder(36); |
| | |
| | | case 23: |
| | | if (c != '-') |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_DASH.get( |
| | | value.toString(), i, String.valueOf(c)); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logger.error( |
| | | message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | | } |
| | | return reportInvalidAttrSyntax(value, |
| | | WARN_ATTR_SYNTAX_UUID_EXPECTED_DASH.get(value, i, c)); |
| | | } |
| | | builder.append(c); |
| | | break; |
| | |
| | | builder.append('f'); |
| | | break; |
| | | default: |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_HEX.get( |
| | | value.toString(), i, String.valueOf(value.byteAt(i))); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException( |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logger.error( |
| | | message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | | } |
| | | return reportInvalidAttrSyntax(value, |
| | | WARN_ATTR_SYNTAX_UUID_EXPECTED_HEX.get(value, i, value.byteAt(i))); |
| | | } |
| | | } |
| | | } |
| | | |
| | | return ByteString.valueOf(builder.toString()); |
| | | } |
| | | |
| | | private ByteString reportInvalidAttrSyntax(ByteSequence value, LocalizableMessage message) |
| | | throws DirectoryException |
| | | { |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, message); |
| | | case WARN: |
| | | logger.error(message); |
| | | return value.toByteString(); |
| | | default: |
| | | return value.toByteString(); |
| | | } |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | if (value.length() != 36) |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_INVALID_LENGTH.get( |
| | | value.toString(), value.length()); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_INVALID_LENGTH.get(value, value.length()); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | case 23: |
| | | if (c != '-') |
| | | { |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_DASH.get( |
| | | value.toString(), i, String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_DASH.get(value, i, c); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | builder.append('f'); |
| | | break; |
| | | default: |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_HEX.get( |
| | | value.toString(), i, String.valueOf(c)); |
| | | LocalizableMessage message = WARN_ATTR_SYNTAX_UUID_EXPECTED_HEX.get(value, i, c); |
| | | switch (DirectoryServer.getSyntaxEnforcementPolicy()) |
| | | { |
| | | case REJECT: |
| | |
| | | builder.append(" "); |
| | | } |
| | | LocalizableMessage message = ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND.get( |
| | | builder.toString(), typeClearBackend.getNameOrOID()); |
| | | builder, typeClearBackend.getNameOrOID()); |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | } |
| | |
| | | } |
| | | if (repeatedBackends.length() > 0) |
| | | { |
| | | LocalizableMessage message = ERR_BACKUPDB_REPEATED_BACKEND_ID.get( |
| | | repeatedBackends.toString()); |
| | | LocalizableMessage message = ERR_BACKUPDB_REPEATED_BACKEND_ID.get(repeatedBackends); |
| | | err.println(wrapText(message, MAX_LINE_WIDTH)); |
| | | err.println(argParser.getUsage()); |
| | | return 1; |
| | |
| | | if (serverRoot == null) |
| | | { |
| | | err.println(ERR_CREATERC_UNABLE_TO_DETERMINE_SERVER_ROOT.get( |
| | | PROPERTY_SERVER_ROOT, ENV_VAR_INSTALL_ROOT).toString()); |
| | | PROPERTY_SERVER_ROOT, ENV_VAR_INSTALL_ROOT)); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | File f = new File(javaHome.getValue()); |
| | | if (! (f.exists() && f.isDirectory())) |
| | | { |
| | | err.println(ERR_CREATERC_JAVA_HOME_DOESNT_EXIST.get( |
| | | javaHome.getValue()).toString()); |
| | | err.println(ERR_CREATERC_JAVA_HOME_DOESNT_EXIST.get(javaHome.getValue())); |
| | | return 1; |
| | | } |
| | | |
| | |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | err.println(ERR_CREATERC_CANNOT_WRITE.get( |
| | | getExceptionMessage(e)).toString()); |
| | | err.println(ERR_CREATERC_CANNOT_WRITE.get(getExceptionMessage(e))); |
| | | return 1; |
| | | } |
| | | |
| | | |
| | | // If we've gotten here, then everything has completed successfully. |
| | | return 0; |
| | | } |
| | |
| | | } |
| | | encodedPW = storageScheme.encodeAuthPassword(clearPW); |
| | | |
| | | LocalizableMessage message = ERR_ENCPW_ENCODED_PASSWORD.get( |
| | | encodedPW.toString()); |
| | | LocalizableMessage message = ERR_ENCPW_ENCODED_PASSWORD.get(encodedPW); |
| | | out.println(message); |
| | | } |
| | | catch (DirectoryException de) |
| | |
| | | builder.append(backend.getBaseDNs()[i].toNormalizedString()); |
| | | } |
| | | LocalizableMessage message = ERR_LDIFIMPORT_MISSING_CLEAR_BACKEND.get( |
| | | builder.toString(), clearBackend.getLongIdentifier()); |
| | | builder, clearBackend.getLongIdentifier()); |
| | | err.println(wrapText(message, MAX_LINE_WIDTH)); |
| | | return 1; |
| | | } |
| | |
| | | attributes.add(new LDAPAttribute(a)); |
| | | } |
| | | protocolOp = new AddRequestProtocolOp(asn1OctetStr, attributes); |
| | | out.println(INFO_PROCESSING_OPERATION.get( |
| | | operationType, asn1OctetStr.toString())); |
| | | out.println(INFO_PROCESSING_OPERATION.get(operationType, asn1OctetStr)); |
| | | break; |
| | | case DELETE: |
| | | operationType = "DELETE"; |
| | | protocolOp = new DeleteRequestProtocolOp(asn1OctetStr); |
| | | out.println(INFO_PROCESSING_OPERATION.get( |
| | | operationType, asn1OctetStr.toString())); |
| | | out.println(INFO_PROCESSING_OPERATION.get(operationType, asn1OctetStr)); |
| | | break; |
| | | case MODIFY: |
| | | operationType = "MODIFY"; |
| | |
| | | ArrayList<RawModification> mods = |
| | | new ArrayList<RawModification>(modEntry.getModifications()); |
| | | protocolOp = new ModifyRequestProtocolOp(asn1OctetStr, mods); |
| | | out.println(INFO_PROCESSING_OPERATION.get( |
| | | operationType, asn1OctetStr.toString())); |
| | | out.println(INFO_PROCESSING_OPERATION.get(operationType, asn1OctetStr)); |
| | | break; |
| | | case MODIFY_DN: |
| | | operationType = "MODIFY DN"; |
| | |
| | | modDNEntry.deleteOldRDN()); |
| | | } |
| | | |
| | | out.println(INFO_PROCESSING_OPERATION.get( |
| | | operationType, asn1OctetStr.toString())); |
| | | out.println(INFO_PROCESSING_OPERATION.get(operationType, asn1OctetStr)); |
| | | break; |
| | | default: |
| | | break; |
| | |
| | | } |
| | | } else |
| | | { |
| | | LocalizableMessage msg = INFO_OPERATION_SUCCESSFUL.get( |
| | | operationType, asn1OctetStr.toString()); |
| | | out.println(msg); |
| | | out.println(INFO_OPERATION_SUCCESSFUL.get(operationType, asn1OctetStr)); |
| | | |
| | | if (errorMessage != null) |
| | | { |
| | |
| | | if(c instanceof LDAPControl) |
| | | { |
| | | // Don't really need to decode since its just an octet string. |
| | | out.println(INFO_CHANGE_NUMBER_CONTROL_RESULT.get(operationType, |
| | | ((LDAPControl)c).getValue().toString())); |
| | | out.println(INFO_CHANGE_NUMBER_CONTROL_RESULT.get( |
| | | operationType, ((LDAPControl)c).getValue())); |
| | | } |
| | | else |
| | | { |
| | | out.println(INFO_CHANGE_NUMBER_CONTROL_RESULT.get(operationType, |
| | | ((ChangeNumberControlPlugin.ChangeNumberControl)c). |
| | | getCSN().toString())); |
| | | ((ChangeNumberControlPlugin.ChangeNumberControl)c).getCSN())); |
| | | } |
| | | } |
| | | } |
| | |
| | | if (pwPolicyWarningType != null) |
| | | { |
| | | LocalizableMessage message = INFO_LDAPPWMOD_PWPOLICY_WARNING.get( |
| | | pwPolicyWarningType.toString(), |
| | | pwPolicyWarningType, |
| | | pwPolicyControl.getWarningValue()); |
| | | out.println(wrapText(message, MAX_LINE_WIDTH)); |
| | | } |
| | |
| | | pwPolicyControl.getErrorType(); |
| | | if (pwPolicyErrorType != null) |
| | | { |
| | | LocalizableMessage message = INFO_LDAPPWMOD_PWPOLICY_ERROR.get( |
| | | pwPolicyErrorType.toString()); |
| | | LocalizableMessage message = INFO_LDAPPWMOD_PWPOLICY_ERROR.get(pwPolicyErrorType); |
| | | out.println(wrapText(message, MAX_LINE_WIDTH)); |
| | | } |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | LocalizableMessage message = ERR_LDAPPWMOD_CANNOT_DECODE_PWPOLICY_CONTROL.get( |
| | | String.valueOf(e)); |
| | | LocalizableMessage message = ERR_LDAPPWMOD_CANNOT_DECODE_PWPOLICY_CONTROL.get(e); |
| | | err.println(wrapText(message, MAX_LINE_WIDTH)); |
| | | } |
| | | } |
| | |
| | | EntryChangeNotificationControl.DECODER |
| | | .decode(c.isCritical(), ((LDAPControl) c).getValue()); |
| | | |
| | | out.println(INFO_LDAPSEARCH_PSEARCH_CHANGE_TYPE.get( |
| | | ecn.getChangeType().toString())); |
| | | out.println(INFO_LDAPSEARCH_PSEARCH_CHANGE_TYPE.get(ecn.getChangeType())); |
| | | DN previousDN = ecn.getPreviousDN(); |
| | | if (previousDN != null) |
| | | { |
| | | |
| | | out.println(INFO_LDAPSEARCH_PSEARCH_PREVIOUS_DN.get( |
| | | previousDN.toString())); |
| | | out.println(INFO_LDAPSEARCH_PSEARCH_PREVIOUS_DN.get(previousDN)); |
| | | } |
| | | } catch (Exception e) {} |
| | | } |
| | |
| | | */ |
| | | public static String getMessageForConnectionException(ASN1Exception ae) |
| | | { |
| | | String msg; |
| | | Throwable cause = ae.getCause(); |
| | | if (cause != null) |
| | | { |
| | |
| | | } |
| | | if (isTimeout) |
| | | { |
| | | msg = ERR_CLIENT_SIDE_TIMEOUT.get( |
| | | ae.getMessageObject().toString()).toString(); |
| | | } |
| | | else |
| | | { |
| | | msg = ae.getMessageObject().toString(); |
| | | return ERR_CLIENT_SIDE_TIMEOUT.get(ae.getMessageObject()).toString(); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | msg = ae.getMessageObject().toString(); |
| | | } |
| | | return msg; |
| | | return ae.getMessageObject().toString(); |
| | | } |
| | | } |
| | | |
| | |
| | | String id = baseToIDMap.get(dn); |
| | | if (id == null) |
| | | { |
| | | LocalizableMessage message = INFO_LISTBACKENDS_NOT_BASE_DN.get( |
| | | dn.toString()); |
| | | out.println(message); |
| | | out.println(INFO_LISTBACKENDS_NOT_BASE_DN.get(dn)); |
| | | |
| | | DN parentDN = dn.parent(); |
| | | while (true) |
| | | { |
| | | if (parentDN == null) |
| | | { |
| | | message = INFO_LISTBACKENDS_NO_BACKEND_FOR_DN.get( |
| | | dn.toString()); |
| | | out.println(message); |
| | | out.println(INFO_LISTBACKENDS_NO_BACKEND_FOR_DN.get(dn)); |
| | | invalidDn = true; |
| | | break; |
| | | } |
| | |
| | | id = baseToIDMap.get(parentDN); |
| | | if (id != null) |
| | | { |
| | | message = INFO_LISTBACKENDS_DN_BELOW_BASE.get( |
| | | dn.toString(), parentDN.toString(), id); |
| | | out.println(message); |
| | | out.println(INFO_LISTBACKENDS_DN_BELOW_BASE.get(dn, parentDN, id)); |
| | | break; |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = INFO_LISTBACKENDS_BASE_FOR_ID.get( |
| | | dn.toString(), id); |
| | | out.println(message); |
| | | out.println(INFO_LISTBACKENDS_BASE_FOR_ID.get(dn, id)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | |
| | | |
| | | message = INFO_RESTOREDB_LIST_DEPENDENCIES.get( |
| | | dependencyList.toString()); |
| | | message = INFO_RESTOREDB_LIST_DEPENDENCIES.get(dependencyList); |
| | | out.println(message); |
| | | |
| | | out.println(); |
| | | } |
| | | |
| | |
| | | } |
| | | catch (IOException ioe) |
| | | { |
| | | println(ERR_DSCFG_ERROR_WRITING_EQUIVALENT_COMMAND_LINE.get(file, |
| | | ioe.toString())); |
| | | println(ERR_DSCFG_ERROR_WRITING_EQUIVALENT_COMMAND_LINE.get(file, ioe)); |
| | | } |
| | | } |
| | | } |
| | |
| | | println( |
| | | ERR_REPLICATION_STATUS_READING_REGISTERED_SERVERS.get( |
| | | Utils.getMessageFromCollection(exceptionMsgs, |
| | | Constants.LINE_SEPARATOR).toString())); |
| | | Constants.LINE_SEPARATOR))); |
| | | println(); |
| | | } |
| | | else |
| | |
| | | cancelled = !askConfirmation( |
| | | ERR_REPLICATION_READING_REGISTERED_SERVERS_CONFIRM_UPDATE_REMOTE. |
| | | get(Utils.getMessageFromCollection(exceptionMsgs, |
| | | Constants.LINE_SEPARATOR).toString()), true, logger); |
| | | Constants.LINE_SEPARATOR)), true, logger); |
| | | } |
| | | catch (CLIException ce) |
| | | { |
| | |
| | | { |
| | | println(ERR_REPLICATION_READING_REGISTERED_SERVERS_WARNING.get( |
| | | Utils.getMessageFromCollection(messages, |
| | | Constants.LINE_SEPARATOR).toString())); |
| | | Constants.LINE_SEPARATOR))); |
| | | } |
| | | } |
| | | // Check whether there is more than one replication server in the |
| | |
| | | println( |
| | | ERR_REPLICATION_READING_REGISTERED_SERVERS_WARNING.get( |
| | | Utils.getMessageFromCollection(messages, |
| | | Constants.LINE_SEPARATOR).toString())); |
| | | Constants.LINE_SEPARATOR))); |
| | | } |
| | | } |
| | | |
| | |
| | | LocalizableMessage msg = |
| | | ERR_REPLICATION_STATUS_READING_REGISTERED_SERVERS.get( |
| | | Utils.getMessageFromCollection(messages, |
| | | Constants.LINE_SEPARATOR).toString()); |
| | | Constants.LINE_SEPARATOR)); |
| | | println(msg); |
| | | } |
| | | } |
| | |
| | | { |
| | | throw new ReplicationCliException( |
| | | ERR_REPLICATION_INITIALIZING_TRIES_COMPLETED.get( |
| | | pnfe.getMessageObject().toString()), |
| | | INITIALIZING_TRIES_COMPLETED, pnfe); |
| | | pnfe.getMessageObject()), INITIALIZING_TRIES_COMPLETED, pnfe); |
| | | } |
| | | try |
| | | { |
| | |
| | | { |
| | | throw new ReplicationCliException( |
| | | ERR_REPLICATION_INITIALIZING_TRIES_COMPLETED.get( |
| | | pnfe.getMessageObject().toString()), |
| | | INITIALIZING_TRIES_COMPLETED, pnfe); |
| | | pnfe.getMessageObject()), INITIALIZING_TRIES_COMPLETED, pnfe); |
| | | } |
| | | try |
| | | { |
| | |
| | | } |
| | | catch (IOException ioe) |
| | | { |
| | | println( |
| | | ERR_REPLICATION_ERROR_WRITING_EQUIVALENT_COMMAND_LINE.get(file, |
| | | ioe.toString())); |
| | | println(ERR_REPLICATION_ERROR_WRITING_EQUIVALENT_COMMAND_LINE.get(file, ioe)); |
| | | } |
| | | } |
| | | } |
| | |
| | | templates.get(toLowerCase(subordinateTemplateNames[i])); |
| | | if (subordinateTemplates[i] == null) |
| | | { |
| | | LocalizableMessage message = ERR_MAKELDIF_UNDEFINED_BRANCH_SUBORDINATE.get( |
| | | branchDN.toString(), subordinateTemplateNames[i]); |
| | | throw new MakeLDIFException(message); |
| | | throw new MakeLDIFException(ERR_MAKELDIF_UNDEFINED_BRANCH_SUBORDINATE.get( |
| | | branchDN, subordinateTemplateNames[i])); |
| | | } |
| | | } |
| | | } |
| | |
| | | // This should not happen but this is useful information to |
| | | // diagnose the error. |
| | | println(); |
| | | println(INFO_ERROR_READING_SERVER_CONFIGURATION.get( |
| | | ne.toString())); |
| | | println(INFO_ERROR_READING_SERVER_CONFIGURATION.get(ne)); |
| | | return ErrorReturnCode.ERROR_READING_CONFIGURATION_WITH_LDAP. |
| | | getReturnCode(); |
| | | } catch (ConfigReadException cre) { |
| | |
| | | // The upgrade only supports version >= 2.4.5. |
| | | if (context.getFromVersion().compareTo(UPGRADESUPPORTSVERSIONFROM) < 0) |
| | | { |
| | | final LocalizableMessage message = |
| | | INFO_UPGRADE_VERSION_IS_NOT_SUPPORTED.get(UPGRADESUPPORTSVERSIONFROM |
| | | .toString(), UPGRADESUPPORTSVERSIONFROM.toString()); |
| | | final LocalizableMessage message = INFO_UPGRADE_VERSION_IS_NOT_SUPPORTED.get( |
| | | UPGRADESUPPORTSVERSIONFROM, UPGRADESUPPORTSVERSIONFROM); |
| | | context.notify(message, NOTICE_CALLBACK); |
| | | throw new ClientException(EXIT_CODE_ERROR, message); |
| | | } |
| | |
| | | // Write the new version |
| | | buildInfo.write(context.getToVersion().toString()); |
| | | |
| | | context.notify(INFO_UPGRADE_SUCCESSFUL.get(context.getFromVersion() |
| | | .toString(), context.getToVersion().toString()), TITLE_CALLBACK); |
| | | |
| | | context.notify(INFO_UPGRADE_SUCCESSFUL.get( |
| | | context.getFromVersion(), context.getToVersion()), TITLE_CALLBACK); |
| | | } |
| | | catch (IOException e) |
| | | { |
| | |
| | | == ConfirmationCallback.YES_NO_CANCEL_OPTION) |
| | | { |
| | | choices.addAll(yesNoDefaultResponses); |
| | | choices.addAll(StaticUtils |
| | | .arrayToList(new String[] { INFO_TASKINFO_CMD_CANCEL_CHAR.get() |
| | | .toString() })); |
| | | choices.addAll(StaticUtils.arrayToList( |
| | | new String[] { INFO_TASKINFO_CMD_CANCEL_CHAR.get().toString() } |
| | | )); |
| | | |
| | | prompt.append(" ") |
| | | .append("(").append(INFO_PROMPT_YES_COMPLETE_ANSWER.get()) |
| | |
| | | // that would be invalid. |
| | | if (dnReader.remaining() <= 0) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString.toString(), attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | // This means that we hit the end of the value before |
| | | // finding a '='. This is illegal because there is no |
| | | // attribute-value separator. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString.toString(), attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | // The next character must be an equal sign. If it is not, |
| | |
| | | { |
| | | // This should not happen. At any rate, it's an illegal |
| | | // character, so throw an exception. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID_CHAR.get( |
| | | dnReader.toString(), (char) b, dnReader.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID_CHAR.get( |
| | | dnReader, (char) b, dnReader.position()-1)); |
| | | } |
| | | |
| | | |
| | |
| | | // because that would be invalid. |
| | | if (b == ' ') |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString.toString(), attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | { |
| | | // This should not happen. At any rate, it's an illegal |
| | | // character, so throw an exception. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID_CHAR.get( |
| | | dnString.toString(), (char) b, dnReader.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID_CHAR.get( |
| | | dnString, (char) b, dnReader.position()-1)); |
| | | } |
| | | } |
| | | } |
| | |
| | | // that would be invalid. |
| | | if (pos >= length) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | // This means that we hit the end of the value before |
| | | // finding a '='. This is illegal because there is no |
| | | // attribute-value separator. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_NO_EQUAL.get( |
| | | dnString, attributeName.toString(), c); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_NO_EQUAL.get(dnString, attributeName, c)); |
| | | } |
| | | |
| | | |
| | |
| | | // because that would be invalid. |
| | | if (pos >= length) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_ATTR_NAME.get(dnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_NO_EQUAL.get( |
| | | dnString, attributeName.toString(), c); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_NO_EQUAL.get(dnString, attributeName, c)); |
| | | } |
| | | |
| | | |
| | |
| | | // know that there is at least one RDN component, and |
| | | // therefore the last non-space character of the DN must |
| | | // have been a comma. This is not acceptable. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_END_WITH_COMMA.get( |
| | | dnBytes.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_END_WITH_COMMA.get(dnBytes)); |
| | | } |
| | | |
| | | dnBytes.skip(-1); |
| | |
| | | case ',': |
| | | // None of these are allowed in an attribute name or any |
| | | // character immediately following it. |
| | | LocalizableMessage msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case '-': |
| | |
| | | // character in the attribute name. |
| | | if (dnBytes.position() == nameStartPos + 1) |
| | | { |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DASH.get(dnBytes); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DASH.get(dnBytes)); |
| | | } |
| | | break; |
| | | |
| | |
| | | case '/': |
| | | // This is not allowed in an attribute name or any character |
| | | // immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case '0': |
| | |
| | | case '<': |
| | | // None of these are allowed in an attribute name or any |
| | | // character immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case '=': |
| | |
| | | case '@': |
| | | // None of these are allowed in an attribute name or any |
| | | // character immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case 'A': |
| | |
| | | case '^': |
| | | // None of these are allowed in an attribute name or any |
| | | // character immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case '_': |
| | |
| | | // name exceptions option is enabled. |
| | | if (dnBytes.position() == nameStartPos + 1) |
| | | { |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_UNDERSCORE. |
| | | get(dnBytes, ATTR_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_UNDERSCORE.get( |
| | | dnBytes, ATTR_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS)); |
| | | } |
| | | else if (!allowExceptions) |
| | | { |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_UNDERSCORE_CHAR. |
| | | get(dnBytes, ATTR_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_UNDERSCORE_CHAR.get( |
| | | dnBytes, ATTR_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS)); |
| | | } |
| | | break; |
| | | |
| | |
| | | case '`': |
| | | // This is not allowed in an attribute name or any character |
| | | // immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | |
| | | |
| | | case 'a': |
| | |
| | | default: |
| | | // This is not allowed in an attribute name or any character |
| | | // immediately following it. |
| | | msg = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes.toString(), (char) b, dnBytes.position()-1); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | msg); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, invalidChar(dnBytes, b)); |
| | | } |
| | | |
| | | |
| | |
| | | |
| | | if (! validOID) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get( |
| | | dnBytes.toString(), nameBytes.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get(dnBytes, nameBytes)); |
| | | } |
| | | } |
| | | else if (isDigit((char)nameBytes.byteAt(0)) && (!allowExceptions)) |
| | |
| | | return nameBytes; |
| | | } |
| | | |
| | | private static LocalizableMessage invalidChar(ByteSequenceReader dnBytes, byte b) |
| | | { |
| | | return ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_CHAR.get( |
| | | dnBytes, (char) b, dnBytes.position()-1); |
| | | } |
| | | |
| | | |
| | | /** |
| | |
| | | validOID = false; |
| | | } |
| | | |
| | | |
| | | if (! validOID) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get( |
| | | dnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_PERIOD.get(dnString, attributeName)); |
| | | } |
| | | } |
| | | else if (isDigit(attributeName.charAt(0)) && |
| | |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_ATTR_ILLEGAL_INITIAL_DIGIT. |
| | | get(dnString, attributeName.charAt(0), |
| | | ATTR_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | } |
| | | |
| | | |
| | | return pos; |
| | | } |
| | | |
| | |
| | | StringBuilder hexString = new StringBuilder(); |
| | | if (dnBytes.remaining() < 2) |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get( |
| | | dnBytes.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get(dnBytes)); |
| | | } |
| | | |
| | | for (int i=0; i < 2; i++) |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get( |
| | | dnBytes.toString(), (char) b); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(dnBytes, (char) b)); |
| | | } |
| | | } |
| | | |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT. |
| | | get(dnBytes, (char) b); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(dnBytes, (char) b)); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get(dnBytes); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_HEX_VALUE_TOO_SHORT.get(dnBytes)); |
| | | } |
| | | } |
| | | else if ((b == ' ') || (b == ',') || (b == ';') || (b == '+')) |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get( |
| | | dnBytes.toString(), (char) b); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID_HEX_DIGIT.get(dnBytes, (char) b)); |
| | | } |
| | | } |
| | | |
| | |
| | | // octet string. |
| | | try |
| | | { |
| | | return ByteString.wrap(hexStringToByteArray( |
| | | hexString.toString())); |
| | | return ByteString.wrap(hexStringToByteArray(hexString.toString())); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE.get(dnBytes, e); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_ATTR_SYNTAX_DN_ATTR_VALUE_DECODE_FAILURE.get(dnBytes, e)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | // We hit the end of the DN before the closing quote. |
| | | // That's an error. |
| | | LocalizableMessage message = ERR_ATTR_SYNTAX_DN_UNMATCHED_QUOTE.get( |
| | | dnBytes.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_UNMATCHED_QUOTE.get(dnBytes)); |
| | | } |
| | | |
| | | if (dnBytes.get() == '"') |
| | |
| | | |
| | | int valueEndPos = dnBytes.position(); |
| | | dnBytes.position(valueStartPos); |
| | | ByteString bs = |
| | | dnBytes.getByteString(valueEndPos - valueStartPos - 1); |
| | | ByteString bs = dnBytes.getByteString(valueEndPos - valueStartPos - 1); |
| | | dnBytes.skip(1); |
| | | return bs; |
| | | } |
| | |
| | | //We don't allow an empty attribute value. So do not allow the |
| | | // first character to be a '+' or ',' since it is not escaped |
| | | // by the user. |
| | | LocalizableMessage message = |
| | | ERR_ATTR_SYNTAX_DN_INVALID_REQUIRES_ESCAPE_CHAR.get( |
| | | dnBytes.toString(),dnBytes.position()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | message); |
| | | ERR_ATTR_SYNTAX_DN_INVALID_REQUIRES_ESCAPE_CHAR.get(dnBytes, dnBytes.position())); |
| | | } |
| | | |
| | | // Otherwise, use general parsing to find the end of the value. |
| | |
| | | // that would be invalid. |
| | | if (pos >= length) |
| | | { |
| | | LocalizableMessage message = ERR_RDN_END_WITH_ATTR_NAME.get( |
| | | rdnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_END_WITH_ATTR_NAME.get(rdnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | { |
| | | // This means that we hit the end of the string before finding a '='. |
| | | // This is illegal because there is no attribute-value separator. |
| | | LocalizableMessage message = ERR_RDN_END_WITH_ATTR_NAME.get( |
| | | rdnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_END_WITH_ATTR_NAME.get(rdnString, attributeName)); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_RDN_NO_EQUAL.get( |
| | | rdnString, attributeName.toString(), c); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_NO_EQUAL.get(rdnString, attributeName, c)); |
| | | } |
| | | |
| | | |
| | |
| | | // Make sure we're not at the end of the RDN. |
| | | if (pos >= length) |
| | | { |
| | | LocalizableMessage message = ERR_RDN_END_WITH_ATTR_NAME.get( |
| | | rdnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_END_WITH_ATTR_NAME.get(rdnString, attributeName)); |
| | | } |
| | | |
| | | |
| | |
| | | { |
| | | // This means that we hit the end of the string before finding a '='. |
| | | // This is illegal because there is no attribute-value separator. |
| | | LocalizableMessage message = ERR_RDN_END_WITH_ATTR_NAME.get( |
| | | rdnString, attributeName.toString()); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_END_WITH_ATTR_NAME.get(rdnString, attributeName)); |
| | | } |
| | | else |
| | | { |
| | |
| | | } |
| | | else |
| | | { |
| | | LocalizableMessage message = ERR_RDN_NO_EQUAL.get( |
| | | rdnString, attributeName.toString(), c); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, message); |
| | | throw new DirectoryException(ResultCode.INVALID_DN_SYNTAX, |
| | | ERR_RDN_NO_EQUAL.get(rdnString, attributeName, c)); |
| | | } |
| | | |
| | | |
| | |
| | | |
| | | default: |
| | | // This is an invalid filter type. |
| | | LocalizableMessage message = ERR_SEARCH_FILTER_INVALID_FILTER_TYPE. |
| | | get(String.valueOf(entry.getName()), toString(), |
| | | filterType.toString()); |
| | | throw new DirectoryException(ResultCode.PROTOCOL_ERROR, |
| | | message); |
| | | ERR_SEARCH_FILTER_INVALID_FILTER_TYPE.get(entry.getName(), this, filterType)); |
| | | } |
| | | } |
| | | |
| | |
| | | catch (Exception e) |
| | | { |
| | | System.err.println(ERR_BASE64_CANNOT_READ_RAW_DATA.get( |
| | | getExceptionMessage(e)).toString()); |
| | | getExceptionMessage(e))); |
| | | System.exit(1); |
| | | } |
| | | } |
| | |
| | | catch (Exception e) |
| | | { |
| | | System.err.println(ERR_BASE64_CANNOT_WRITE_ENCODED_DATA.get( |
| | | getExceptionMessage(e)).toString()); |
| | | getExceptionMessage(e))); |
| | | System.exit(1); |
| | | } |
| | | } |
| | |
| | | catch (Exception e) |
| | | { |
| | | System.err.println(ERR_BASE64_CANNOT_READ_ENCODED_DATA.get( |
| | | getExceptionMessage(e)).toString()); |
| | | getExceptionMessage(e))); |
| | | System.exit(1); |
| | | } |
| | | } |
| | |
| | | catch (Exception e) |
| | | { |
| | | System.err.println(ERR_BASE64_CANNOT_WRITE_RAW_DATA.get( |
| | | getExceptionMessage(e)).toString()); |
| | | getExceptionMessage(e))); |
| | | System.exit(1); |
| | | } |
| | | } |
| | | else |
| | | { |
| | | System.err.println(ERR_BASE64_UNKNOWN_SUBCOMMAND.get( |
| | | subCommand.getName()).toString()); |
| | | subCommand.getName())); |
| | | System.exit(1); |
| | | } |
| | | } |
| | |
| | | * |
| | | * |
| | | * Copyright 2008 Sun Microsystems, Inc. |
| | | * Portions copyright 2013 ForgeRock AS. |
| | | * Portions copyright 2013-2014 ForgeRock AS. |
| | | */ |
| | | |
| | | package org.opends.server.util; |
| | | |
| | | import static org.opends.messages.ToolMessages.ERR_BUILDVERSION_NOT_FOUND; |
| | |
| | | BuildVersion.instanceVersion().toString())) |
| | | { |
| | | throw new InitializationException(ERR_BUILDVERSION_MISMATCH.get( |
| | | BuildVersion.binaryVersion().toString(), BuildVersion |
| | | .instanceVersion().toString())); |
| | | BuildVersion.binaryVersion(), BuildVersion.instanceVersion())); |
| | | } |
| | | } |
| | | |
| | |
| | | if (! entry.conformsToSchema(null, false, true, false, invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIF_SCHEMA_VIOLATION.get( |
| | | String.valueOf(entryDN), |
| | | lastEntryLineNumber, |
| | | invalidReason.toString()); |
| | | entryDN, lastEntryLineNumber, invalidReason); |
| | | logToRejectWriter(lines, message); |
| | | suffix.removePending(entryDN); |
| | | continue; |
| | |
| | | if (! entry.conformsToSchema(null, false, true, false, invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_LDIF_SCHEMA_VIOLATION.get( |
| | | String.valueOf(entryDN), |
| | | lastEntryLineNumber, |
| | | invalidReason.toString()); |
| | | entryDN, lastEntryLineNumber, invalidReason); |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true); |
| | | } |
| | |
| | | } |
| | | |
| | | LocalizableMessage message = ERR_LDIF_INVALID_DN.get( |
| | | lastEntryLineNumber, line.toString(), |
| | | de.getMessageObject()); |
| | | lastEntryLineNumber, line, de.getMessageObject()); |
| | | |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true, de); |
| | |
| | | logger.trace("DN decode failed for: ", dnString); |
| | | } |
| | | LocalizableMessage message = ERR_LDIF_INVALID_DN.get( |
| | | lastEntryLineNumber, line.toString(), |
| | | String.valueOf(e)); |
| | | lastEntryLineNumber, line, e); |
| | | |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true, e); |
| | |
| | | int colonPos = line.indexOf(":"); |
| | | if (colonPos <= 0) |
| | | { |
| | | LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get( |
| | | lastEntryLineNumber, line.toString()); |
| | | LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get(lastEntryLineNumber, line); |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true); |
| | | } |
| | |
| | | if (! attrType.getSyntax().valueIsAcceptable(value, invalidReason)) |
| | | { |
| | | LocalizableMessage message = WARN_LDIF_VALUE_VIOLATES_SYNTAX.get( |
| | | String.valueOf(entryDN), |
| | | lastEntryLineNumber, value.toString(), |
| | | attrName, invalidReason.toString()); |
| | | entryDN, lastEntryLineNumber, value, attrName, invalidReason); |
| | | if (DirectoryServer.getSyntaxEnforcementPolicy() == |
| | | AcceptRejectWarn.WARN) |
| | | { |
| | |
| | | if (!a.add(attributeValue) && checkSchema) |
| | | { |
| | | LocalizableMessage message = WARN_LDIF_DUPLICATE_ATTR.get( |
| | | String.valueOf(entryDN), |
| | | lastEntryLineNumber, attrName, |
| | | value.toString()); |
| | | entryDN, lastEntryLineNumber, attrName, value); |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true); |
| | | } |
| | |
| | | { |
| | | logger.traceException(de); |
| | | LocalizableMessage message = ERR_LDIF_INVALID_DN.get( |
| | | lineNumber, line.toString(), de.getMessageObject()); |
| | | lineNumber, line, de.getMessageObject()); |
| | | throw new LDIFException(message, lineNumber, true); |
| | | } catch (Exception e) |
| | | { |
| | |
| | | { |
| | | logger.traceException(de); |
| | | LocalizableMessage message = ERR_LDIF_INVALID_DN.get( |
| | | lineNumber, line.toString(), de.getMessageObject()); |
| | | lineNumber, line, de.getMessageObject()); |
| | | throw new LDIFException(message, lineNumber, true); |
| | | } catch (Exception e) |
| | | { |
| | | logger.traceException(e); |
| | | LocalizableMessage message = ERR_LDIF_INVALID_DN.get( |
| | | lineNumber, line.toString(), e.getMessage()); |
| | | lineNumber, line, e.getMessage()); |
| | | throw new LDIFException(message, lineNumber, true); |
| | | } |
| | | } |
| | |
| | | if (colonPos <= 0) |
| | | { |
| | | LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get( |
| | | lastEntryLineNumber, line.toString()); |
| | | lastEntryLineNumber, line); |
| | | logToRejectWriter(lines, message); |
| | | throw new LDIFException(message, lastEntryLineNumber, true); |
| | | } |
| | |
| | | if (! a.valueIsAcceptable(argValue, invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_ARGPARSER_VALUE_UNACCEPTABLE_FOR_LONG_ID.get( |
| | | argValue, origArgName, invalidReason.toString()); |
| | | argValue, origArgName, invalidReason); |
| | | throw new ArgumentException(message); |
| | | } |
| | | |
| | |
| | | LocalizableMessageBuilder invalidReason = new LocalizableMessageBuilder(); |
| | | if (! a.valueIsAcceptable(argValue, invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_ARGPARSER_VALUE_UNACCEPTABLE_FOR_SHORT_ID. |
| | | get(argValue, String.valueOf(argCharacter), |
| | | invalidReason.toString()); |
| | | throw new ArgumentException(message); |
| | | throw new ArgumentException(ERR_ARGPARSER_VALUE_UNACCEPTABLE_FOR_SHORT_ID.get( |
| | | argValue, argCharacter, invalidReason)); |
| | | } |
| | | |
| | | // If the argument already has a value, then make sure it is |
| | | // acceptable to have more than one. |
| | | if (a.hasValue() && !a.isMultiValued()) |
| | | { |
| | | LocalizableMessage message = ERR_ARGPARSER_NOT_MULTIVALUED_FOR_SHORT_ID.get( |
| | | String.valueOf(argCharacter)); |
| | | throw new ArgumentException(message); |
| | | throw new ArgumentException(ERR_ARGPARSER_NOT_MULTIVALUED_FOR_SHORT_ID.get(argCharacter)); |
| | | } |
| | | |
| | | a.addValue(argValue); |
| | |
| | | LocalizableMessageBuilder invalidReason = new LocalizableMessageBuilder(); |
| | | if (! a.valueIsAcceptable(argValue, invalidReason)) |
| | | { |
| | | LocalizableMessage message = ERR_SUBCMDPARSER_VALUE_UNACCEPTABLE_FOR_SHORT_ID. |
| | | get(argValue, String.valueOf(argCharacter), |
| | | invalidReason.toString()); |
| | | throw new ArgumentException(message); |
| | | throw new ArgumentException(ERR_SUBCMDPARSER_VALUE_UNACCEPTABLE_FOR_SHORT_ID.get( |
| | | argValue, argCharacter, invalidReason)); |
| | | } |
| | | |
| | | // If the argument already has a value, then make sure it is |
| | | // acceptable to have more than one. |
| | | if (a.hasValue() && !a.isMultiValued()) |
| | | { |
| | | LocalizableMessage message = ERR_SUBCMDPARSER_NOT_MULTIVALUED_FOR_SHORT_ID.get( |
| | | String.valueOf(argCharacter)); |
| | | throw new ArgumentException(message); |
| | | throw new ArgumentException(ERR_SUBCMDPARSER_NOT_MULTIVALUED_FOR_SHORT_ID.get(argCharacter)); |
| | | } |
| | | |
| | | a.addValue(argValue); |
| | |
| | | { |
| | | // Certificate DN |
| | | app.println(INFO_LDAP_CONN_SECURITY_SERVER_CERTIFICATE_USER_DN.get( |
| | | chain[i].getSubjectDN().toString())); |
| | | chain[i].getSubjectDN())); |
| | | |
| | | // certificate validity |
| | | app.println( |
| | | INFO_LDAP_CONN_SECURITY_SERVER_CERTIFICATE_VALIDITY.get( |
| | | chain[i].getNotBefore().toString(), |
| | | chain[i].getNotAfter().toString())); |
| | | app.println(INFO_LDAP_CONN_SECURITY_SERVER_CERTIFICATE_VALIDITY.get( |
| | | chain[i].getNotBefore(), |
| | | chain[i].getNotAfter())); |
| | | |
| | | // certificate Issuer |
| | | app.println( |
| | | INFO_LDAP_CONN_SECURITY_SERVER_CERTIFICATE_ISSUER.get( |
| | | chain[i].getIssuerDN().toString())); |
| | | app.println(INFO_LDAP_CONN_SECURITY_SERVER_CERTIFICATE_ISSUER.get( |
| | | chain[i].getIssuerDN())); |
| | | |
| | | if (i+1 <chain.length) |
| | | { |
| | |
| | | } |
| | | } |
| | | |
| | | LocalizableMessage message = |
| | | ERR_CONFIG_WORKFLOW_ELEMENT_CONFIG_NOT_ACCEPTABLE.get( |
| | | String.valueOf(configuration.dn()), buffer.toString()); |
| | | throw new InitializationException(message); |
| | | throw new InitializationException( |
| | | ERR_CONFIG_WORKFLOW_ELEMENT_CONFIG_NOT_ACCEPTABLE.get(configuration.dn(), buffer)); |
| | | } |
| | | } |
| | | |
| | |
| | | { |
| | | message = WARN_ADD_OP_INVALID_SYNTAX. |
| | | get(String.valueOf(entryDN), |
| | | String.valueOf(v.getValue().toString()), |
| | | String.valueOf(v.getValue()), |
| | | String.valueOf(a.getName()), |
| | | String.valueOf(invalidReason)); |
| | | |
| | |
| | | { |
| | | throw newDirectoryException(currentEntry, |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_MODIFY_ADD_INVALID_SYNTAX.get(String.valueOf(entryDN), |
| | | attr.getName(), v.getValue().toString(), invalidReason)); |
| | | ERR_MODIFY_ADD_INVALID_SYNTAX.get( |
| | | entryDN, attr.getName(), v.getValue(), invalidReason)); |
| | | } |
| | | } |
| | | } |
| | |
| | | } |
| | | else |
| | | { |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX.get(String |
| | | .valueOf(entryDN), attr.getName(), v.getValue().toString(), |
| | | invalidReason)); |
| | | logger.error(ERR_MODIFY_ADD_INVALID_SYNTAX.get( |
| | | entryDN, attr.getName(), v.getValue(), invalidReason)); |
| | | } |
| | | invalidReason = new LocalizableMessageBuilder(); |
| | | } |
| | |
| | | throw newDirectoryException(currentEntry, |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_MODIFY_REPLACE_INVALID_SYNTAX.get(String.valueOf(entryDN), |
| | | attr.getName(), v.getValue().toString(), invalidReason)); |
| | | attr.getName(), v.getValue(), invalidReason)); |
| | | } |
| | | } |
| | | } |
| | |
| | | else |
| | | { |
| | | logger.error(ERR_MODIFY_REPLACE_INVALID_SYNTAX.get(String |
| | | .valueOf(entryDN), attr.getName(), v.getValue().toString(), |
| | | .valueOf(entryDN), attr.getName(), v.getValue(), |
| | | invalidReason)); |
| | | } |
| | | invalidReason = new LocalizableMessageBuilder(); |
| | |
| | | |
| | | throw new DirectoryException(ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_MODIFY_INCREMENT_PROVIDED_VALUE_NOT_INTEGER.get(String |
| | | .valueOf(entryDN), attr.getName(), v.getValue().toString()), e); |
| | | .valueOf(entryDN), attr.getName(), v.getValue()), e); |
| | | } |
| | | |
| | | // Get the attribute that is to be incremented. |
| | |
| | | ResultCode.INVALID_ATTRIBUTE_SYNTAX, |
| | | ERR_MODIFY_INCREMENT_REQUIRES_INTEGER_VALUE.get(String |
| | | .valueOf(entryDN), a.getName(), |
| | | existingValue.getValue().toString()), |
| | | existingValue.getValue()), |
| | | e); |
| | | } |
| | | |