/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2008-2009 Sun Microsystems, Inc.
|
* Portions Copyright 2014-2015 ForgeRock AS
|
*/
|
|
package org.opends.guitools.controlpanel.ui;
|
|
import static org.opends.messages.AdminToolMessages.*;
|
|
import java.awt.Component;
|
import java.awt.GridBagConstraints;
|
import java.awt.event.ItemEvent;
|
import java.awt.event.ItemListener;
|
import java.io.IOException;
|
import java.io.StringReader;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.SortedSet;
|
import java.util.TreeSet;
|
|
import javax.naming.directory.Attributes;
|
import javax.naming.directory.BasicAttribute;
|
import javax.naming.directory.BasicAttributes;
|
import javax.naming.ldap.InitialLdapContext;
|
import javax.swing.DefaultComboBoxModel;
|
import javax.swing.JCheckBox;
|
import javax.swing.SwingUtilities;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.opendj.ldap.ByteString;
|
import org.opends.guitools.controlpanel.datamodel.BackendDescriptor;
|
import org.opends.guitools.controlpanel.datamodel.CategorizedComboBoxElement;
|
import org.opends.guitools.controlpanel.datamodel.ControlPanelInfo;
|
import org.opends.guitools.controlpanel.datamodel.IndexDescriptor;
|
import org.opends.guitools.controlpanel.datamodel.IndexTypeDescriptor;
|
import org.opends.guitools.controlpanel.datamodel.ServerDescriptor;
|
import org.opends.guitools.controlpanel.event.ConfigurationChangeEvent;
|
import org.opends.guitools.controlpanel.task.OfflineUpdateException;
|
import org.opends.guitools.controlpanel.task.OnlineUpdateException;
|
import org.opends.guitools.controlpanel.task.Task;
|
import org.opends.guitools.controlpanel.util.ConfigReader;
|
import org.opends.guitools.controlpanel.util.Utilities;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.types.Attribute;
|
import org.opends.server.types.AttributeType;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.Entry;
|
import org.opends.server.types.LDIFImportConfig;
|
import org.opends.server.types.OpenDsException;
|
import org.opends.server.types.Schema;
|
import org.opends.server.util.LDIFReader;
|
import org.opends.server.util.ServerConstants;
|
|
import com.forgerock.opendj.cli.CommandBuilder;
|
|
/**
|
* Panel that appears when the user defines a new index.
|
*/
|
public class NewIndexPanel extends AbstractIndexPanel
|
{
|
private static final long serialVersionUID = -3516011638125862137L;
|
|
private Component relativeComponent;
|
|
private Schema schema;
|
|
private IndexDescriptor newIndex;
|
|
/**
|
* Constructor of the panel.
|
* @param backendName the backend where the index will be created.
|
* @param relativeComponent the component relative to which the dialog
|
* containing this panel will be centered.
|
*/
|
public NewIndexPanel(String backendName, Component relativeComponent)
|
{
|
super();
|
this.backendName.setText(backendName);
|
this.relativeComponent = relativeComponent;
|
createLayout();
|
}
|
|
/** {@inheritDoc} */
|
public LocalizableMessage getTitle()
|
{
|
return INFO_CTRL_PANEL_NEW_INDEX_TITLE.get();
|
}
|
|
/** {@inheritDoc} */
|
public Component getPreferredFocusComponent()
|
{
|
return attributes;
|
}
|
|
/**
|
* Updates the contents of the panel with the provided backend.
|
* @param backend the backend where the index will be created.
|
*/
|
public void update(BackendDescriptor backend)
|
{
|
backendName.setText(backend.getBackendID());
|
}
|
|
/** {@inheritDoc} */
|
public void configurationChanged(ConfigurationChangeEvent ev)
|
{
|
final ServerDescriptor desc = ev.getNewDescriptor();
|
|
Schema s = desc.getSchema();
|
final boolean[] repack = {false};
|
final boolean[] error = {false};
|
if (s != null)
|
{
|
schema = s;
|
repack[0] = attributes.getItemCount() == 0;
|
LinkedHashSet<CategorizedComboBoxElement> newElements =
|
new LinkedHashSet<CategorizedComboBoxElement>();
|
|
// Check that the index does not exist
|
BackendDescriptor backend = null;
|
for (BackendDescriptor b : getInfo().getServerDescriptor().getBackends())
|
{
|
if (b.getBackendID().equalsIgnoreCase(backendName.getText()))
|
{
|
backend = b;
|
break;
|
}
|
}
|
|
TreeSet<String> standardAttrNames = new TreeSet<String>();
|
TreeSet<String> configurationAttrNames = new TreeSet<String>();
|
TreeSet<String> customAttrNames = new TreeSet<String>();
|
for (AttributeType attr : schema.getAttributeTypes().values())
|
{
|
String name = attr.getPrimaryName();
|
boolean defined = false;
|
if (backend != null)
|
{
|
for (IndexDescriptor index : backend.getIndexes())
|
{
|
if (index.getName().equalsIgnoreCase(name))
|
{
|
defined = true;
|
break;
|
}
|
}
|
}
|
if (!defined)
|
{
|
if (Utilities.isStandard(attr))
|
{
|
standardAttrNames.add(name);
|
}
|
else if (Utilities.isConfiguration(attr))
|
{
|
configurationAttrNames.add(name);
|
}
|
else
|
{
|
customAttrNames.add(name);
|
}
|
}
|
}
|
if (customAttrNames.size() > 0)
|
{
|
newElements.add(new CategorizedComboBoxElement(
|
CUSTOM_ATTRIBUTES,
|
CategorizedComboBoxElement.Type.CATEGORY));
|
for (String attrName : customAttrNames)
|
{
|
newElements.add(new CategorizedComboBoxElement(
|
attrName,
|
CategorizedComboBoxElement.Type.REGULAR));
|
}
|
}
|
if (standardAttrNames.size() > 0)
|
{
|
newElements.add(new CategorizedComboBoxElement(
|
STANDARD_ATTRIBUTES,
|
CategorizedComboBoxElement.Type.CATEGORY));
|
for (String attrName : standardAttrNames)
|
{
|
newElements.add(new CategorizedComboBoxElement(
|
attrName,
|
CategorizedComboBoxElement.Type.REGULAR));
|
}
|
}
|
// Ignore configuration attr names
|
/*
|
if (configurationAttrNames.size() > 0)
|
{
|
newElements.add(new CategorizedComboBoxDescriptor(
|
"Configuration Attributes",
|
CategorizedComboBoxDescriptor.Type.CATEGORY));
|
for (String attrName : configurationAttrNames)
|
{
|
newElements.add(new CategorizedComboBoxDescriptor(
|
attrName,
|
CategorizedComboBoxDescriptor.Type.REGULAR));
|
}
|
}
|
*/
|
DefaultComboBoxModel model =
|
(DefaultComboBoxModel)attributes.getModel();
|
updateComboBoxModel(newElements, model);
|
}
|
else
|
{
|
updateErrorPane(errorPane,
|
ERR_CTRL_PANEL_SCHEMA_NOT_FOUND_SUMMARY.get(),
|
ColorAndFontConstants.errorTitleFont,
|
ERR_CTRL_PANEL_SCHEMA_NOT_FOUND_DETAILS.get(),
|
ColorAndFontConstants.defaultFont);
|
repack[0] = true;
|
error[0] = true;
|
}
|
|
SwingUtilities.invokeLater(new Runnable()
|
{
|
public void run()
|
{
|
setEnabledOK(!error[0]);
|
errorPane.setVisible(error[0]);
|
if (repack[0])
|
{
|
packParentDialog();
|
if (relativeComponent != null)
|
{
|
Utilities.centerGoldenMean(
|
Utilities.getParentDialog(NewIndexPanel.this),
|
relativeComponent);
|
}
|
}
|
}
|
});
|
if (!error[0])
|
{
|
updateErrorPaneAndOKButtonIfAuthRequired(desc,
|
isLocal() ? INFO_CTRL_PANEL_AUTHENTICATION_REQUIRED_FOR_NEW_INDEX.get() :
|
INFO_CTRL_PANEL_CANNOT_CONNECT_TO_REMOTE_DETAILS.get(desc.getHostname()));
|
}
|
}
|
|
/** {@inheritDoc} */
|
public void okClicked()
|
{
|
setPrimaryValid(lAttribute);
|
setPrimaryValid(lEntryLimit);
|
setPrimaryValid(lType);
|
ArrayList<LocalizableMessage> errors = new ArrayList<LocalizableMessage>();
|
String attrName = getAttributeName();
|
if (attrName == null)
|
{
|
errors.add(ERR_INFO_CTRL_ATTRIBUTE_NAME_REQUIRED.get());
|
setPrimaryInvalid(lAttribute);
|
}
|
|
String v = entryLimit.getText();
|
try
|
{
|
int n = Integer.parseInt(v);
|
if ((n < MIN_ENTRY_LIMIT) || (n > MAX_ENTRY_LIMIT))
|
{
|
errors.add(ERR_INFO_CTRL_PANEL_ENTRY_LIMIT_NOT_VALID.get(
|
MIN_ENTRY_LIMIT, MAX_ENTRY_LIMIT));
|
setPrimaryInvalid(lEntryLimit);
|
}
|
}
|
catch (Throwable t)
|
{
|
errors.add(ERR_INFO_CTRL_PANEL_ENTRY_LIMIT_NOT_VALID.get(
|
MIN_ENTRY_LIMIT, MAX_ENTRY_LIMIT));
|
setPrimaryInvalid(lEntryLimit);
|
}
|
|
boolean somethingSelected = false;
|
for (JCheckBox type : types)
|
{
|
somethingSelected = type.isSelected() && type.isVisible();
|
if (somethingSelected)
|
{
|
break;
|
}
|
}
|
if (!somethingSelected)
|
{
|
errors.add(ERR_INFO_ONE_INDEX_TYPE_MUST_BE_SELECTED.get());
|
setPrimaryInvalid(lType);
|
}
|
ProgressDialog dlg = new ProgressDialog(
|
Utilities.createFrame(),
|
Utilities.getParentDialog(this), INFO_CTRL_PANEL_NEW_INDEX_TITLE.get(),
|
getInfo());
|
NewIndexTask newTask = new NewIndexTask(getInfo(), dlg);
|
for (Task task : getInfo().getTasks())
|
{
|
task.canLaunch(newTask, errors);
|
}
|
if (errors.size() == 0)
|
{
|
launchOperation(newTask,
|
INFO_CTRL_PANEL_CREATING_NEW_INDEX_SUMMARY.get(attrName),
|
INFO_CTRL_PANEL_CREATING_NEW_INDEX_SUCCESSFUL_SUMMARY.get(),
|
INFO_CTRL_PANEL_CREATING_NEW_INDEX_SUCCESSFUL_DETAILS.get(attrName),
|
ERR_CTRL_PANEL_CREATING_NEW_INDEX_ERROR_SUMMARY.get(),
|
ERR_CTRL_PANEL_CREATING_NEW_INDEX_ERROR_DETAILS.get(),
|
null,
|
dlg);
|
dlg.setVisible(true);
|
Utilities.getParentDialog(this).setVisible(false);
|
}
|
else
|
{
|
displayErrorDialog(errors);
|
}
|
}
|
|
|
private String getAttributeName()
|
{
|
CategorizedComboBoxElement o = (CategorizedComboBoxElement) attributes.getSelectedItem();
|
return o != null ? o.getValue().toString() : null;
|
}
|
|
/**
|
* Creates the layout of the panel (but the contents are not populated here).
|
*/
|
private void createLayout()
|
{
|
GridBagConstraints gbc = new GridBagConstraints();
|
|
createBasicLayout(this, gbc, false);
|
|
attributes.addItemListener(new ItemListener()
|
{
|
public void itemStateChanged(ItemEvent ev)
|
{
|
String n = getAttributeName();
|
AttributeType attr = null;
|
if (n != null)
|
{
|
attr = schema.getAttributeType(n.toLowerCase());
|
}
|
repopulateTypesPanel(attr);
|
}
|
});
|
entryLimit.setText(String.valueOf(DEFAULT_ENTRY_LIMIT));
|
}
|
|
/**
|
* The task in charge of creating the index.
|
*
|
*/
|
protected class NewIndexTask extends Task
|
{
|
private Set<String> backendSet;
|
private String attributeName;
|
private int entryLimitValue;
|
private SortedSet<IndexTypeDescriptor> indexTypes;
|
|
/**
|
* The constructor of the task.
|
* @param info the control panel info.
|
* @param dlg the progress dialog that shows the progress of the task.
|
*/
|
public NewIndexTask(ControlPanelInfo info, ProgressDialog dlg)
|
{
|
super(info, dlg);
|
backendSet = new HashSet<String>();
|
backendSet.add(backendName.getText());
|
attributeName = getAttributeName();
|
entryLimitValue = Integer.parseInt(entryLimit.getText());
|
indexTypes = getTypes();
|
}
|
|
/** {@inheritDoc} */
|
public Type getType()
|
{
|
return Type.NEW_INDEX;
|
}
|
|
/** {@inheritDoc} */
|
public Set<String> getBackends()
|
{
|
return backendSet;
|
}
|
|
/** {@inheritDoc} */
|
public LocalizableMessage getTaskDescription()
|
{
|
return INFO_CTRL_PANEL_NEW_INDEX_TASK_DESCRIPTION.get(
|
attributeName, backendName.getText());
|
}
|
|
/** {@inheritDoc} */
|
public boolean canLaunch(Task taskToBeLaunched,
|
Collection<LocalizableMessage> incompatibilityReasons)
|
{
|
boolean canLaunch = true;
|
if (state == State.RUNNING && runningOnSameServer(taskToBeLaunched))
|
{
|
// All the operations are incompatible if they apply to this
|
// backend for safety. This is a short operation so the limitation
|
// has not a lot of impact.
|
Set<String> backends =
|
new TreeSet<String>(taskToBeLaunched.getBackends());
|
backends.retainAll(getBackends());
|
if (backends.size() > 0)
|
{
|
incompatibilityReasons.add(getIncompatibilityMessage(this,
|
taskToBeLaunched));
|
canLaunch = false;
|
}
|
}
|
return canLaunch;
|
}
|
|
private void updateConfiguration() throws OpenDsException
|
{
|
boolean configHandlerUpdated = false;
|
try
|
{
|
if (!isServerRunning())
|
{
|
configHandlerUpdated = true;
|
getInfo().stopPooling();
|
if (getInfo().mustDeregisterConfig())
|
{
|
DirectoryServer.deregisterBaseDN(DN.valueOf("cn=config"));
|
}
|
DirectoryServer.getInstance().initializeConfiguration(
|
org.opends.server.extensions.ConfigFileHandler.class.getName(),
|
ConfigReader.configFile);
|
getInfo().setMustDeregisterConfig(true);
|
}
|
else
|
{
|
SwingUtilities.invokeLater(new Runnable()
|
{
|
/** {@inheritDoc} */
|
public void run()
|
{
|
List<String> args = getObfuscatedCommandLineArguments(
|
getDSConfigCommandLineArguments());
|
args.removeAll(getConfigCommandLineArguments());
|
printEquivalentCommandLine(getConfigCommandLineName(),
|
args, INFO_CTRL_PANEL_EQUIVALENT_CMD_TO_CREATE_INDEX.get());
|
}
|
});
|
}
|
SwingUtilities.invokeLater(new Runnable()
|
{
|
/** {@inheritDoc} */
|
public void run()
|
{
|
getProgressDialog().appendProgressHtml(
|
Utilities.getProgressWithPoints(
|
INFO_CTRL_PANEL_CREATING_NEW_INDEX_PROGRESS.get(
|
attributeName),
|
ColorAndFontConstants.progressFont));
|
}
|
});
|
if (isServerRunning())
|
{
|
// Create additional indexes and display the equivalent command.
|
// Everything is done in the method createAdditionalIndexes
|
createIndex(getInfo().getDirContext());
|
}
|
else
|
{
|
createIndex();
|
}
|
SwingUtilities.invokeLater(new Runnable()
|
{
|
/** {@inheritDoc} */
|
public void run()
|
{
|
getProgressDialog().appendProgressHtml(
|
Utilities.getProgressDone(ColorAndFontConstants.progressFont));
|
}
|
});
|
}
|
finally
|
{
|
if (configHandlerUpdated)
|
{
|
DirectoryServer.getInstance().initializeConfiguration(
|
ConfigReader.configClassName, ConfigReader.configFile);
|
getInfo().startPooling();
|
}
|
}
|
}
|
|
/**
|
* Returns the LDIF representation of the index to be created.
|
* @return the LDIF representation of the index to be created.
|
*/
|
private String getIndexLDIF()
|
{
|
String dn = Utilities.getRDNString(
|
"ds-cfg-backend-id", backendName.getText())+",cn=Backends,cn=config";
|
ArrayList<String> lines = new ArrayList<String>();
|
lines.add("dn: "+Utilities.getRDNString("ds-cfg-attribute",
|
attributeName)+
|
",cn=Index,"+dn);
|
lines.add("objectClass: ds-cfg-local-db-index");
|
lines.add("objectClass: top");
|
lines.add("ds-cfg-attribute: "+attributeName);
|
lines.add("ds-cfg-index-entry-limit: "+entryLimitValue);
|
for (IndexTypeDescriptor type : indexTypes)
|
{
|
lines.add("ds-cfg-index-type: " + type.toLocalDBIndexType());
|
}
|
StringBuilder sb = new StringBuilder();
|
for (String line : lines)
|
{
|
sb.append(line).append(ServerConstants.EOL);
|
}
|
return sb.toString();
|
}
|
|
private void createIndex() throws OpenDsException
|
{
|
LDIFImportConfig ldifImportConfig = null;
|
try
|
{
|
String ldif = getIndexLDIF();
|
|
ldifImportConfig = new LDIFImportConfig(new StringReader(ldif));
|
LDIFReader reader = new LDIFReader(ldifImportConfig);
|
Entry backendConfigEntry;
|
while ((backendConfigEntry = reader.readEntry()) != null)
|
{
|
DirectoryServer.getConfigHandler().addEntry(backendConfigEntry, null);
|
}
|
DirectoryServer.getConfigHandler().writeUpdatedConfig();
|
}
|
catch (IOException ioe)
|
{
|
throw new OfflineUpdateException(
|
ERR_CTRL_PANEL_ERROR_UPDATING_CONFIGURATION.get(ioe), ioe);
|
}
|
finally
|
{
|
if (ldifImportConfig != null)
|
{
|
ldifImportConfig.close();
|
}
|
}
|
}
|
|
private void createIndex(InitialLdapContext ctx) throws OpenDsException
|
{
|
// Instead of adding indexes using management framework, use this approach
|
// so that we have to define the additional indexes only in the method
|
// getBackendLdif.
|
String ldif = getIndexLDIF();
|
LDIFImportConfig ldifImportConfig = null;
|
try
|
{
|
ldifImportConfig = new LDIFImportConfig(new StringReader(ldif));
|
LDIFReader reader = new LDIFReader(ldifImportConfig);
|
Entry indexEntry = reader.readEntry();
|
Attributes attrs = new BasicAttributes();
|
|
BasicAttribute oc = new BasicAttribute("objectClass");
|
Iterator<ByteString> it =
|
indexEntry.getObjectClassAttribute().iterator();
|
while (it.hasNext())
|
{
|
oc.add(it.next().toString());
|
}
|
attrs.put(oc);
|
|
List<Attribute> odsAttrs = indexEntry.getAttributes();
|
for (Attribute odsAttr : odsAttrs)
|
{
|
String attrName = odsAttr.getName();
|
BasicAttribute attr = new BasicAttribute(attrName);
|
it = odsAttr.iterator();
|
while (it.hasNext())
|
{
|
attr.add(it.next().toString());
|
}
|
attrs.put(attr);
|
}
|
|
final StringBuilder sb = new StringBuilder();
|
sb.append(getConfigCommandLineName());
|
Collection<String> args =
|
getObfuscatedCommandLineArguments(getDSConfigCommandLineArguments());
|
for (String arg : args)
|
{
|
sb.append(" ").append(CommandBuilder.escapeValue(arg));
|
}
|
|
ctx.createSubcontext(indexEntry.getName().toString(), attrs);
|
}
|
catch (Throwable t)
|
{
|
throw new OnlineUpdateException(
|
ERR_CTRL_PANEL_ERROR_UPDATING_CONFIGURATION.get(t), t);
|
}
|
finally
|
{
|
if (ldifImportConfig != null)
|
{
|
ldifImportConfig.close();
|
}
|
}
|
}
|
|
/** {@inheritDoc} */
|
protected String getCommandLinePath()
|
{
|
return null;
|
}
|
|
/** {@inheritDoc} */
|
protected ArrayList<String> getCommandLineArguments()
|
{
|
return new ArrayList<String>();
|
}
|
|
private String getConfigCommandLineName()
|
{
|
if (isServerRunning())
|
{
|
return getCommandLinePath("dsconfig");
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
/** {@inheritDoc} */
|
public void runTask()
|
{
|
state = State.RUNNING;
|
lastException = null;
|
|
try
|
{
|
updateConfiguration();
|
for (BackendDescriptor backend :
|
getInfo().getServerDescriptor().getBackends())
|
{
|
if (backend.getBackendID().equalsIgnoreCase(backendName.getText()))
|
{
|
newIndex = new IndexDescriptor(attributeName,
|
schema.getAttributeType(attributeName.toLowerCase()), backend,
|
indexTypes, entryLimitValue);
|
getInfo().registerModifiedIndex(newIndex);
|
notifyConfigurationElementCreated(newIndex);
|
break;
|
}
|
}
|
state = State.FINISHED_SUCCESSFULLY;
|
}
|
catch (Throwable t)
|
{
|
lastException = t;
|
state = State.FINISHED_WITH_ERROR;
|
}
|
}
|
|
/** {@inheritDoc} */
|
public void postOperation()
|
{
|
if ((lastException == null) && (state == State.FINISHED_SUCCESSFULLY) &&
|
(newIndex != null))
|
{
|
rebuildIndexIfNecessary(newIndex, getProgressDialog());
|
}
|
}
|
|
private ArrayList<String> getDSConfigCommandLineArguments()
|
{
|
ArrayList<String> args = new ArrayList<String>();
|
args.add("create-local-db-index");
|
args.add("--backend-name");
|
args.add(backendName.getText());
|
args.add("--type");
|
args.add("generic");
|
|
args.add("--index-name");
|
args.add(attributeName);
|
|
for (IndexTypeDescriptor type : indexTypes)
|
{
|
args.add("--set");
|
args.add("index-type:"+type.toLocalDBIndexType());
|
}
|
args.add("--set");
|
args.add("index-entry-limit:"+entryLimitValue);
|
args.addAll(getConnectionCommandLineArguments());
|
args.add(getNoPropertiesFileArgument());
|
args.add("--no-prompt");
|
return args;
|
}
|
}
|
}
|
