Source code

001/*
002 * The contents of this file are subject to the terms of the Common Development and
003 * Distribution License (the License). You may not use this file except in compliance with the
004 * License.
005 *
006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
007 * specific language governing permission and limitations under the License.
008 *
009 * When distributing Covered Software, include this CDDL Header Notice in each file and include
010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
011 * Header, with the fields enclosed by brackets [] replaced by your own identifying
012 * information: "Portions Copyright [year] [name of copyright owner]".
013 *
014 * Copyright 2008-2010 Sun Microsystems, Inc.
015 * Portions Copyright 2014-2016 ForgeRock AS.
016 */
017package org.opends.guitools.controlpanel.ui;
018
019import static org.opends.messages.AdminToolMessages.*;
020import static org.opends.messages.QuickSetupMessages.*;
021import static com.forgerock.opendj.cli.Utils.OBFUSCATED_VALUE;
022
023import java.awt.Component;
024import java.awt.GridBagConstraints;
025import java.io.File;
026import java.util.ArrayList;
027import java.util.Collection;
028import java.util.HashSet;
029import java.util.LinkedHashSet;
030import java.util.Set;
031import java.util.TreeSet;
032
033import javax.swing.DefaultComboBoxModel;
034import javax.swing.JButton;
035import javax.swing.JCheckBox;
036import javax.swing.JComboBox;
037import javax.swing.JLabel;
038import javax.swing.JTextField;
039import javax.swing.SwingUtilities;
040import javax.swing.event.ChangeEvent;
041import javax.swing.event.ChangeListener;
042import javax.swing.event.DocumentEvent;
043import javax.swing.event.DocumentListener;
044
045import org.opends.admin.ads.util.ConnectionUtils;
046import org.opends.guitools.controlpanel.datamodel.BackendDescriptor;
047import org.opends.guitools.controlpanel.datamodel.BaseDNDescriptor;
048import org.opends.guitools.controlpanel.datamodel.ControlPanelInfo;
049import org.opends.guitools.controlpanel.datamodel.ServerDescriptor;
050import org.opends.guitools.controlpanel.event.BrowseActionListener;
051import org.opends.guitools.controlpanel.event.ConfigurationChangeEvent;
052import org.opends.guitools.controlpanel.task.Task;
053import org.opends.guitools.controlpanel.util.Utilities;
054import org.forgerock.i18n.LocalizableMessage;
055import org.opends.quicksetup.ui.UIFactory;
056import org.opends.quicksetup.util.Utils;
057import org.opends.server.tools.ImportLDIF;
058import org.opends.server.tools.dsreplication.ReplicationCliArgumentParser;
059import org.opends.server.tools.dsreplication.ReplicationCliException;
060import org.opends.server.tools.dsreplication.ReplicationCliMain;
061import org.forgerock.opendj.ldap.DN;
062
063/**
064 * The panel where the user can import the contents of an LDIF file to the
065 * server.
066 */
067public class ImportLDIFPanel extends InclusionExclusionPanel
068{
069  private static final long serialVersionUID = 1143246529610229229L;
070  private JComboBox<String> backends;
071  private JTextField file;
072  private JCheckBox dataCompressed;
073  private JCheckBox rejectNotSchemaCompliant;
074  private JCheckBox doDNValidationAfter;
075  private JCheckBox writeRejects;
076  private JCheckBox writeSkips;
077  private JTextField threads;
078  private JTextField rejectsFile;
079  private JTextField skipsFile;
080  private JCheckBox overwriteRejectsFile;
081  private JCheckBox overwriteSkipsFile;
082  private JButton bBrowse;
083  private JButton rejectsBrowse;
084  private JButton skipsBrowse;
085
086  private JLabel lBackend;
087  private JLabel lNoBackendsFound;
088  private JLabel lFile;
089  private JLabel lSchemaValidation;
090  private JLabel lDNValidation;
091  private JLabel lThreads;
092  private JLabel lRejectsFile;
093  private JLabel lSkipsFile;
094  private JLabel lRemoteFileHelp;
095  private JLabel lRemoteRejectsHelp;
096  private JLabel lRemoteSkipsHelp;
097
098  private DocumentListener documentListener;
099
100  /**
101   * Default constructor.
102   *
103   */
104  public ImportLDIFPanel()
105  {
106    super();
107    createLayout();
108  }
109
110  @Override
111  public LocalizableMessage getTitle()
112  {
113    return INFO_CTRL_PANEL_IMPORT_LDIF_TITLE.get();
114  }
115
116  @Override
117  public Component getPreferredFocusComponent()
118  {
119    return file;
120  }
121
122  @Override
123  public void toBeDisplayed(boolean visible)
124  {
125    if (visible)
126    {
127      documentListener.changedUpdate(null);
128    }
129  }
130
131  /**
132   * Creates the layout of the panel (but the contents are not populated here).
133   */
134  private void createLayout()
135  {
136    GridBagConstraints gbc = new GridBagConstraints();
137    gbc.anchor = GridBagConstraints.WEST;
138    gbc.gridx = 0;
139    gbc.gridy = 0;
140    gbc.gridwidth = 3;
141    addErrorPane(gbc);
142
143    gbc.gridy ++;
144    gbc.weightx = 0.0;
145    gbc.gridwidth = 1;
146    gbc.fill = GridBagConstraints.NONE;
147    lBackend = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_BACKEND_LABEL.get());
148    add(lBackend, gbc);
149    gbc.insets.left = 10;
150    gbc.gridx = 1;
151    backends = Utilities.createComboBox();
152    backends.setModel(new DefaultComboBoxModel<>(new String[]{}));
153    gbc.gridwidth = 2;
154    add(backends, gbc);
155    lNoBackendsFound = Utilities.createDefaultLabel(INFO_CTRL_PANEL_NO_BACKENDS_FOUND_LABEL.get());
156    add(lNoBackendsFound, gbc);
157    lNoBackendsFound.setVisible(false);
158    gbc.insets.top = 10;
159    lBackend.setLabelFor(backends);
160    lNoBackendsFound.setLabelFor(lBackend);
161
162    gbc.gridx = 0;
163    gbc.gridy ++;
164    gbc.insets.left = 0;
165    gbc.gridwidth = 1;
166    lFile = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_FILE_TO_IMPORT_LABEL.get());
167    add(lFile, gbc);
168
169    gbc.gridx = 1;
170    gbc.insets.left = 10;
171    file = Utilities.createTextField();
172    lFile.setLabelFor(file);
173    documentListener = new DocumentListener()
174    {
175      @Override
176      public void changedUpdate(DocumentEvent ev)
177      {
178        String text = file.getText().trim();
179        setEnabledOK(text.length() > 0 && !errorPane.isVisible());
180      }
181
182      @Override
183      public void removeUpdate(DocumentEvent ev)
184      {
185        changedUpdate(ev);
186      }
187
188      @Override
189      public void insertUpdate(DocumentEvent ev)
190      {
191        changedUpdate(ev);
192      }
193    };
194    file.getDocument().addDocumentListener(documentListener);
195    gbc.weightx = 1.0;
196    gbc.fill = GridBagConstraints.HORIZONTAL;
197    add(file, gbc);
198    bBrowse = Utilities.createButton(INFO_CTRL_PANEL_BROWSE_BUTTON_LABEL.get());
199    bBrowse.addActionListener(
200        new BrowseActionListener(file, BrowseActionListener.BrowseType.OPEN_LDIF_FILE,  this));
201    gbc.gridx = 2;
202    gbc.gridwidth = 1;
203    gbc.weightx = 0.0;
204    bBrowse.setOpaque(false);
205    add(bBrowse, gbc);
206
207    lRemoteFileHelp = Utilities.createInlineHelpLabel(INFO_CTRL_PANEL_REMOTE_SERVER_PATH.get());
208    gbc.gridx = 1;
209    gbc.gridwidth = 2;
210    gbc.insets.top = 3;
211    gbc.insets.left = 10;
212    gbc.gridy ++;
213    add(lRemoteFileHelp, gbc);
214    lRemoteFileHelp.setLabelFor(file);
215
216    gbc.gridx = 1;
217    gbc.gridy ++;
218    gbc.insets.left = 30;
219    gbc.insets.top = 5;
220    gbc.gridwidth = 2;
221    dataCompressed = Utilities.createCheckBox(INFO_CTRL_PANEL_DATA_IN_FILE_COMPRESSED.get());
222    dataCompressed.setOpaque(false);
223    add(dataCompressed, gbc);
224
225    gbc.gridx = 0;
226    gbc.gridy ++;
227    gbc.insets.left = 0;
228    gbc.insets.top = 10;
229    gbc.gridwidth = 1;
230    lSchemaValidation = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_SCHEMA_VALIDATION_LABEL.get());
231    add(lSchemaValidation, gbc);
232
233    gbc.gridx = 1;
234    rejectNotSchemaCompliant = Utilities.createCheckBox(INFO_CTRL_PANEL_REJECT_NOT_SCHEMA_COMPLIANT_LABEL.get());
235    rejectNotSchemaCompliant.setSelected(true);
236    gbc.insets.left = 10;
237    add(rejectNotSchemaCompliant, gbc);
238    lSchemaValidation.setLabelFor(rejectNotSchemaCompliant);
239
240    gbc.gridx = 0;
241    gbc.gridy ++;
242    gbc.insets.left = 0;
243    lDNValidation = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_DN_VALIDATION_LABEL.get());
244    add(lDNValidation, gbc);
245
246    gbc.gridx = 1;
247    doDNValidationAfter = Utilities.createCheckBox(INFO_CTRL_PANEL_DO_DN_VALIDATION_LATER_LABEL.get());
248    doDNValidationAfter.setSelected(false);
249    gbc.insets.left = 10;
250    add(doDNValidationAfter, gbc);
251    lDNValidation.setLabelFor(doDNValidationAfter);
252
253    gbc.gridx = 0;
254    gbc.gridy ++;
255    gbc.insets.left = 0;
256    lThreads = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_IMPORT_THREADS_LABEL.get());
257    add(lThreads, gbc);
258
259    gbc.gridx = 1;
260    threads = Utilities.createShortTextField();
261    gbc.gridwidth = 2;
262    gbc.fill = GridBagConstraints.NONE;
263    threads.setToolTipText(INFO_CTRL_PANEL_IMPORT_THREADS_TOOLTIP.get().toString());
264    gbc.insets.left = 10;
265    add(threads, gbc);
266    lThreads.setLabelFor(threads);
267
268    gbc.insets.top = 3;
269    gbc.gridy ++;
270    add(Utilities.createInlineHelpLabel(INFO_CTRL_PANEL_IMPORT_THREADS_HELP.get()), gbc);
271
272    gbc.gridx = 0;
273    gbc.gridy ++;
274    gbc.insets.left = 0;
275    gbc.insets.top = 10;
276    gbc.gridwidth = 1;
277    lRejectsFile = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_REJECTS_FILE_LABEL.get());
278    add(lRejectsFile, gbc);
279
280    gbc.gridx = 1;
281    writeRejects = Utilities.createCheckBox(INFO_CTRL_PANEL_WRITE_REJECTS_FILE_LABEL.get());
282    writeRejects.setSelected(false);
283    gbc.insets.left = 10;
284    add(writeRejects, gbc);
285    lRejectsFile.setLabelFor(writeRejects);
286
287    gbc.gridx = 1;
288    gbc.gridy++;
289    gbc.insets.left = 30;
290    gbc.insets.top = 5;
291    rejectsFile = Utilities.createTextField();
292    gbc.weightx = 1.0;
293    gbc.fill = GridBagConstraints.HORIZONTAL;
294    add(rejectsFile, gbc);
295    rejectsBrowse = Utilities.createButton(INFO_CTRL_PANEL_BROWSE_BUTTON_LABEL.get());
296    rejectsBrowse.addActionListener(
297        new BrowseActionListener(rejectsFile, BrowseActionListener.BrowseType.CREATE_GENERIC_FILE,  this));
298    gbc.gridx = 2;
299    gbc.gridwidth = 1;
300    gbc.weightx = 0.0;
301    gbc.insets.left = 10;
302    rejectsBrowse.setOpaque(false);
303    add(rejectsBrowse, gbc);
304
305    lRemoteRejectsHelp = Utilities.createInlineHelpLabel(INFO_CTRL_PANEL_REMOTE_SERVER_PATH.get());
306    gbc.gridx = 1;
307    gbc.gridwidth = 2;
308    gbc.insets.top = 3;
309    gbc.insets.left = 10;
310    gbc.gridy ++;
311    add(lRemoteRejectsHelp, gbc);
312
313    gbc.gridx = 1;
314    gbc.gridy ++;
315    gbc.insets.left = 30;
316    gbc.gridwidth = 2;
317    overwriteRejectsFile = Utilities.createCheckBox(INFO_CTRL_PANEL_OVERWRITE_REJECTS_FILE_LABEL.get());
318    overwriteRejectsFile.setOpaque(false);
319    add(overwriteRejectsFile, gbc);
320    lRemoteRejectsHelp.setLabelFor(overwriteRejectsFile);
321
322    ChangeListener changeListener = new ChangeListener()
323    {
324      @Override
325      public void stateChanged(ChangeEvent ev)
326      {
327        rejectsFile.setEnabled(writeRejects.isSelected());
328        rejectsBrowse.setEnabled(writeRejects.isSelected());
329        overwriteRejectsFile.setEnabled(writeRejects.isSelected());
330      }
331    };
332    writeRejects.addChangeListener(changeListener);
333    writeRejects.setSelected(false);
334    changeListener.stateChanged(null);
335
336    gbc.gridx = 0;
337    gbc.gridy ++;
338    gbc.insets.left = 0;
339    gbc.insets.top = 10;
340    gbc.gridwidth = 1;
341    lSkipsFile = Utilities.createPrimaryLabel(INFO_CTRL_PANEL_SKIPS_FILE_LABEL.get());
342    add(lSkipsFile, gbc);
343
344    gbc.gridx = 1;
345    writeSkips = Utilities.createCheckBox(INFO_CTRL_PANEL_WRITE_SKIPS_FILE_LABEL.get());
346    writeSkips.setSelected(false);
347    gbc.insets.left = 10;
348    add(writeSkips, gbc);
349    lSkipsFile.setLabelFor(writeSkips);
350
351    gbc.gridx = 1;
352    gbc.gridy++;
353    gbc.insets.left = 30;
354    gbc.insets.top = 5;
355    skipsFile = Utilities.createTextField();
356    gbc.weightx = 1.0;
357    gbc.fill = GridBagConstraints.HORIZONTAL;
358    add(skipsFile, gbc);
359    skipsBrowse = Utilities.createButton(INFO_CTRL_PANEL_BROWSE_BUTTON_LABEL.get());
360    skipsBrowse.addActionListener(
361        new BrowseActionListener(skipsFile, BrowseActionListener.BrowseType.CREATE_GENERIC_FILE,  this));
362    gbc.gridx = 2;
363    gbc.gridwidth = 1;
364    gbc.weightx = 0.0;
365    gbc.insets.left = 10;
366    skipsBrowse.setOpaque(false);
367    add(skipsBrowse, gbc);
368
369    lRemoteSkipsHelp = Utilities.createInlineHelpLabel(INFO_CTRL_PANEL_REMOTE_SERVER_PATH.get());
370    gbc.gridx = 1;
371    gbc.gridwidth = 2;
372    gbc.insets.top = 3;
373    gbc.insets.left = 10;
374    gbc.gridy ++;
375    add(lRemoteSkipsHelp, gbc);
376
377    gbc.gridx = 1;
378    gbc.gridy ++;
379    gbc.insets.left = 30;
380    gbc.gridwidth = 2;
381    overwriteSkipsFile = Utilities.createCheckBox(INFO_CTRL_PANEL_OVERWRITE_SKIPS_FILE_LABEL.get());
382    overwriteSkipsFile.setOpaque(false);
383    add(overwriteSkipsFile, gbc);
384    lRemoteSkipsHelp.setLabelFor(overwriteSkipsFile);
385
386    changeListener = new ChangeListener()
387    {
388      @Override
389      public void stateChanged(ChangeEvent ev)
390      {
391        skipsFile.setEnabled(writeSkips.isSelected());
392        skipsBrowse.setEnabled(writeSkips.isSelected());
393        overwriteSkipsFile.setEnabled(writeSkips.isSelected());
394      }
395    };
396    writeSkips.addChangeListener(changeListener);
397    writeSkips.setSelected(false);
398    changeListener.stateChanged(null);
399
400    changeListener = new ChangeListener()
401    {
402      @Override
403      public void stateChanged(ChangeEvent ev)
404      {
405        if (ev.getSource() == overwriteSkipsFile)
406        {
407          overwriteRejectsFile.setSelected(overwriteSkipsFile.isSelected());
408        }
409        if (ev.getSource() == overwriteRejectsFile)
410        {
411          overwriteSkipsFile.setSelected(overwriteRejectsFile.isSelected());
412        }
413      }
414    };
415    overwriteRejectsFile.addChangeListener(changeListener);
416    overwriteSkipsFile.addChangeListener(changeListener);
417
418    gbc.insets.top = 10;
419    gbc.insets.left = 0;
420    gbc.gridy ++;
421    gbc.gridx = 0;
422    gbc.gridwidth = 3;
423    gbc.fill = GridBagConstraints.HORIZONTAL;
424    add(createDataExclusionOptions(new JLabel[]{}, new Component[]{}), gbc);
425    gbc.gridy ++;
426    gbc.insets.top = 15;
427    add(createDataInclusionOptions(new JLabel[]{}, new Component[]{}), gbc);
428
429    addBottomGlue(gbc);
430  }
431
432  @Override
433  public void configurationChanged(ConfigurationChangeEvent ev)
434  {
435    ServerDescriptor desc = ev.getNewDescriptor();
436    updateSimpleBackendComboBoxModel(backends, lNoBackendsFound, desc);
437    updateErrorPaneAndOKButtonIfAuthRequired(desc,
438      isLocal() ? INFO_CTRL_PANEL_AUTHENTICATION_REQUIRED_FOR_IMPORT.get() :
439      INFO_CTRL_PANEL_CANNOT_CONNECT_TO_REMOTE_DETAILS.get(desc.getHostname()));
440    SwingUtilities.invokeLater(new Runnable()
441    {
442      @Override
443      public void run()
444      {
445        lRemoteFileHelp.setVisible(!isLocal());
446        bBrowse.setVisible(isLocal());
447        rejectsBrowse.setVisible(isLocal());
448        skipsBrowse.setVisible(isLocal());
449        lRemoteRejectsHelp.setVisible(!isLocal());
450        lRemoteSkipsHelp.setVisible(!isLocal());
451      }
452    });
453  }
454
455  @Override
456  protected void checkOKButtonEnable()
457  {
458    documentListener.changedUpdate(null);
459  }
460
461  @Override
462  public void okClicked()
463  {
464    setPrimaryValid(lBackend);
465    setPrimaryValid(lFile);
466    setPrimaryValid(lRejectsFile);
467    setPrimaryValid(lSkipsFile);
468    setPrimaryValid(lThreads);
469    final LinkedHashSet<LocalizableMessage> errors = new LinkedHashSet<>();
470
471    String backendName = (String)backends.getSelectedItem();
472    if (backendName == null)
473    {
474      errors.add(ERR_CTRL_PANEL_NO_BACKEND_SELECTED.get());
475      setPrimaryInvalid(lBackend);
476    }
477
478    String ldifPath = file.getText();
479    if (ldifPath == null || "".equals(ldifPath.trim()))
480    {
481      errors.add(INFO_NO_LDIF_PATH.get());
482      setPrimaryInvalid(lFile);
483    } else if (isLocal() && !Utils.fileExists(ldifPath))
484    {
485      errors.add(INFO_LDIF_FILE_DOES_NOT_EXIST.get());
486      setPrimaryInvalid(lFile);
487    }
488
489    String sThread = threads.getText().trim();
490    if (sThread.length() > 0)
491    {
492      try
493      {
494        int threads = Integer.parseInt(sThread);
495        if (threads < 1)
496        {
497          errors.add(ERR_IMPORT_THREAD_NUMBER_INVALID.get());
498          setPrimaryInvalid(lThreads);
499        }
500      }
501      catch (Throwable t)
502      {
503        errors.add(ERR_IMPORT_THREAD_NUMBER_INVALID.get());
504        setPrimaryInvalid(lThreads);
505      }
506    }
507
508    if (writeRejects.isSelected())
509    {
510      String rejectPath = rejectsFile.getText();
511      if (rejectPath == null || "".equals(rejectPath.trim()))
512      {
513        errors.add(ERR_CTRL_PANEL_REJECTS_FILE_REQUIRED.get());
514        setPrimaryInvalid(lRejectsFile);
515      }
516      else if (writeSkips.isSelected() && new File(rejectPath).equals(new File(skipsFile.getText())))
517      {
518        errors.add(ERR_CTRL_PANEL_REJECTS_AND_SKIPS_MUST_BE_DIFFERENT.get());
519        setPrimaryInvalid(lRejectsFile);
520        setPrimaryInvalid(lSkipsFile);
521      }
522    }
523
524    if (writeSkips.isSelected())
525    {
526      String skipPath = skipsFile.getText();
527      if (skipPath == null || "".equals(skipPath.trim()))
528      {
529        errors.add(ERR_CTRL_PANEL_SKIPS_FILE_REQUIRED.get());
530        setPrimaryInvalid(lSkipsFile);
531      }
532    }
533
534    updateIncludeExclude(errors, backendName);
535
536    if (errors.isEmpty())
537    {
538      ProgressDialog progressDialog = new ProgressDialog(
539          Utilities.createFrame(),
540          Utilities.getParentDialog(this), getTitle(), getInfo());
541      ImportTask newTask = new ImportTask(getInfo(), progressDialog);
542      for (Task task : getInfo().getTasks())
543      {
544        task.canLaunch(newTask, errors);
545      }
546      boolean initializeAll = false;
547      if (errors.isEmpty())
548      {
549        Set<DN> replicatedBaseDNs = getReplicatedBaseDNs();
550        boolean canInitialize = !replicatedBaseDNs.isEmpty() && isServerRunning();
551        if (canInitialize)
552        {
553          ArrayList<String> dns = new ArrayList<>();
554          for (DN dn : replicatedBaseDNs)
555          {
556            dns.add(dn.toString());
557          }
558          initializeAll = displayConfirmationDialog(
559              INFO_CTRL_PANEL_CONFIRMATION_REQUIRED_SUMMARY.get(),
560              INFO_CTRL_PANEL_CONFIRMATION_INITIALIZE_ALL_DETAILS.get(Utilities.getStringFromCollection(dns, "<br>")));
561        }
562
563        newTask.setInitializeAll(initializeAll);
564        launchOperation(newTask,
565            INFO_CTRL_PANEL_IMPORTING_LDIF_SUMMARY.get(backends.getSelectedItem()),
566            INFO_CTRL_PANEL_IMPORTING_LDIF_SUCCESSFUL_SUMMARY.get(),
567            INFO_CTRL_PANEL_IMPORTING_LDIF_SUCCESSFUL_DETAILS.get(),
568            ERR_CTRL_PANEL_IMPORTING_LDIF_ERROR_SUMMARY.get(),
569            null,
570            ERR_CTRL_PANEL_IMPORTING_LDIF_ERROR_DETAILS,
571            progressDialog);
572        progressDialog.setVisible(true);
573        Utilities.getParentDialog(this).setVisible(false);
574      }
575    }
576    if (!errors.isEmpty())
577    {
578      displayErrorDialog(errors);
579    }
580  }
581
582  @Override
583  public void cancelClicked()
584  {
585    setPrimaryValid(lBackend);
586    setPrimaryValid(lFile);
587    setPrimaryValid(lSchemaValidation);
588    setPrimaryValid(lDNValidation);
589    setPrimaryValid(lThreads);
590    setPrimaryValid(lRejectsFile);
591    setPrimaryValid(lSkipsFile);
592    super.cancelClicked();
593  }
594
595  private Set<DN> getReplicatedBaseDNs()
596  {
597    Set<DN> baseDNs = new TreeSet<>();
598    String backendID = (String)backends.getSelectedItem();
599    if (backendID != null)
600    {
601      for (BackendDescriptor backend :
602        getInfo().getServerDescriptor().getBackends())
603      {
604        if (backendID.equalsIgnoreCase(backend.getBackendID()))
605        {
606          for (BaseDNDescriptor baseDN : backend.getBaseDns())
607          {
608            if (baseDN.getReplicaID() != -1)
609            {
610              baseDNs.add(baseDN.getDn());
611            }
612          }
613        }
614      }
615    }
616    return baseDNs;
617  }
618
619  /**
620   * The class that performs the import.
621   *
622   */
623  protected class ImportTask extends InclusionExclusionTask
624  {
625    private Set<String> backendSet;
626    private String fileName;
627    private boolean initializeAll;
628    private Set<DN> replicatedBaseDNs;
629
630    /**
631     * The constructor of the task.
632     * @param info the control panel info.
633     * @param dlg the progress dialog that shows the progress of the task.
634     */
635    public ImportTask(ControlPanelInfo info, ProgressDialog dlg)
636    {
637      super(info, dlg);
638      backendSet = new HashSet<>();
639      backendSet.add((String)backends.getSelectedItem());
640      fileName = file.getText();
641      replicatedBaseDNs = getReplicatedBaseDNs();
642    }
643
644    private void setInitializeAll(boolean initializeAll)
645    {
646      this.initializeAll = initializeAll;
647    }
648
649    @Override
650    public Type getType()
651    {
652      return Type.IMPORT_LDIF;
653    }
654
655    @Override
656    public LocalizableMessage getTaskDescription()
657    {
658      return INFO_CTRL_PANEL_IMPORT_TASK_DESCRIPTION.get(fileName, backendSet.iterator().next());
659    }
660
661    @Override
662    public boolean canLaunch(Task taskToBeLaunched, Collection<LocalizableMessage> incompatibilityReasons)
663    {
664      boolean canLaunch = true;
665      if (state == State.RUNNING && runningOnSameServer(taskToBeLaunched))
666      {
667        // All the operations are incompatible if they apply to this backend.
668        Set<String> backends = new TreeSet<>(taskToBeLaunched.getBackends());
669        backends.retainAll(getBackends());
670        if (!backends.isEmpty())
671        {
672          incompatibilityReasons.add(getIncompatibilityMessage(this, taskToBeLaunched));
673          canLaunch = false;
674        }
675      }
676      return canLaunch;
677    }
678
679    @Override
680    protected ArrayList<String> getCommandLineArguments()
681    {
682      ArrayList<String> args = new ArrayList<>();
683      args.add("--ldifFile");
684      args.add(fileName);
685      args.add("--backendID");
686      args.add((String)backends.getSelectedItem());
687      if (dataCompressed.isSelected())
688      {
689        args.add("--isCompressed");
690      }
691      if (!rejectNotSchemaCompliant.isSelected())
692      {
693        args.add("--skipSchemaValidation");
694      }
695      if (doDNValidationAfter.isSelected())
696      {
697        args.add("--skipDNValidation");
698      }
699
700      String sThread = threads.getText().trim();
701      if (sThread.length() > 0)
702      {
703        args.add("--threadCount");
704        args.add(sThread);
705      }
706
707      if (writeRejects.isSelected())
708      {
709        args.add("--rejectFile");
710        args.add(rejectsFile.getText());
711      }
712
713      if (writeSkips.isSelected())
714      {
715        args.add("--skipFile");
716        args.add(skipsFile.getText());
717      }
718
719      if ((writeRejects.isSelected() || writeSkips.isSelected()) && overwriteRejectsFile.isSelected())
720      {
721        args.add("--overwrite");
722      }
723
724      args.addAll(super.getCommandLineArguments());
725
726      if (isServerRunning())
727      {
728        args.addAll(getConfigCommandLineArguments());
729      }
730
731      args.add(getNoPropertiesFileArgument());
732
733      return args;
734    }
735
736    @Override
737    protected String getCommandLinePath()
738    {
739      return getCommandLinePath("import-ldif");
740    }
741
742    @Override
743    public void runTask()
744    {
745      state = State.RUNNING;
746      lastException = null;
747      try
748      {
749        ArrayList<String> arguments = getCommandLineArguments();
750
751        String[] args = new String[arguments.size()];
752
753        arguments.toArray(args);
754        if (isServerRunning())
755        {
756          returnCode = ImportLDIF.mainImportLDIF(args, false, outPrintStream, errorPrintStream);
757          if (returnCode == 0 && initializeAll)
758          {
759            initializeAll();
760          }
761        }
762        else
763        {
764          returnCode = executeCommandLine(getCommandLinePath(), args);
765        }
766        if (returnCode != 0)
767        {
768          state = State.FINISHED_WITH_ERROR;
769        }
770        else
771        {
772          for (String backend : getBackends())
773          {
774            getInfo().unregisterModifiedIndexesInBackend(backend);
775          }
776          state = State.FINISHED_SUCCESSFULLY;
777        }
778      }
779      catch (Throwable t)
780      {
781        lastException = t;
782        state = State.FINISHED_WITH_ERROR;
783      }
784      HashSet<BackendDescriptor> backends = new HashSet<>();
785      for (BackendDescriptor backend : getInfo().getServerDescriptor().getBackends())
786      {
787        for (String backendID : getBackends())
788        {
789          if (backendID.equalsIgnoreCase(backend.getBackendID()))
790          {
791            backends.add(backend);
792            break;
793          }
794        }
795      }
796      if (!backends.isEmpty())
797      {
798        getInfo().backendPopulated(backends);
799      }
800    }
801
802    @Override
803    public Set<String> getBackends()
804    {
805      return backendSet;
806    }
807
808    private void initializeAll() throws ReplicationCliException
809    {
810      ReplicationCliMain repl = new ReplicationCliMain(outPrintStream, errorPrintStream);
811      getProgressDialog().appendProgressHtml(UIFactory.HTML_SEPARATOR+"<br><br>");
812
813      String cmd = getCommandLineToInitializeAll();
814
815      getProgressDialog().appendProgressHtml(Utilities.applyFont(
816          INFO_CTRL_PANEL_EQUIVALENT_CMD_TO_INITIALIZE_ALL.get()+ "<br><b>"+cmd+"</b><br><br>",
817          ColorAndFontConstants.progressFont));
818
819      for (DN baseDN : replicatedBaseDNs)
820      {
821        LocalizableMessage msg = INFO_PROGRESS_INITIALIZING_SUFFIX.get(baseDN,
822            ConnectionUtils.getHostPort(getInfo().getDirContext()));
823        getProgressDialog().appendProgressHtml(Utilities.applyFont(msg + "<br>", ColorAndFontConstants.progressFont));
824        repl.initializeAllSuffix(baseDN.toString(), getInfo().getDirContext(), true);
825      }
826    }
827
828    private String getCommandLineToInitializeAll()
829    {
830      String cmdLineName = getCommandLinePath("dsreplication");
831      ArrayList<String> args = new ArrayList<>();
832      args.add(ReplicationCliArgumentParser.INITIALIZE_ALL_REPLICATION_SUBCMD_NAME);
833      args.add("--hostName");
834      args.add(getInfo().getServerDescriptor().getHostname());
835      args.add("--port");
836      args.add(String.valueOf(ConnectionUtils.getPort(getInfo().getDirContext())));
837      for (DN baseDN : replicatedBaseDNs)
838      {
839        args.add("--baseDN");
840        args.add(baseDN.toString());
841      }
842      args.add("--adminUID");
843      args.add("admin");
844      args.add("--adminPassword");
845      args.add(OBFUSCATED_VALUE);
846      args.add("--trustAll");
847      args.add("--no-prompt");
848
849      return Task.getEquivalentCommandLine(cmdLineName, args);
850    }
851  }
852}