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