/** {@inheritDoc} */ @Override() public DynamicGroup newInstance(Entry groupEntry) throws DirectoryException { ensureNotNull(groupEntry); // Get the memberURL attribute from the entry, if there is one, and parse // out the LDAP URLs that it contains. LinkedHashSet<LDAPURL> memberURLs = new LinkedHashSet<LDAPURL>(); AttributeType memberURLType = DirectoryConfig.getAttributeType(ATTR_MEMBER_URL_LC, true); List<Attribute> attrList = groupEntry.getAttribute(memberURLType); if (attrList != null) { for (Attribute a : attrList) { for (AttributeValue v : a) { try { memberURLs.add(LDAPURL.decode(v.getValue().toString(), true)); } catch (DirectoryException de) { if (debugEnabled()) { TRACER.debugCaught(DebugLogLevel.ERROR, de); } Message message = ERR_DYNAMICGROUP_CANNOT_DECODE_MEMBERURL.get( v.getValue().toString(), String.valueOf(groupEntry.getDN()), de.getMessageObject()); ErrorLogger.logError(message); } } } } return new DynamicGroup(groupEntry.getDN(), memberURLs); }
/** {@inheritDoc} */ @Override protected int processLocal(boolean initializeServer, PrintStream out, PrintStream err) { // Perform the initial bootstrap of the Directory Server and process the // configuration. DirectoryServer directoryServer = DirectoryServer.getInstance(); if (initializeServer) { try { DirectoryServer.bootstrapClient(); DirectoryServer.initializeJMX(); } catch (Exception e) { printWrappedText(err, ERR_SERVER_BOOTSTRAP_ERROR.get(getExceptionMessage(e))); return 1; } try { directoryServer.initializeConfiguration(configClass.getValue(), configFile.getValue()); } catch (InitializationException ie) { printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(ie.getMessage())); return 1; } catch (Exception e) { printWrappedText(err, ERR_CANNOT_LOAD_CONFIG.get(getExceptionMessage(e))); return 1; } // Initialize the Directory Server schema elements. try { directoryServer.initializeSchema(); } catch (ConfigException | InitializationException e) { printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(e.getMessage())); return 1; } catch (Exception e) { printWrappedText(err, ERR_CANNOT_LOAD_SCHEMA.get(getExceptionMessage(e))); return 1; } // Initialize the Directory Server core configuration. try { CoreConfigManager coreConfigManager = new CoreConfigManager(directoryServer.getServerContext()); coreConfigManager.initializeCoreConfig(); } catch (ConfigException | InitializationException e) { printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(e.getMessage())); return 1; } catch (Exception e) { printWrappedText(err, ERR_CANNOT_INITIALIZE_CORE_CONFIG.get(getExceptionMessage(e))); return 1; } // Initialize the Directory Server crypto manager. try { directoryServer.initializeCryptoManager(); } catch (ConfigException | InitializationException e) { printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(e.getMessage())); return 1; } catch (Exception e) { printWrappedText(err, ERR_CANNOT_INITIALIZE_CRYPTO_MANAGER.get(getExceptionMessage(e))); return 1; } try { ErrorLogPublisher errorLogPublisher = TextErrorLogPublisher.getToolStartupTextErrorPublisher(new TextWriter.STREAM(out)); ErrorLogger.getInstance().addLogPublisher(errorLogPublisher); DebugLogger.getInstance().addPublisherIfRequired(new TextWriter.STREAM(out)); } catch (Exception e) { err.println("Error installing the custom error logger: " + stackTraceToSingleLineString(e)); } // Make sure that the Directory Server plugin initialization is performed. try { HashSet<PluginType> pluginTypes = new HashSet<>(1); pluginTypes.add(PluginType.LDIF_EXPORT); directoryServer.initializePlugins(pluginTypes); } catch (ConfigException | InitializationException e) { printWrappedText(err, ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS.get(e.getMessage())); return 1; } catch (Exception e) { printWrappedText(err, ERR_LDIFEXPORT_CANNOT_INITIALIZE_PLUGINS.get(getExceptionMessage(e))); return 1; } } // See if there were any user-defined sets of include/exclude attributes or // filters. If so, then process them. Set<AttributeType> excludeAttributes = toAttributeTypes(excludeAttributeStrings); Set<AttributeType> includeAttributes = toAttributeTypes(includeAttributeStrings); ArrayList<SearchFilter> excludeFilters; if (excludeFilterStrings == null) { excludeFilters = null; } else { excludeFilters = new ArrayList<>(); for (String filterString : excludeFilterStrings.getValues()) { try { excludeFilters.add(SearchFilter.createFilterFromString(filterString)); } catch (DirectoryException de) { logger.error( ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, de.getMessageObject()); return 1; } catch (Exception e) { logger.error( ERR_LDIFEXPORT_CANNOT_PARSE_EXCLUDE_FILTER, filterString, getExceptionMessage(e)); return 1; } } } ArrayList<SearchFilter> includeFilters; if (includeFilterStrings == null) { includeFilters = null; } else { includeFilters = new ArrayList<>(); for (String filterString : includeFilterStrings.getValues()) { try { includeFilters.add(SearchFilter.createFilterFromString(filterString)); } catch (DirectoryException de) { logger.error( ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, de.getMessageObject()); return 1; } catch (Exception e) { logger.error( ERR_LDIFEXPORT_CANNOT_PARSE_INCLUDE_FILTER, filterString, getExceptionMessage(e)); return 1; } } } // Get information about the backends defined in the server. Iterate // through them, finding the one backend that should be used for the export, // and also finding backends with subordinate base DNs that should be // excluded from the export. Backend backend = null; List<DN> baseDNList = null; List<DN> defaultIncludeBranches = null; ArrayList<DN> excludeBranches = null; ArrayList<Backend> backendList = new ArrayList<>(); ArrayList<BackendCfg> entryList = new ArrayList<>(); ArrayList<List<DN>> dnList = new ArrayList<>(); BackendToolUtils.getBackends(backendList, entryList, dnList); int numBackends = backendList.size(); for (int i = 0; i < numBackends; i++) { Backend b = backendList.get(i); if (!backendID.getValue().equals(b.getBackendID())) { continue; } if (backend == null) { backend = b; baseDNList = dnList.get(i); defaultIncludeBranches = dnList.get(i); } else { logger.error(ERR_LDIFEXPORT_MULTIPLE_BACKENDS_FOR_ID, backendID.getValue()); return 1; } } if (backend == null) { logger.error(ERR_LDIFEXPORT_NO_BACKENDS_FOR_ID, backendID.getValue()); return 1; } else if (!backend.supports(BackendOperation.RESTORE)) { logger.error(ERR_LDIFEXPORT_CANNOT_EXPORT_BACKEND, backendID.getValue()); return 1; } if (excludeBranchStrings.isPresent()) { excludeBranches = new ArrayList<>(); for (String s : excludeBranchStrings.getValues()) { DN excludeBranch; try { excludeBranch = DN.valueOf(s); } catch (DirectoryException de) { logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, de.getMessageObject()); return 1; } catch (Exception e) { logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_EXCLUDE_BASE, s, getExceptionMessage(e)); return 1; } if (!excludeBranches.contains(excludeBranch)) { excludeBranches.add(excludeBranch); } } } List<DN> includeBranches; if (includeBranchStrings.isPresent()) { includeBranches = new ArrayList<>(); for (String s : includeBranchStrings.getValues()) { DN includeBranch; try { includeBranch = DN.valueOf(s); } catch (DirectoryException de) { logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, de.getMessageObject()); return 1; } catch (Exception e) { logger.error(ERR_LDIFIMPORT_CANNOT_DECODE_INCLUDE_BASE, s, getExceptionMessage(e)); return 1; } if (!Backend.handlesEntry(includeBranch, defaultIncludeBranches, excludeBranches)) { logger.error(ERR_LDIFEXPORT_INVALID_INCLUDE_BASE, s, backendID.getValue()); return 1; } includeBranches.add(includeBranch); } } else { includeBranches = defaultIncludeBranches; } // Create the LDIF export configuration to use when reading the LDIF. ExistingFileBehavior existingBehavior; if (appendToLDIF.isPresent()) { existingBehavior = ExistingFileBehavior.APPEND; } else { existingBehavior = ExistingFileBehavior.OVERWRITE; } LDIFExportConfig exportConfig = new LDIFExportConfig(ldifFile.getValue(), existingBehavior); exportConfig.setCompressData(compressLDIF.isPresent()); exportConfig.setEncryptData(encryptLDIF.isPresent()); exportConfig.setExcludeAttributes(excludeAttributes); exportConfig.setExcludeBranches(excludeBranches); exportConfig.setExcludeFilters(excludeFilters); exportConfig.setIncludeAttributes(includeAttributes); exportConfig.setIncludeBranches(includeBranches); exportConfig.setIncludeFilters(includeFilters); exportConfig.setSignHash(signHash.isPresent()); exportConfig.setIncludeOperationalAttributes(!excludeOperationalAttrs.isPresent()); // FIXME -- Should this be conditional? exportConfig.setInvokeExportPlugins(true); try { exportConfig.setWrapColumn(wrapColumn.getIntValue()); } catch (ArgumentException ae) { logger.error(ERR_LDIFEXPORT_CANNOT_DECODE_WRAP_COLUMN_AS_INTEGER, wrapColumn.getValue()); return 1; } // Get the set of base DNs for the backend as an array. DN[] baseDNs = new DN[baseDNList.size()]; baseDNList.toArray(baseDNs); // Acquire a shared lock for the backend. try { String lockFile = LockFileManager.getBackendLockFileName(backend); StringBuilder failureReason = new StringBuilder(); if (!LockFileManager.acquireSharedLock(lockFile, failureReason)) { logger.error(ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), failureReason); return 1; } } catch (Exception e) { logger.error( ERR_LDIFEXPORT_CANNOT_LOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); return 1; } boolean errorOccurred = false; // Launch the export. try { backend.exportLDIF(exportConfig); } catch (DirectoryException de) { logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, de.getMessageObject()); errorOccurred = true; } catch (Exception e) { logger.error(ERR_LDIFEXPORT_ERROR_DURING_EXPORT, getExceptionMessage(e)); errorOccurred = true; } // Release the shared lock on the backend. try { String lockFile = LockFileManager.getBackendLockFileName(backend); StringBuilder failureReason = new StringBuilder(); if (!LockFileManager.releaseLock(lockFile, failureReason)) { logger.warn(WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), failureReason); } } catch (Exception e) { logger.warn( WARN_LDIFEXPORT_CANNOT_UNLOCK_BACKEND, backend.getBackendID(), getExceptionMessage(e)); } // Clean up after the export by closing the export config. exportConfig.close(); return !errorOccurred ? 0 : 1; }