| | |
| | | import org.forgerock.i18n.slf4j.LocalizedLogger; |
| | | import org.forgerock.opendj.config.server.ConfigChangeResult; |
| | | import org.forgerock.opendj.config.server.ConfigException; |
| | | import org.forgerock.opendj.config.server.ConfigurationChangeListener; |
| | | import org.forgerock.opendj.ldap.AVA; |
| | | import org.forgerock.opendj.ldap.ByteString; |
| | | import org.forgerock.opendj.ldap.ConditionResult; |
| | |
| | | import org.forgerock.opendj.ldap.schema.CoreSchema; |
| | | import org.forgerock.opendj.ldap.schema.MatchingRule; |
| | | import org.forgerock.opendj.ldap.schema.ObjectClassType; |
| | | import org.forgerock.opendj.config.server.ConfigurationChangeListener; |
| | | import org.forgerock.opendj.server.config.server.SchemaBackendCfg; |
| | | import org.opends.server.api.AlertGenerator; |
| | | import org.opends.server.api.Backend; |
| | | import org.opends.server.api.Backupable; |
| | | import org.opends.server.api.ClientConnection; |
| | | import org.opends.server.types.Entry; |
| | | import org.opends.server.core.AddOperation; |
| | | import org.opends.server.core.DeleteOperation; |
| | | import org.opends.server.core.DirectoryServer; |
| | |
| | | import org.opends.server.types.DITContentRule; |
| | | import org.opends.server.types.DITStructureRule; |
| | | import org.opends.server.types.DirectoryException; |
| | | import org.opends.server.types.Entry; |
| | | import org.opends.server.types.ExistingFileBehavior; |
| | | import org.opends.server.types.IndexType; |
| | | import org.opends.server.types.InitializationException; |
| | |
| | | ObjectClass subschemaOC = DirectoryServer.getObjectClass(OC_SUBSCHEMA, true); |
| | | schemaObjectClasses.put(subschemaOC, OC_SUBSCHEMA); |
| | | |
| | | |
| | | configEntryDN = configEntry.getName(); |
| | | baseDNs = cfg.getBaseDN(); |
| | | |
| | |
| | | modifyTimestamp = |
| | | GeneralizedTimeSyntax.createGeneralizedTimeValue(newModifyTime); |
| | | |
| | | |
| | | // Get the set of user-defined attributes for the configuration entry. Any |
| | | // attributes that we don't recognize will be included directly in the |
| | | // schema entry. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Identify any differences that may exist between the concatenated schema |
| | | // file from the last online modification and the current schema files. If |
| | | // there are any differences, then they should be from making changes to the |
| | |
| | | logger.error(ERR_SCHEMA_ERROR_DETERMINING_SCHEMA_CHANGES, getExceptionMessage(e)); |
| | | } |
| | | |
| | | |
| | | // Register with the Directory Server as a configurable component. |
| | | currentConfig.addSchemaChangeListener(this); |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether the provided attribute is one that is used in the |
| | | * configuration of this backend. |
| | |
| | | return null; |
| | | } |
| | | |
| | | |
| | | /** |
| | | * Generates and returns a schema entry for the Directory Server. |
| | | * |
| | |
| | | } |
| | | } |
| | | |
| | | /* |
| | | * Add the schema definition attributes. |
| | | */ |
| | | /* Add the schema definition attributes. */ |
| | | Schema schema = DirectoryServer.getSchema(); |
| | | buildSchemaAttribute(schema.getAttributeTypes(), userAttrs, |
| | | operationalAttrs, attributeTypesType, includeSchemaFile, |
| | |
| | | return e; |
| | | } |
| | | |
| | | |
| | | |
| | | private void addAttributeToSchemaEntry(Attribute attribute, |
| | | Map<AttributeType, List<Attribute>> userAttrs, |
| | | Map<AttributeType, List<Attribute>> operationalAttrs) |
| | |
| | | attrs.add(attribute); |
| | | } |
| | | |
| | | |
| | | |
| | | private void buildSchemaAttribute(Collection<?> elements, |
| | | Map<AttributeType, List<Attribute>> userAttrs, |
| | | Map<AttributeType, List<Attribute>> operationalAttrs, |
| | |
| | | AttributeBuilder builder = new AttributeBuilder(schemaAttributeType); |
| | | for (Object element : elements) |
| | | { |
| | | /* |
| | | * Add the file name to the description of the element if this was |
| | | * requested by the caller. |
| | | */ |
| | | /* Add the file name to the description of the element if this was requested by the caller. */ |
| | | String value; |
| | | if (includeSchemaFile && element instanceof CommonSchemaElements) |
| | | { |
| | |
| | | message); |
| | | } |
| | | |
| | | |
| | | ArrayList<Modification> mods = new ArrayList<>(modifyOperation.getModifications()); |
| | | if (mods.isEmpty()) |
| | | { |
| | |
| | | |
| | | break; |
| | | |
| | | |
| | | case DELETE: |
| | | if (a.isEmpty()) |
| | | { |
| | |
| | | |
| | | break; |
| | | |
| | | |
| | | case REPLACE: |
| | | if (!m.isInternal() |
| | | && !modifyOperation.isSynchronizationOperation()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If we've gotten here, then everything looks OK, re-write all the |
| | | // modified Schema Files. |
| | | updateSchemaFiles(newSchema, modifiedSchemaFiles); |
| | |
| | | // Finally set DirectoryServer to use the new Schema. |
| | | DirectoryServer.setSchema(newSchema); |
| | | |
| | | |
| | | DN authzDN = modifyOperation.getAuthorizationDN(); |
| | | if (authzDN == null) |
| | | { |
| | |
| | | System.currentTimeMillis()); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Re-write all schema files using the provided new Schema and list of |
| | | * modified files. |
| | |
| | | cleanUpTempSchemaFiles(tempSchemaFiles); |
| | | } |
| | | |
| | | |
| | | // Create a single file with all of the concatenated schema information |
| | | // that we can use on startup to detect whether the schema files have been |
| | | // edited with the server offline. |
| | | Schema.writeConcatenatedSchema(); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided attribute type to |
| | | * the given schema, replacing an existing type if necessary, and ensuring all |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided objectclass to the |
| | | * given schema, replacing an existing class if necessary, and ensuring |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the new objectclass doesn't reference an undefined |
| | | // superior class, or an undefined required or optional attribute type, |
| | | // and that none of them are OBSOLETE. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If there is no existing class, then we're adding a new objectclass. |
| | | // Otherwise, we're replacing an existing one. |
| | | if (existingClass == null) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required to remove the provided objectclass from the |
| | | * server schema, ensuring all other metadata is properly updated. Note that |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // See if there is another modification later to add the objectclass back |
| | | // into the schema. If so, then it's a replace and we should ignore the |
| | | // remove because adding it back will handle the replace. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the objectclass isn't used as the superior class for any |
| | | // other objectclass. |
| | | for (ObjectClass oc : schema.getObjectClasses().values()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the objectclass isn't used as the structural class for |
| | | // any name form. |
| | | List<NameForm> mappedForms = schema.getNameForm(removeClass); |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // Make sure that the objectclass isn't used as a structural or auxiliary |
| | | // class for any DIT content rule. |
| | | for (DITContentRule dcr : schema.getDITContentRules().values()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If we've gotten here, then it's OK to remove the objectclass from the |
| | | // schema. |
| | | schema.deregisterObjectClass(removeClass); |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided name form to the |
| | | * the given schema, replacing an existing name form if necessary, and |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the new name form doesn't reference an undefined |
| | | // structural class, or an undefined required or optional attribute type, or |
| | | // that any of them are marked OBSOLETE. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If there is no existing class, then we're adding a new name form. |
| | | // Otherwise, we're replacing an existing one. |
| | | if (existingNF == null) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required to remove the provided name form from the |
| | | * server schema, ensuring all other metadata is properly updated. Note that |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // See if there is another modification later to add the name form back |
| | | // into the schema. If so, then it's a replace and we should ignore the |
| | | // remove because adding it back will handle the replace. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the name form isn't referenced by any DIT structure |
| | | // rule. |
| | | DITStructureRule dsr = schema.getDITStructureRule(removeNF); |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // If we've gotten here, then it's OK to remove the name form from the |
| | | // schema. |
| | | schema.deregisterNameForm(removeNF); |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided DIT content rule to |
| | | * the given schema, replacing an existing rule if necessary, and ensuring |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Get the structural class for the new DIT content rule and see if there's |
| | | // already an existing rule that is associated with that class. If there |
| | | // is, then it will only be acceptable if it's the DIT content rule that we |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // Make sure that the new DIT content rule doesn't reference an undefined |
| | | // structural or auxiliary class, or an undefined required, optional, or |
| | | // prohibited attribute type. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If there is no existing rule, then we're adding a new DIT content rule. |
| | | // Otherwise, we're replacing an existing one. |
| | | if (existingDCR == null) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required to remove the provided DIT content rule |
| | | * from the server schema, ensuring all other metadata is properly updated. |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // Since DIT content rules don't have any dependencies, then we don't need |
| | | // to worry about the difference between a remove or a replace. We can |
| | | // just remove the DIT content rule now, and if it is added back later then |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided DIT structure rule |
| | | * to the given schema, replacing an existing rule if necessary, and ensuring |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // Make sure that the new DIT structure rule doesn't reference an undefined |
| | | // name form or superior DIT structure rule. |
| | | if (! schema.hasNameForm(nameForm.getOID())) |
| | |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message); |
| | | } |
| | | |
| | | |
| | | // If there are any superior rules, then make sure none of them are marked |
| | | // OBSOLETE. |
| | | for (DITStructureRule dsr : ditStructureRule.getSuperiorRules()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If there is no existing rule, then we're adding a new DIT structure rule. |
| | | // Otherwise, we're replacing an existing one. |
| | | if (existingDSR == null) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required to remove the provided DIT structure rule |
| | | * from the server schema, ensuring all other metadata is properly updated. |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // See if there is another modification later to add the DIT structure rule |
| | | // back into the schema. If so, then it's a replace and we should ignore |
| | | // the remove because adding it back will handle the replace. |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Make sure that the DIT structure rule isn't the superior for any other |
| | | // DIT structure rule. |
| | | for (DITStructureRule dsr : schema.getDITStructureRulesByID().values()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If we've gotten here, then it's OK to remove the DIT structure rule from |
| | | // the schema. |
| | | schema.deregisterDITStructureRule(removeDSR); |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required for adding the provided matching rule use |
| | | * to the given schema, replacing an existing use if necessary, and ensuring |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Get the matching rule for the new matching rule use and see if there's |
| | | // already an existing matching rule use that is associated with that |
| | | // matching rule. If there is, then it will only be acceptable if it's the |
| | |
| | | throw new DirectoryException(ResultCode.CONSTRAINT_VIOLATION, message); |
| | | } |
| | | |
| | | |
| | | // Make sure that the new matching rule use doesn't reference an undefined |
| | | // attribute type. |
| | | for (AttributeType at : matchingRuleUse.getAttributes()) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // If there is no existing matching rule use, then we're adding a new one. |
| | | // Otherwise, we're replacing an existing matching rule use. |
| | | if (existingMRU == null) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Handles all processing required to remove the provided matching rule use |
| | | * from the server schema, ensuring all other metadata is properly updated. |
| | |
| | | throw new DirectoryException(ResultCode.UNWILLING_TO_PERFORM, message); |
| | | } |
| | | |
| | | |
| | | // Since matching rule uses don't have any dependencies, then we don't need |
| | | // to worry about the difference between a remove or a replace. We can |
| | | // just remove the DIT content rule now, and if it is added back later then |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** Gets rid of the ldap syntax description. */ |
| | | private void removeLdapSyntaxDescription(String definition, Schema schema, Set<String> modifiedSchemaFiles) |
| | | throws DirectoryException |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates an empty entry that may be used as the basis for a new schema file. |
| | | * |
| | |
| | | return new Entry(dn, objectClasses, userAttributes, operationalAttributes); |
| | | } |
| | | |
| | | |
| | | |
| | | |
| | | /** |
| | | * Writes a temporary version of the specified schema file. |
| | | * |
| | |
| | | schemaEntry.putAttribute(attributeTypesType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | // Add all of the appropriate objectclasses to the schema entry. We need |
| | | // to be careful of the ordering to ensure that any superior classes in the |
| | | // same file are written before the subordinate classes. |
| | |
| | | schemaEntry.putAttribute(objectClassesType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | // Add all of the appropriate name forms to the schema entry. Since there |
| | | // is no hierarchical relationship between name forms, we don't need to |
| | | // worry about ordering. |
| | |
| | | schemaEntry.putAttribute(nameFormsType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | // Add all of the appropriate DIT content rules to the schema entry. Since |
| | | // there is no hierarchical relationship between DIT content rules, we don't |
| | | // need to worry about ordering. |
| | |
| | | schemaEntry.putAttribute(ditContentRulesType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | // Add all of the appropriate DIT structure rules to the schema entry. We |
| | | // need to be careful of the ordering to ensure that any superior rules in |
| | | // the same file are written before the subordinate rules. |
| | |
| | | schemaEntry.putAttribute(ditStructureRulesType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | // Add all of the appropriate matching rule uses to the schema entry. Since |
| | | // there is no hierarchical relationship between matching rule uses, we |
| | | // don't need to worry about ordering. |
| | |
| | | schemaEntry.putAttribute(matchingRuleUsesType, newArrayList(builder.toAttribute())); |
| | | } |
| | | |
| | | |
| | | if (FILE_USER_SCHEMA_ELEMENTS.equals(schemaFile)) |
| | | { |
| | | Map<String, Attribute> attributes = schema.getExtraAttributes(); |
| | |
| | | LDIFExportConfig exportConfig = |
| | | new LDIFExportConfig(tempFile.getAbsolutePath(), |
| | | ExistingFileBehavior.OVERWRITE); |
| | | LDIFWriter ldifWriter = new LDIFWriter(exportConfig); |
| | | ldifWriter.writeEntry(schemaEntry); |
| | | ldifWriter.close(); |
| | | try (LDIFWriter ldifWriter = new LDIFWriter(exportConfig)) |
| | | { |
| | | ldifWriter.writeEntry(schemaEntry); |
| | | } |
| | | |
| | | return tempFile; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Adds the definition for the specified attribute type to the provided set of |
| | | * attribute values, recursively adding superior types as appropriate. |
| | |
| | | addedTypes.add(attributeType); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Adds the definition for the specified objectclass to the provided set of |
| | | * attribute values, recursively adding superior classes as appropriate. |
| | |
| | | addedClasses.add(objectClass); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Adds the definition for the specified DIT structure rule to the provided |
| | | * set of attribute values, recursively adding superior rules as appropriate. |
| | |
| | | addedDSRs.add(ditStructureRule); |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Moves the specified temporary schema files in place of the active versions. |
| | | * If an error occurs in the process, then this method will attempt to restore |
| | |
| | | origFileList.add(new File(schemaInstanceDir, name + ".orig")); |
| | | } |
| | | |
| | | |
| | | // If there are any old ".orig" files laying around from a previous |
| | | // attempt, then try to clean them up. |
| | | for (File f : origFileList) |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | // Copy all of the currently-installed files with a ".orig" extension. If |
| | | // this fails, then try to clean up the copies. |
| | | try |
| | |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), message, e); |
| | | } |
| | | |
| | | |
| | | // Try to copy all of the temporary files into place over the installed |
| | | // files. If this fails, then try to restore the originals. |
| | | try |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Creates a copy of the specified file. |
| | | * |
| | |
| | | */ |
| | | private void copyFile(File from, File to) throws IOException |
| | | { |
| | | byte[] buffer = new byte[4096]; |
| | | FileInputStream inputStream = null; |
| | | FileOutputStream outputStream = null; |
| | | try |
| | | try (FileInputStream inputStream = new FileInputStream(from); |
| | | FileOutputStream outputStream = new FileOutputStream(to, false)) |
| | | { |
| | | inputStream = new FileInputStream(from); |
| | | outputStream = new FileOutputStream(to, false); |
| | | |
| | | byte[] buffer = new byte[4096]; |
| | | int bytesRead = inputStream.read(buffer); |
| | | while (bytesRead > 0) |
| | | { |
| | |
| | | bytesRead = inputStream.read(buffer); |
| | | } |
| | | } |
| | | finally |
| | | { |
| | | close(inputStream, outputStream); |
| | | } |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Performs any necessary cleanup in an attempt to delete any temporary schema |
| | | * files that may have been left over after trying to install the new schema. |
| | |
| | | matchedDN, null); |
| | | } |
| | | |
| | | |
| | | // If it's a onelevel or subordinate subtree search, then we will never |
| | | // match anything since there isn't anything below the schema. |
| | | SearchScope scope = searchOperation.getScope(); |
| | |
| | | return; |
| | | } |
| | | |
| | | |
| | | // Get the schema entry and see if it matches the filter. If so, then send |
| | | // it to the client. |
| | | Entry schemaEntry = getSchemaEntry(baseDN, false); |
| | |
| | | message); |
| | | } |
| | | |
| | | |
| | | // Write the root schema entry to it. Make sure to close the LDIF |
| | | // writer when we're done. |
| | | try |
| | |
| | | public LDIFImportResult importLDIF(LDIFImportConfig importConfig, ServerContext serverContext) |
| | | throws DirectoryException |
| | | { |
| | | LDIFReader reader; |
| | | try |
| | | { |
| | | reader = new LDIFReader(importConfig); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | ERR_MEMORYBACKEND_CANNOT_CREATE_LDIF_READER.get(e), e); |
| | | } |
| | | |
| | | |
| | | try |
| | | try (LDIFReader reader = newLDIFReader(importConfig)) |
| | | { |
| | | while (true) |
| | | { |
| | |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | ERR_MEMORYBACKEND_ERROR_DURING_IMPORT.get(e), e); |
| | | } |
| | | finally |
| | | { |
| | | close(reader); |
| | | } |
| | | } |
| | | |
| | | private LDIFReader newLDIFReader(LDIFImportConfig importConfig) throws DirectoryException |
| | | { |
| | | try |
| | | { |
| | | return new LDIFReader(importConfig); |
| | | } |
| | | catch (Exception e) |
| | | { |
| | | throw new DirectoryException(DirectoryServer.getServerErrorResultCode(), |
| | | ERR_MEMORYBACKEND_CANNOT_CREATE_LDIF_READER.get(e), e); |
| | | } |
| | | } |
| | | |
| | | /** |
| | | * Import an entry in a new schema by : |
| | |
| | | { |
| | | final ConfigChangeResult ccr = new ConfigChangeResult(); |
| | | |
| | | |
| | | // Check to see if we should apply a new set of base DNs. |
| | | Set<DN> newBaseDNs; |
| | | try |
| | |
| | | newBaseDNs = null; |
| | | } |
| | | |
| | | |
| | | // Check to see if we should change the behavior regarding whether to show |
| | | // all schema attributes. |
| | | boolean newShowAllAttributes = backendCfg.isShowAllAttributes(); |
| | | |
| | | |
| | | // Check to see if there is a new set of user-defined attributes. |
| | | ArrayList<Attribute> newUserAttrs = new ArrayList<>(); |
| | | try |
| | |
| | | ccr.setResultCode(DirectoryServer.getServerErrorResultCode()); |
| | | } |
| | | |
| | | |
| | | if (ccr.getResultCode() == ResultCode.SUCCESS) |
| | | { |
| | | // Determine the set of DNs to add and delete. When this is done, the |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | showAllAttributes = newShowAllAttributes; |
| | | |
| | | |
| | | userDefinedAttributes = newUserAttrs; |
| | | LocalizableMessage message = INFO_SCHEMA_USING_NEW_USER_ATTRS.get(); |
| | | ccr.addMessage(message); |
| | | } |
| | | |
| | | |
| | | currentConfig = backendCfg; |
| | | return ccr; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Indicates whether to treat common schema attributes like user attributes |
| | | * rather than operational attributes. |
| | |
| | | return showAllAttributes; |
| | | } |
| | | |
| | | |
| | | |
| | | /** |
| | | * Specifies whether to treat common schema attributes like user attributes |
| | | * rather than operational attributes. |