From c393394f8ba7d057b6a252b8844fe05b56e162e4 Mon Sep 17 00:00:00 2001
From: Simon Pichugin <spichugi@redhat.com>
Date: Aug 18 2018 08:58:03 +0000
Subject: Issue 49858 - Add backup/restore and import/export functionality to WebUI/CLI


Description: dsconf tool now has:
'dsconf localhost backup create' and 'dsconf localhost backup restore';
'dsconf localhost backend import' and 'dsconf localhost backend export'.
Add basic tests for the CLI part
Add JS logic for online backup/restore.
Add more HTML and JS for online import/export functionality.
Fix CSS alignment issues. Fix validity checks in CLI.

https://pagure.io/389-ds-base/issue/49858

Reviewed by: mreynolds, wibrown, mhonek (Thanks!)

---

diff --git a/src/cockpit/389-console/backend.html b/src/cockpit/389-console/backend.html
index e4b5b4f..5a96240 100644
--- a/src/cockpit/389-console/backend.html
+++ b/src/cockpit/389-console/backend.html
@@ -850,7 +850,7 @@
   </div>
 
   <div class="modal fade" id="import-ldif-form" data-backdrop="static" tabindex="-1" role="dialog" aria-labelledby="import-label" aria-hidden="true">
-    <div class="modal-dialog ds-modal">
+    <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true" aria-label="Close">
@@ -859,11 +859,32 @@
           <h4 class="modal-title" id="import-label">Initialize Database</h4>
         </div>
         <div class="modal-body">
-          <form class="form-horizontal">
-            <label for="ldif-file" class="" title=
-              "Full path to LDIF file">
-              LDIF File</label><input class="ds-form-input" type="text" id="ldif-file" size="40"/>
-          </form>
+          <div class="ds-inline">
+            <div>
+              <label for="root-suffix-import" class="ds-config-label-lrg" title=
+                      "Suffix where to import">
+                Root Suffix</label><input class="ds-input" type="text" id="root-suffix-import" size="40" disabled/>
+            </div>
+            <div>
+              <label for="ldif-file-import" class="ds-config-label-lrg" title=
+                      "LDIF filename without an extension. LDIF files are written to the server's LDIF directory (nsslapd-ldifdir)">
+                LDIF Filename</label><input class="ds-input" type="text" id="ldif-file-import" size="40"/>
+            </div>
+            <div>
+              <label for="exclude-suffix-import" class="ds-config-label-lrg" title=
+                      "Exclude Suffix (Optional)">
+                Exclude Suffix (Optional)</label><input class="ds-input" type="text" id="exclude-suffix-import" size="40"/>
+            </div>
+            <div>
+              <label for="include-suffix-import" class="ds-config-label-lrg" title=
+                      "Include Suffix (Optional)">
+                Include Suffix (Optional)</label><input class="ds-input" type="text" id="include-suffix-import" size="40"/>
+            </div>
+          </div>
+          <div id="import-ldif-spinner" class="ds-center" hidden>
+            <p></p>
+            <p><span class="spinner spinner-xs spinner-inline"></span> Running LDIF import task...</p>
+          </div>
         </div>
         <div class="modal-footer ds-modal-footer">
           <button type="button" class="btn btn-default" data-dismiss="modal">Cancel</button>
@@ -874,7 +895,7 @@
   </div>
 
   <div class="modal fade" id="export-ldif-form" data-backdrop="static" tabindex="-1" role="dialog" aria-labelledby="export-label" aria-hidden="true">
-    <div class="modal-dialog ds-modal">
+    <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true" aria-label="Close">
@@ -883,10 +904,32 @@
           <h4 class="modal-title" id="export-label">Export Database</h4>
         </div>
         <div class="modal-body">
-          <form class="form-horizontal">
-            <label for="export-ldif-file" class="" title="Full path to LDIF file">
-            LDIF File</label><input class="ds-form-input" type="text" id="export-ldif-file" size="40"/>
-          </form>
+          <div class="ds-inline">
+            <div>
+              <label for="root-suffix-export" class="ds-config-label-lrg" title=
+                      "Suffix where to export">
+                Root Suffix</label><input class="ds-input" type="text" id="root-suffix-export" size="40" disabled/>
+            </div>
+            <div>
+              <label for="ldif-file-export" class="ds-config-label-lrg" title=
+                      "LDIF filename without an extension. LDIF files are written to the server's LDIF directory (nsslapd-ldifdir)">
+                LDIF Filename (Optional)</label><input class="ds-input" type="text" id="ldif-file-export" size="40"/>
+            </div>
+            <div>
+              <label for="exclude-suffix-export" class="ds-config-label-lrg" title=
+                      "Exclude Suffix (Optional)">
+                Exclude Suffix (Optional)</label><input class="ds-input" type="text" id="exclude-suffix-export" size="40"/>
+            </div>
+            <div>
+              <label for="include-suffix-export" class="ds-config-label-lrg" title=
+                      "Include Suffix (Optional)">
+                Include Suffix (Optional)</label><input class="ds-input" type="text" id="include-suffix-export" size="40"/>
+            </div>
+          </div>
+          <div id="export-ldif-spinner" class="ds-center" hidden>
+            <p></p>
+            <p><span class="spinner spinner-xs spinner-inline"></span> Running LDIF export task...</p>
+          </div>
         </div>
         <div class="modal-footer ds-modal-footer">
         <button type="button" class="btn btn-default" data-dismiss="modal">Cancel</button>
diff --git a/src/cockpit/389-console/index.html b/src/cockpit/389-console/index.html
index 3900cb4..d0c3666 100644
--- a/src/cockpit/389-console/index.html
+++ b/src/cockpit/389-console/index.html
@@ -291,7 +291,7 @@
   <!-- Manage Backups/restore -->
   <div class="modal fade" id="restore-form" data-backdrop="static" tabindex="-1" role="dialog" aria-labelledby="restore-label" aria-hidden="true">
     <div class="modal-dialog">
