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