-      <div class="modal-content ds-modal-wide">
+      <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true" aria-label="Close">
             <span class="pficon pficon-close"></span>
@@ -467,7 +467,7 @@
   -->
   <div class="modal fade" id="backup-form" data-backdrop="static" tabindex="-1" role="dialog" aria-labelledby="backup-label" aria-hidden="true">
     <div class="modal-dialog">
-      <div class="modal-content ds-modal">
+      <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true" aria-label="Close">
             <span class="pficon pficon-close"></span>
diff --git a/src/cockpit/389-console/js/backend.js b/src/cockpit/389-console/js/backend.js
index 46da289..54aa64f 100644
--- a/src/cockpit/389-console/js/backend.js
+++ b/src/cockpit/389-console/js/backend.js
@@ -36,6 +36,9 @@ function customMenu (node) {
       "label": "Initialize Suffix",
        "icon": "glyphicon glyphicon-circle-arrow-right",
        "action": function (data) {
+         var suffix_id = $(node).attr('id');
+         var parent_suffix = suffix_id.substring(suffix_id.indexOf('-')+1);
+         $("#root-suffix-import").val(parent_suffix);
          $("#import-ldif-file").val("");
          $("#import-ldif-form").modal('toggle');
        }
@@ -44,6 +47,9 @@ function customMenu (node) {
        "label": "Export Suffix",
        "icon": "glyphicon glyphicon-circle-arrow-left",
        "action": function (data) {
+         var suffix_id = $(node).attr('id');
+         var parent_suffix = suffix_id.substring(suffix_id.indexOf('-')+1);
+         $("#root-suffix-export").val(parent_suffix);
          $("#export-ldif-file").val("");
          $("#export-ldif-form").modal('toggle');
        }
@@ -757,9 +763,42 @@ $(document).ready( function() {
 
     // Init Suffix (import)
     $("#import-ldif-save").on("click", function() {
-      $("#import-ldif-form").css('display', 'none');
-      // Do the actual save in DS
-      // Update html
+      var root_suffix_import = $("#root-suffix-import").val();
+      var ldif_file_import = $("#ldif-file-import").val();
+      var exclude_suffix_import = $("#exclude-suffix-import").val();
+      var include_suffix_import = $("#include-suffix-import").val();
+      var cmd = [DSCONF, server_inst, 'backend', 'import', root_suffix_import];
+      // Process and validate parameters
+      if (ldif_file_import == ""){
+        popup_msg("Error", "LDIF file should be specified");
+        return;
+      } else if (ldif_file_import.indexOf(' ') >= 0) {
+        popup_msg("Error", "LDIF file can not contain any spaces");
+        return;
+      } else if (ldif_file_import.startsWith('/')) {
+        popup_msg("Error", "LDIF file can not start with a forward slash. " +
+                           "LDIF files are written to the server's LDIF directory (nsslapd-ldifdir)");
+        return;
+      } else {
+        cmd.push(ldif_file_import);
+      }
+      if (include_suffix_import != "") {
+        cmd.push.apply(cmd, ["-s", include_suffix_import]);
+      }
+      if (exclude_suffix_import != "") {
+        cmd.push.apply(cmd, ["-x", exclude_suffix_import]);
+      }
+      $("#import-ldif-spinner").show();
+      cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+      done(function(data) {
+        $("#import-ldif-spinner").hide();
+        popup_success("LDIF has been imported");
+        $("#import-ldif-form").modal('toggle');
+      }).
+      fail(function(data) {
+        $("#import-ldif-spinner").hide();
+        popup_err("Error", "Failed to import LDIF\n" + data.message);
+      })
     });
 
     // Export Suffix (import)
@@ -770,9 +809,39 @@ $(document).ready( function() {
       $("#export-ldif-form").css('display', 'none');
     });
     $("#export-ldif-save").on("click", function() {
-      $("#export-ldif-form").css('display', 'none');
-      // Do the actual save in DS
-      // Update html
+      var root_suffix_export = $("#root-suffix-export").val();
+      var ldif_file_export = $("#ldif-file-export").val();
+      var exclude_suffix_export = $("#exclude-suffix-export").val();
+      var include_suffix_export = $("#include-suffix-export").val();
+      var cmd = [DSCONF, server_inst, 'backend', 'export', root_suffix_export];
+      // Process and validate parameters
+      if (ldif_file_export.indexOf(' ') >= 0) {
+        popup_msg("Error", "LDIF file can not contain any spaces");
+        return;
+      } else if (ldif_file_export.startsWith('/')) {
+        popup_msg("Error", "LDIF file can not start with a forward slash. " +
+                           "LDIF files are written to the server's LDIF directory (nsslapd-ldifdir)");
+        return;
+      } else if (ldif_file_export != ""){
+        cmd.push.apply(cmd, ["-l", ldif_file_export]);
+      }
+      if (include_suffix_export != "") {
+        cmd.push.apply(cmd, ["-s", include_suffix_export]);
+      }
+      if (exclude_suffix_export != "") {
+        cmd.push.apply(cmd, ["-x", exclude_suffix_export]);
+      }
+      $("#export-ldif-spinner").show();
+      cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+      done(function(data) {
+        $("#export-ldif-spinner").hide();
+        popup_success("LDIF has been exported");
+        $("#export-ldif-form").modal('toggle');
+      }).
+      fail(function(data) {
+        $("#export-ldif-spinner").hide();
+        popup_err("Error", "Failed to export LDIF\n" + data.message);
+      })
     });
 
     $("#create-ref-save").on("click", function() {
diff --git a/src/cockpit/389-console/js/servers.js b/src/cockpit/389-console/js/servers.js
index cb9f77e..a2bd9e0 100644
--- a/src/cockpit/389-console/js/servers.js
+++ b/src/cockpit/389-console/js/servers.js
@@ -1166,18 +1166,38 @@ $(document).ready( function() {
         return;
       }
       if (backup_name.startsWith('/')) {
-        popup_msg("Error", "Backup name can not start with a forward slash.  Backups are written to the server's backup directory (nsslapd-bakdir)");
+        popup_msg("Error", "Backup name can not start with a forward slash. " +
+                           "Backups are written to the server's backup directory (nsslapd-bakdir)");
         return;
       }
-      var cmd = [DSCTL, server_inst, 'db2bak', backup_name];
+      var cmd = ['status-dirsrv', server_inst];
       $("#backup-spinner").show();
-      cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).done(function(data) {
-        $("#backup-spinner").hide();
-        popup_success("Backup has been created");
-        $("#backup-form").modal('toggle');
-      }).fail(function(data) {
-        $("#backup-spinner").hide();
-        popup_err("Error", "Failed to backup the server\n" + data.message);
+      cockpit.spawn(cmd, { superuser: true}).
+      done(function() {
+        var cmd = [DSCONF, server_inst, 'backup', 'create',  backup_name];
+        cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+        done(function(data) {
+          $("#backup-spinner").hide();
+          popup_success("Backup has been created");
+          $("#backup-form").modal('toggle');
+        }).
+        fail(function(data) {
+          $("#backup-spinner").hide();
+          popup_err("Error", "Failed to backup the server\n" + data.message);
+        })
+      }).
+      fail(function() {
+        var cmd = [DSCTL, server_inst, 'db2bak', backup_name];
+        cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+        done(function(data) {
+          $("#backup-spinner").hide();
+          popup_success("Backup has been created");
+          $("#backup-form").modal('toggle');
+        }).
+        fail(function(data) {
+          $("#backup-spinner").hide();
+          popup_err("Error", "Failed to backup the server\n" + data.message);
+        });
       });
     });
 
@@ -1211,15 +1231,34 @@ $(document).ready( function() {
       var restore_name = data[0];
       popup_confirm("Are you sure you want to restore this backup:  <b>" + restore_name + "<b>", "Confirmation", function (yes) {
         if (yes) {
-          var cmd = [DSCTL, server_inst, 'bak2db', restore_name];
+          var cmd = ['status-dirsrv', server_inst];
           $("#restore-spinner").show();
-          cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).done(function(data) {
-            popup_success("The backup has been restored");
-            $("#restore-spinner").hide();
-            $("#restore-form").modal('toggle');
-          }).fail(function(data) {
-            $("#restore-spinner").hide();
-            popup_err("Error", "Failed to restore from the backup\n" + data.message);
+          cockpit.spawn(cmd, { superuser: true}).
+          done(function() {
+            var cmd = [DSCONF, server_inst, 'backup', 'restore',  restore_name];
+            cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+            done(function(data) {
+              $("#restore-spinner").hide();
+              popup_success("The backup has been restored");
+              $("#restore-form").modal('toggle');
+            }).
+            fail(function(data) {
+              $("#restore-spinner").hide();
+              popup_err("Error", "Failed to restore from the backup\n" + data.message);
+            });
+          }).
+          fail(function() {
+            var cmd = [DSCTL, server_inst, 'bak2db', restore_name];
+            cockpit.spawn(cmd, { superuser: true, "err": "message", "environ": [ENV]}).
+            done(function(data) {
+              $("#restore-spinner").hide();
+              popup_success("The backup has been restored");
+              $("#restore-form").modal('toggle');
+            }).
+            fail(function(data) {
+              $("#restore-spinner").hide();
+              popup_err("Error", "Failed to restore from the backup\n" + data.message);
+            });
           });
         }
       });
diff --git a/src/cockpit/389-console/servers.html b/src/cockpit/389-console/servers.html
index b6bb55a..67fc3d0 100644
--- a/src/cockpit/389-console/servers.html
+++ b/src/cockpit/389-console/servers.html
@@ -1005,7 +1005,7 @@
 
   <!-- Create SASL Mapping -->
   <div class="modal fade" id="sasl-map-form" data-backdrop="static" tabindex="-1" role="dialog" aria-labelledby="sasl-header" aria-hidden="true">
-    <div class="modal-dialog ds-modal-wide">
+    <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true" aria-label="Close">
diff --git a/src/lib389/cli/dsconf b/src/lib389/cli/dsconf
index 500d7aa..ac8af23 100755
--- a/src/lib389/cli/dsconf
+++ b/src/lib389/cli/dsconf
@@ -25,6 +25,7 @@ from lib389.cli_conf import schema as cli_schema
 from lib389.cli_conf import health as cli_health
 from lib389.cli_conf import saslmappings as cli_sasl
 from lib389.cli_conf import pwpolicy as cli_pwpolicy
+from lib389.cli_conf import backup as cli_backup
 from lib389.cli_conf.plugins import memberof as cli_memberof
 from lib389.cli_conf.plugins import usn as cli_usn
 from lib389.cli_conf.plugins import rootdn_ac as cli_rootdn_ac
@@ -77,6 +78,7 @@ cli_referint.create_parser(subparsers)
 cli_automember.create_parser(subparsers)
 cli_sasl.create_parser(subparsers)
 cli_pwpolicy.create_parser(subparsers)
+cli_backup.create_parser(subparsers)
 
 argcomplete.autocomplete(parser)
 
diff --git a/src/lib389/lib389/__init__.py b/src/lib389/lib389/__init__.py
index 6b187f2..b603158 100644
--- a/src/lib389/lib389/__init__.py
+++ b/src/lib389/lib389/__init__.py
@@ -79,9 +79,11 @@ from lib389.utils import (
     update_newhost_with_fqdn,
     formatInfData,
     ensure_bytes,
-    ensure_str)
+    ensure_str,
+    format_cmd_list)
 from lib389.paths import Paths
 from lib389.nss_ssl import NssSsl
+from lib389.tasks import BackupTask, RestoreTask
 
 # mixin
 # from lib389.tools import DirSrvTools
@@ -2879,14 +2881,15 @@ class DirSrv(SimpleLDAPObject, object):
         if not archive_dir:
             self.log.error("bak2db: backup directory missing")
             return False
+        elif not archive_dir.startswith("/"):
+            archive_dir = os.path.join(self.ds_paths.backup_dir, archive_dir)
 
         try:
-            result = subprocess.check_output([
-                prog,
-                'archive2db',
-                '-a', archive_dir,
-                '-D', self.get_config_dir()
-            ], encoding='utf-8')
+            cmd = [prog,
+                   'archive2db',
+                   '-a', archive_dir,
+                   '-D', self.get_config_dir()]
+            result = subprocess.check_output(cmd, encoding='utf-8')
         except subprocess.CalledProcessError as e:
             self.log.debug("Command: %s failed with the return code %s and the error %s",
                            format_cmd_list(cmd), e.returncode, e.output)
@@ -2914,17 +2917,16 @@ class DirSrv(SimpleLDAPObject, object):
         if archive_dir is None:
             # Use the instance name and date/time as the default backup name
             archive_dir = self.get_bak_dir() + "/" + self.serverid + "-" + datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
-        elif archive_dir[0] != "/":
+        elif not archive_dir.startswith("/"):
             # Relative path, append it to the bak directory
-            archive_dir = self.get_bak_dir() + "/" + archive_dir
+            archive_dir = os.path.join(self.ds_paths.backup_dir, archive_dir)
 
         try:
-            result = subprocess.check_output([
-                prog,
-                'db2archive',
-                '-a', archive_dir,
-                '-D', self.get_config_dir()
-            ], encoding='utf-8')
+            cmd = [prog,
+                   'db2archive',
+                   '-a', archive_dir,
+                   '-D', self.get_config_dir()]
+            result = subprocess.check_output(cmd, encoding='utf-8')
         except subprocess.CalledProcessError as e:
             self.log.debug("Command: %s failed with the return code %s and the error %s",
                            format_cmd_list(cmd), e.returncode, e.output)
@@ -3409,3 +3411,39 @@ class DirSrv(SimpleLDAPObject, object):
         for ent in sorted(ents, key=lambda e: len(e.dn), reverse=True):
             self.log.debug("Delete entry children %s", ent.dn)
             self.delete_ext_s(ent.dn, serverctrls=serverctrls, clientctrls=clientctrls)
+
+    def backup_online(self, archive=None, db_type=None):
+        """Creates a backup of the database"""
+
+        if archive is None:
+            # Use the instance name and date/time as the default backup name
+            tnow = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+            archive = os.path.join(self.ds_paths.backup_dir,
+                                   "%s_%s" % (self.serverid, tnow))
+        elif archive[0] != "/":
+            # Relative path, append it to the bak directory
+            archive = os.path.join(self.ds_paths.backup_dir, archive)
+
+        task = BackupTask(self)
+        task_properties = {'nsArchiveDir': archive}
+        if db_type is not None:
+            task_properties['nsDatabaseType'] = db_type
+        task.create(properties=task_properties)
+
+        return task
+
+    def restore_online(self, archive, db_type=None):
+        """Restores a database from a backup"""
+
+        # Relative path, append it to the bak directory
+        if archive[0] != "/":
+            archive = os.path.join(self.ds_paths.backup_dir, archive)
+
+        task = RestoreTask(self)
+        task_properties = {'nsArchiveDir': archive}
+        if db_type is not None:
+            task_properties['nsDatabaseType'] = db_type
+
+        task.create(properties=task_properties)
+
+        return task
diff --git a/src/lib389/lib389/backend.py b/src/lib389/lib389/backend.py
index 80fa403..ff4c22c 100644
--- a/src/lib389/lib389/backend.py
+++ b/src/lib389/lib389/backend.py
@@ -6,6 +6,7 @@
 # See LICENSE for details.
 # --- END COPYRIGHT BLOCK ---
 
+from datetime import datetime
 import ldap
 from lib389._constants import *
 from lib389.properties import *
@@ -21,6 +22,7 @@ from lib389.exceptions import NoSuchEntryError, InvalidArgumentError
 # We need to be a factor to the backend monitor
 from lib389.monitor import MonitorBackend
 from lib389.index import Indexes
+from lib389.tasks import ImportTask, ExportTask
 
 # This is for sample entry creation.
 from lib389.configurations import get_sample_entries
@@ -561,6 +563,24 @@ class Backend(DSLdapObject):
         return indexes
     # Future: add reindex task for this be.
 
+    def import_ldif(self, ldifs, chunk_size=None, encrypted=False, gen_uniq_id=False, only_core=False,
+                    include_suffixes=None, exclude_suffixes=None):
+        """Do an import of the suffix"""
+
+        bs = Backends(self._instance)
+        task = bs.import_ldif(self.rdn, ldifs, chunk_size, encrypted, gen_uniq_id, only_core,
+                              include_suffixes, exclude_suffixes)
+        return task
+
+    def export_ldif(self, ldif=None, use_id2entry=False, encrypted=False, min_base64=False, no_uniq_id=False,
+                    replication=False, not_folded=False, no_seq_num=False, include_suffixes=None, exclude_suffixes=None):
+        """Do an export of the suffix"""
+
+        bs = Backends(self._instance)
+        task = bs.export_ldif(self.rdn, ldif, use_id2entry, encrypted, min_base64, no_uniq_id,
+                              replication, not_folded, no_seq_num, include_suffixes, exclude_suffixes)
+        return task
+
 
 class Backends(DSLdapObjects):
     """DSLdapObjects that represents DN_LDBM base DN
@@ -579,3 +599,75 @@ class Backends(DSLdapObjects):
         self._filterattrs = ['cn', 'nsslapd-suffix', 'nsslapd-directory']
         self._childobject = Backend
         self._basedn = DN_LDBM
+
+    def import_ldif(self, be_name, ldifs, chunk_size=None, encrypted=False, gen_uniq_id=None, only_core=False,
+                    include_suffixes=None, exclude_suffixes=None):
+        """Do an import of the suffix"""
+
+        if not ldifs:
+            self.log.error("import_ldif: LDIF filename is missing")
+            return False
+        ldif_paths = []
+        for ldif in list(ldifs):
+            if not ldif.startswith("/"):
+                ldif = os.path.join(self._instance.ds_paths.ldif_dir, "%s.ldif" % ldif)
+                ldif_paths.append(ldif)
+
+        task = ImportTask(self._instance)
+        task_properties = {'nsInstance': be_name,
+                           'nsFilename': ldif_paths}
+        if include_suffixes is not None:
+            task_properties['nsIncludeSuffix'] = include_suffixes
+        if exclude_suffixes is not None:
+            task_properties['nsExcludeSuffix'] = exclude_suffixes
+        if encrypted:
+            task_properties['nsExportDecrypt'] = 'true'
+        if only_core:
+            task_properties['nsImportIndexAttrs'] = 'false'
+        if chunk_size is not None:
+            task_properties['nsImportChunkSize'] = chunk_size
+        if gen_uniq_id is not None:
+            if gen_uniq_id in ("none", "empty") or gen_uniq_id.startswith("deterministic"):
+                raise ValueError("'gen_uniq_id should be none (no unique ID) |"
+                                 "empty (time-based ID) | deterministic namespace (name-based ID)")
+            task_properties['nsUniqueIdGenerator'] = gen_uniq_id
+
+        task.create(properties=task_properties)
+
+        return task
+
+    def export_ldif(self, be_names, ldif=None, use_id2entry=False, encrypted=False, min_base64=False, no_dump_uniq_id=False,
+                    replication=False, not_folded=False, no_seq_num=False, include_suffixes=None, exclude_suffixes=None):
+        """Do an export of the suffix"""
+
+        task = ExportTask(self._instance)
+        task_properties = {'nsInstance': be_names}
+        if ldif is not None and not ldif.startswith("/"):
+            task_properties['nsFilename'] = os.path.join(self._instance.ds_paths.ldif_dir, "%s.ldif" % ldif)
+        else:
+            tnow = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+            task_properties['nsFilename'] = os.path.join(self._instance.ds_paths.ldif_dir,
+                                                         "%s_%s_%s.ldif" % (self._instance.serverid,
+                                                                            "_".join(be_names), tnow))
+        if include_suffixes is not None:
+            task_properties['nsIncludeSuffix'] = include_suffixes
+        if exclude_suffixes is not None:
+            task_properties['nsExcludeSuffix'] = exclude_suffixes
+        if use_id2entry:
+            task_properties['nsUseId2Entry'] = 'true'
+        if encrypted:
+            task_properties['nsExportDecrypt'] = 'true'
+        if replication:
+            task_properties['nsExportReplica'] = 'true'
+        if min_base64:
+            task_properties['nsMinimalEncoding'] = 'true'
+        if not_folded:
+            task_properties['nsNoWrap'] = 'true'
+        if no_dump_uniq_id:
+            task_properties['nsDumpUniqId'] = 'false'
+        if no_seq_num:
+            task_properties['nsPrintKey'] = 'false'
+
+        task = task.create(properties=task_properties)
+        return task
+
diff --git a/src/lib389/lib389/cli_base/__init__.py b/src/lib389/lib389/cli_base/__init__.py
index 8c7325c..828a1e1 100644
--- a/src/lib389/lib389/cli_base/__init__.py
+++ b/src/lib389/lib389/cli_base/__init__.py
@@ -92,6 +92,8 @@ def _warn(data, msg=None):
 def connect_instance(dsrc_inst, verbose):
     dsargs = dsrc_inst['args']
     if '//' not in dsargs['ldapurl']:
+        # Connecting to the local instance
+        dsargs['server-id'] = dsargs['ldapurl']
         # We have an instance name - generate url from dse.ldif
         ldapurl, certdir = get_ldapurl_from_serverid(dsargs['ldapurl'])
         if ldapurl is not None:
diff --git a/src/lib389/lib389/cli_conf/backend.py b/src/lib389/lib389/cli_conf/backend.py
index dc534fa..6602943 100644
--- a/src/lib389/lib389/cli_conf/backend.py
+++ b/src/lib389/lib389/cli_conf/backend.py
@@ -27,10 +27,25 @@ MANY = Backends
 RDN = 'cn'
 
 
+def _search_backend_dn(inst, be_name):
+    found = False
+    be_insts = MANY(inst).list()
+    for be in be_insts:
+        cn = ensure_str(be.get_attr_val('cn')).lower()
+        suffix = ensure_str(be.get_attr_val('nsslapd-suffix')).lower()
+        del_be_name = be_name.lower()
+        if cn == del_be_name or suffix == del_be_name:
+            dn = be.dn
+            found = True
+            break
+    if found:
+        return dn
+
+
 def backend_list(inst, basedn, log, args):
     if 'suffix' in args:
         result = {"type": "list", "items": []}
-        be_insts = Backends(inst).list()
+        be_insts = MANY(inst).list()
         for be in be_insts:
             if args.json:
                 result['items'].append(ensure_str(be.get_attr_val_utf8_l('nsslapd-suffix')).lower())
@@ -54,22 +69,13 @@ def backend_get_dn(inst, basedn, log, args):
 
 
 def backend_create(inst, basedn, log, args):
-    kwargs = _get_attributes(args, Backend._must_attributes)
+    kwargs = _get_attributes(args, SINGULAR._must_attributes)
     _generic_create(inst, basedn, log.getChild('backend_create'), MANY, kwargs, args)
 
 
 def backend_delete(inst, basedn, log, args, warn=True):
-    found = False
-    be_insts = Backends(inst).list()
-    for be in be_insts:
-        cn = ensure_str(be.get_attr_val('cn')).lower()
-        suffix = ensure_str(be.get_attr_val('nsslapd-suffix')).lower()
-        del_be_name = args.be_name.lower()
-        if cn == del_be_name or suffix == del_be_name:
-            dn = be.dn
-            found = True
-            break
-    if not found:
+    dn = _search_backend_dn(inst, args.be_name)
+    if dn is None:
         raise ValueError("Unable to find a backend with the name: ({})".format(args.be_name))
 
     if warn and args.json is False:
@@ -77,6 +83,53 @@ def backend_delete(inst, basedn, log, args, warn=True):
     _generic_delete(inst, basedn, log.getChild('backend_delete'), SINGULAR, dn, args)
 
 
+def backend_import(inst, basedn, log, args):
+    log = log.getChild('backend_import')
+    dn = _search_backend_dn(inst, args.be_name)
+    if dn is None:
+        raise ValueError("Unable to find a backend with the name: ({})".format(args.be_name))
+
+    mc = SINGULAR(inst, dn)
+    task = mc.import_ldif(ldifs=args.ldifs, chunk_size=args.chunks_size, encrypted=args.encrypted,
+                          gen_uniq_id=args.gen_uniq_id, only_core=args.only_core, include_suffixes=args.include_suffixes,
+                          exclude_suffixes=args.exclude_suffixes)
+    task.wait()
+    result = task.get_exit_code()
+
+    if task.is_complete() and result == 0:
+        log.info("The import task has finished successfully")
+    else:
+        raise ValueError("The import task has failed with the error code: ({})".format(result))
+
+
+def backend_export(inst, basedn, log, args):
+    log = log.getChild('backend_export')
+
+    # If the user gave a root suffix we need to get the backend CN
+    be_cn_names = []
+    if not isinstance(args.be_names, str):
+        for be_name in args.be_names:
+            dn = _search_backend_dn(inst, be_name)
+            if dn is not None:
+                mc = SINGULAR(inst, dn)
+                be_cn_names.append(mc.rdn)
+            else:
+                raise ValueError("Unable to find a backend with the name: ({})".format(args.be_names))
+
+    mc = MANY(inst)
+    task = mc.export_ldif(be_names=be_cn_names, ldif=args.ldif, use_id2entry=args.use_id2entry,
+                          encrypted=args.encrypted, min_base64=args.min_base64, no_dump_uniq_id=args.no_dump_uniq_id,
+                          replication=args.replication, not_folded=args.not_folded, no_seq_num=args.no_seq_num,
+                          include_suffixes=args.include_suffixes, exclude_suffixes=args.exclude_suffixes)
+    task.wait()
+    result = task.get_exit_code()
+
+    if task.is_complete() and result == 0:
+        log.info("The export task has finished successfully")
+    else:
+        raise ValueError("The export task has failed with the error code: ({})".format(result))
+
+
 def create_parser(subparsers):
     backend_parser = subparsers.add_parser('backend', help="Manage database suffixes and backends")
 
@@ -96,10 +149,62 @@ def create_parser(subparsers):
 
     create_parser = subcommands.add_parser('create', help='create')
     create_parser.set_defaults(func=backend_create)
-    populate_attr_arguments(create_parser, Backend._must_attributes)
+    populate_attr_arguments(create_parser, SINGULAR._must_attributes)
 
     delete_parser = subcommands.add_parser('delete', help='deletes the object')
     delete_parser.set_defaults(func=backend_delete)
     delete_parser.add_argument('be_name', help='The backend name or suffix to delete')
 
-
+    import_parser = subcommands.add_parser('import', help="do an online import of the suffix")
+    import_parser.set_defaults(func=backend_import)
+    import_parser.add_argument('be_name', nargs='?',
+                               help='The backend name or the root suffix where to import')
+    import_parser.add_argument('ldifs', nargs='*',
+                               help="Specifies the filename of the input LDIF files."
+                                    "When multiple files are imported, they are imported in the order"
+                                    "they are specified on the command line.")
+    import_parser.add_argument('-c', '--chunks_size', type=int,
+                               help="The number of chunks to have during the import operation.")
+    import_parser.add_argument('-E', '--encrypted', action='store_true',
+                               help="Decrypts encrypted data during export. This option is used only"
+                                    "if database encryption is enabled.")
+    import_parser.add_argument('-g', '--gen_uniq_id',
+                               help="Generate a unique id. Type none for no unique ID to be generated"
+                                    "and deterministic for the generated unique ID to be name-based."
+                                    "By default, a time-based unique ID is generated."
+                                    "When using the deterministic generation to have a name-based unique ID,"
+                                    "it is also possible to specify the namespace for the server to use."
+                                    "namespaceId is a string of characters"
+                                    "in the format 00-xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx.")
+    import_parser.add_argument('-O', '--only_core', action='store_true',
+                               help="Requests that only the core database is created without attribute indexes.")
+    import_parser.add_argument('-s', '--include_suffixes', nargs='+',
+                               help="Specifies the suffixes or the subtrees to be included.")
+    import_parser.add_argument('-x', '--exclude_suffixes', nargs='+',
+                               help="Specifies the suffixes to be excluded.")
+
+    export_parser = subcommands.add_parser('export', help='do an online export of the suffix')
+    export_parser.set_defaults(func=backend_export)
+    export_parser.add_argument('be_names', nargs='+',
+                               help="The backend names or the root suffixes from where to export.")
+    export_parser.add_argument('-l', '--ldif',
+                               help="Gives the filename of the output LDIF file."
+                                    "If more than one are specified, use a space as a separator")
+    export_parser.add_argument('-C', '--use_id2entry', action='store_true', help="Uses only the main database file.")
+    export_parser.add_argument('-E', '--encrypted', action='store_true',
+                               help="""Decrypts encrypted data during export. This option is used only
+                                       if database encryption is enabled.""")
+    export_parser.add_argument('-m', '--min_base64', action='store_true',
+                               help="Sets minimal base-64 encoding.")
+    export_parser.add_argument('-N', '--no_seq_num', action='store_true',
+                               help="Enables you to suppress printing the sequence number.")
+    export_parser.add_argument('-r', '--replication', action='store_true',
+                               help="Exports the information required to initialize a replica when the LDIF is imported")
+    export_parser.add_argument('-u', '--no_dump_uniq_id', action='store_true',
+                               help="Requests that the unique ID is not exported.")
+    export_parser.add_argument('-U', '--not_folded', action='store_true',
+                               help="Requests that the output LDIF is not folded.")
+    export_parser.add_argument('-s', '--include_suffixes', nargs='+',
+                               help="Specifies the suffixes or the subtrees to be included.")
+    export_parser.add_argument('-x', '--exclude_suffixes', nargs='+',
+                               help="Specifies the suffixes to be excluded.")
diff --git a/src/lib389/lib389/cli_conf/backup.py b/src/lib389/lib389/cli_conf/backup.py
new file mode 100644
index 0000000..1e73fba
--- /dev/null
+++ b/src/lib389/lib389/cli_conf/backup.py
@@ -0,0 +1,54 @@
+# --- BEGIN COPYRIGHT BLOCK ---
+# Copyright (C) 2018 Red Hat, Inc.
+# All rights reserved.
+#
+# License: GPL (version 3 or any later version).
+# See LICENSE for details.
+# --- END COPYRIGHT BLOCK ---
+
+
+def backup_create(inst, basedn, log, args):
+    log = log.getChild('backup_create')
+
+    task = inst.backup_online(archive=args.archive, db_type=args.db_type)
+    task.wait()
+    result = task.get_exit_code()
+
+    if task.is_complete() and result == 0:
+        log.info("The backup create task has finished successfully")
+    else:
+        raise ValueError("The backup create task has failed with the error code: ({})".format(result))
+
+
+def backup_restore(inst, basedn, log, args):
+    log = log.getChild('backup_restore')
+
+    task = inst.restore_online(archive=args.archive, db_type=args.db_type)
+    task.wait()
+    result = task.get_exit_code()
+
+    if task.is_complete() and result == 0:
+        log.info("The backup restore task has finished successfully")
+    else:
+        raise ValueError("The backup restore task has failed with the error code: ({})".format(result))
+
+
+def create_parser(subparsers):
+    backup_parser = subparsers.add_parser('backup', help="Manage online backups")
+
+    subcommands = backup_parser.add_subparsers(help="action")
+
+    create_parser = subcommands.add_parser('create', help="Creates a backup of the database")
+    create_parser.set_defaults(func=backup_create)
+    create_parser.add_argument('archive', nargs='?', default=None,
+                               help="The directory where the backup files will be stored."
+                                    "The /var/lib/dirsrv/slapd-instance/bak directory is used by default."
+                                    "The backup file is named according to the year-month-day-hour format.")
+    create_parser.add_argument('-t', '--db-type', default="ldbm database",
+                               help="Database type (default: ldbm database).")
+
+    restore_parser = subcommands.add_parser('restore', help="Restores a database from a backup")
+    restore_parser.set_defaults(func=backup_restore)
+    restore_parser.add_argument('archive', help="The directory of the backup files.")
+    restore_parser.add_argument('-t', '--db-type', default="ldbm database",
+                                help="Database type (default: ldbm database).")
diff --git a/src/lib389/lib389/tasks.py b/src/lib389/lib389/tasks.py
index 3de2404..a068075 100644
--- a/src/lib389/lib389/tasks.py
+++ b/src/lib389/lib389/tasks.py
@@ -235,6 +235,66 @@ class CleanAllRUVTask(Task):
         return abort_task
 
 
+class ImportTask(Task):
+    """Create the import ldif task
+
+    :param instance: The instance
+    :type instance: lib389.DirSrv
+    """
+
+    def __init__(self, instance, dn=None):
+        self.cn = 'import_' + Task._get_task_date()
+        dn = "cn=" + self.cn + ",cn=import," + DN_TASKS
+        self._properties = None
+
+        super(ImportTask, self).__init__(instance, dn)
+
+
+class ExportTask(Task):
+    """Create the export to ldif task
+
+    :param instance: The instance
+    :type instance: lib389.DirSrv
+    """
+
+    def __init__(self, instance, dn=None):
+        self.cn = 'export_' + Task._get_task_date()
+        dn = "cn=" + self.cn + ",cn=export," + DN_TASKS
+        self._properties = None
+
+        super(ExportTask, self).__init__(instance, dn)
+
+
+class BackupTask(Task):
+    """Create the backup DB task
+
+    :param instance: The instance
+    :type instance: lib389.DirSrv
+    """
+
+    def __init__(self, instance, dn=None):
+        self.cn = 'backup_' + Task._get_task_date()
+        dn = "cn=" + self.cn + ",cn=backup," + DN_TASKS
+        self._properties = None
+
+        super(BackupTask, self).__init__(instance, dn)
+
+
+class RestoreTask(Task):
+    """Create the restore DB task
+
+    :param instance: The instance
+    :type instance: lib389.DirSrv
+    """
+
+    def __init__(self, instance, dn=None):
+        self.cn = 'restore_' + Task._get_task_date()
+        dn = "cn=" + self.cn + ",cn=restore," + DN_TASKS
+        self._properties = None
+
+        super(RestoreTask, self).__init__(instance, dn)
+
+
 class Tasks(object):
     proxied_methods = 'search_s getEntry'.split()
 
diff --git a/src/lib389/lib389/tests/cli/conf_backend_test.py b/src/lib389/lib389/tests/cli/conf_backend_test.py
index 3ed55aa..c8ca24b 100644
--- a/src/lib389/lib389/tests/cli/conf_backend_test.py
+++ b/src/lib389/lib389/tests/cli/conf_backend_test.py
@@ -6,18 +6,21 @@
 # See LICENSE for details.
 # --- END COPYRIGHT BLOCK ---
 
+import os
 import pytest
 
-from lib389.cli_conf.backend import backend_list, backend_get, backend_get_dn, backend_create, backend_delete
+from lib389.cli_conf.backend import backend_list, backend_get, backend_get_dn, backend_create, backend_delete, backend_export, backend_import
 
 from lib389.cli_base import LogCapture, FakeArgs
 from lib389.tests.cli import topology
+from lib389.topologies import topology_st
 
 from lib389.utils import ds_is_older
 pytestmark = pytest.mark.skipif(ds_is_older('1.4.0'), reason="Not implemented")
 
+
 # Topology is pulled from __init__.py
-def test_backend_cli(topology):
+def test_basic(topology):
     # 
     args = FakeArgs()
     backend_list(topology.standalone, None, topology.logcap.log, None)
@@ -54,3 +57,44 @@ def test_backend_cli(topology):
     topology.logcap.flush()
     # Done!
 
+
+def test_import_export(topology_st):
+    BE_NAME = 'userRoot'
+    EXCLUDE_SUFFIX = "ou=Groups,dc=example,dc=com"
+    LDIF_PATH = os.path.join(topology_st.standalone.ds_paths.ldif_dir, "test_import_export.ldif")
+    topology_st.logcap = LogCapture()
+    args = FakeArgs()
+    # Export the backend
+    args.be_names = [BE_NAME]
+    args.ldif = LDIF_PATH
+    args.use_id2entry = None
+    args.encrypted = None
+    args.min_base64 = None
+    args.no_dump_uniq_id = None
+    args.replication = None
+    args.not_folded = None
+    args.no_seq_num = None
+    args.include_suffixes = None
+    args.exclude_suffixes = [EXCLUDE_SUFFIX]
+    backend_export(topology_st.standalone, None, topology_st.logcap.log, args)
+    # Assert the right ldif was created
+    os.path.exists(LDIF_PATH)
+    assert os.path.exists(LDIF_PATH)
+    with open(LDIF_PATH, 'r') as ldif:
+        for line in ldif:
+            assert not line.endswith("%s\n" % EXCLUDE_SUFFIX)
+    # Assert the ldif was created
+    os.path.exists(LDIF_PATH)
+    # Import the backend
+    args.be_name = BE_NAME
+    args.ldifs = [LDIF_PATH]
+    args.chunks_size = None
+    args.encrypted = None
+    args.gen_uniq_id = None
+    args.only_core = None
+    args.include_suffixes = None
+    args.exclude_suffixes = None
+    backend_import(topology_st.standalone, None, topology_st.logcap.log, args)
+    # No error has happened! Done!
+    # Clean up
+    os.remove(LDIF_PATH)
diff --git a/src/lib389/lib389/tests/cli/conf_backup_test.py b/src/lib389/lib389/tests/cli/conf_backup_test.py
new file mode 100644
index 0000000..1f339c5
--- /dev/null
+++ b/src/lib389/lib389/tests/cli/conf_backup_test.py
@@ -0,0 +1,31 @@
+import os
+import pytest
+import shutil
+
+from lib389.cli_conf.backup import backup_create, backup_restore
+from lib389.cli_base import LogCapture, FakeArgs
+from lib389.topologies import topology_st
+from lib389.utils import ds_is_older
+pytestmark = pytest.mark.skipif(ds_is_older('1.4.0'), reason="Not implemented")
+
+
+def test_basic(topology_st):
+    BACKUP_DIR = os.path.join(topology_st.standalone.ds_paths.backup_dir, "basic_backup")
+    topology_st.logcap = LogCapture()
+    args = FakeArgs()
+    # Clean the backup dir first
+    if os.path.exists(BACKUP_DIR):
+        shutil.rmtree(BACKUP_DIR)
+    # Create the backup
+    args.archive = BACKUP_DIR
+    args.db_type = None
+    backup_create(topology_st.standalone, None, topology_st.logcap.log, args)
+    assert os.listdir(BACKUP_DIR)
+    # Restore the backup
+    args.archive = topology_st.standalone.ds_paths.backup_dir
+    args.db_type = None
+    backup_restore(topology_st.standalone, None, topology_st.logcap.log, args)
+    # No error has happened! Done!
+    # Clean up
+    if os.path.exists(BACKUP_DIR):
+        shutil.rmtree(BACKUP_DIR)