ldif = '%s/dirsrv/data/Example.ldif' % topology_st.standalone.get_data_dir()

      import_ldif = topology_st.standalone.get_ldif_dir() + "/Example.ldif"

      shutil.copyfile(ldif, import_ldif)

  @pytest.fixture(params=ROOTDSE_DEF_ATTR_LIST)

      dbgen(topology_st.standalone, 50000, import_ldif, DEFAULT_SUFFIX)

      # Online

      # Offline

      topology_st.standalone.stop()

      # Online export

      export_ldif = ldif_dir + '/export.ldif'

      # Offline export

      topology_st.standalone.stop()

      ldif = '%s/dirsrv/data/Example.ldif' % topology_st.standalone.get_data_dir()

      import_ldif = topology_st.standalone.get_ldif_dir() + "/Example.ldif"

      shutil.copyfile(ldif, import_ldif)

      log.info('test_basic_import_export: PASSED')

  from shutil import copy2

  import six

  from ldap.ldapobject import SimpleLDAPObject

  from ldap.cidict import cidict

  from ldap import LDAPError

  # This controls pyldap debug levels

  TRACE_LEVEL = 0

  # My logger

  logger = logging.getLogger(__name__)

      extract the raw data from the entry object to pass in.

      """

      def inner(*args, **kwargs):

          if name == 'result':

              objtype, data = f(*args, **kwargs)

              # data is either a 2-tuple or a list of 2-tuples

          else:

              super(DirSrv, self).__init__(uri, trace_level=TRACE_LEVEL)

          # self.start_tls_s()

      def __add_brookers__(self):

          from lib389.config import Config

          self.set_option(ldap.OPT_X_TLS_NEWCTX, 0)

          if starttls and not uri.startswith('ldaps'):

          if saslmethod and sasltoken is not None:

              # Just pass the sasltoken in!

          elif saslmethod and saslmethod.lower() == 'gssapi':

              """

              Perform kerberos/gssapi authentication

              """

              sasl_auth = ldap.sasl.gssapi("")

          elif saslmethod == 'EXTERNAL':

              # Do nothing.

              sasl_auth = ldap.sasl.external()

          elif saslmethod:

              # Unknown or unsupported method

              self.log.debug('Unsupported SASL method: %s', saslmethod)

              # do nothing: the bind is complete.

              self.log.debug("open(): Using root autobind ...")

              sasl_auth = ldap.sasl.external()

          else:

              """

              Do a simple bind

              """

              try:

              except ldap.SERVER_DOWN as e:

                  # TODO add server info in exception

                  self.log.debug("Cannot connect to %r", uri)

          # check that DirSrv was in DIRSRV_STATE_ONLINE state

          if self.state == DIRSRV_STATE_ONLINE:

              # Don't raise an error. Just move the state and return

          self.state = DIRSRV_STATE_OFFLINE

          return status

      def delete_branch_s(self, basedn, scope, filterstr="(objectclass=*)", serverctrls=None, clientctrls=None):

          for ent in sorted(ents, key=lambda e: len(e.dn), reverse=True):

              self.log.debug("Delete entry children %s", ent.dn)

      def backup_online(self, archive=None, db_type=None):

          """Creates a backup of the database"""

      def __str__(self):

          return self.__unicode__()

          """Get an Entry object

          :returns: Entry object

          """

      def exists(self):

          """Check if the entry exists

          """

          try:

          except ldap.NO_SUCH_OBJECT:

              return False

          :returns: LDIF formatted string

          """

          return e.__repr__()

      def display_attr(self, attr):

              raise ValueError("Invalid state. Cannot get presence on instance that is not ONLINE")

          self._log.debug("%s present(%r) %s" % (self._dn, attr, value))

          values = self.get_attr_vals_bytes(attr)

          self._log.debug("%s contains %s" % (self._dn, values))

              else:

                  value = [ensure_bytes(arg[1])]

              mods.append((ldap.MOD_REPLACE, ensure_str(arg[0]), value))

      # This needs to work on key + val, and key

      def remove(self, key, value):

              value = [ensure_bytes(value)]

          return self._instance.modify_ext_s(self._dn, [(action, key, value)],

      def apply_mods(self, mods):

          """Perform modification operation using several mods at once

              else:

                  # Error too many items

                  raise ValueError('Too many arguments in the mod op')

      @classmethod

      def compare(cls, obj1, obj2):

              raise ValueError("Invalid state. Cannot get properties on instance that is not ONLINE")

          else:

              # retrieving real(*) and operational attributes(+)

              # getting dict from 'entry' object

              attrs_dict = attrs_entry.data

              return attrs_dict

          if self._instance.state != DIRSRV_STATE_ONLINE:

              raise ValueError("Invalid state. Cannot get properties on instance that is not ONLINE")

          else:

              return entry.getValuesSet(keys)

      def get_attrs_vals_utf8(self, keys, use_json=False):

          self._log.debug("%s get_attrs_vals_utf8(%r)" % (self._dn, keys))

          if self._instance.state != DIRSRV_STATE_ONLINE:

              raise ValueError("Invalid state. Cannot get properties on instance that is not ONLINE")

          vset = entry.getValuesSet(keys)

          r = {}

          for (k, vo) in vset.items():

          else:

              # It would be good to prevent the entry code intercepting this ....

              # We have to do this in this method, because else we ignore the scope base.

              vals = entry.getValues(key)

              if use_json:

                  result = {key: []}

              # In the future, I plan to add a mode where if local == true, we

              # can use get on dse.ldif to get values offline.

          else:

              return entry.getValue(key)

      def get_attr_val_bytes(self, key, use_json=False):

          # and the superior as the base (if it changed)

          if self._protected:

              return

          search_base = self._basedn

          if newsuperior != None:

              # Well, the new DN should be rdn + newsuperior.

          self._log.debug("%s delete" % (self._dn))

          if not self._protected:

              # Is there a way to mark this as offline and kill it

      def _validate(self, rdn, properties, basedn):

          """Used to validate a create request.

          exists = False

          try:

              exists = True

          except ldap.NO_SUCH_OBJECT:

              pass

              mods = []

              for k, v in list(valid_props.items()):

                  mods.append((ldap.MOD_REPLACE, k, v))

          elif exists and not ensure:

              # raise "already exists."

              raise ldap.ALREADY_EXISTS("Entry %s already exists" % dn)

              e.update(valid_props)

              # We rely on exceptions here to indicate failure to the parent.

              self._log.debug('Creating entry %s : %s' % (dn, e))

              # If it worked, we need to fix our instance dn

              self._dn = dn

          return self

                  scope=self._scope,

                  filterstr=filterstr,

                  attrlist=self._list_attrlist,

              )

              # def __init__(self, instance, dn=None):

              insts = [self._entry_to_instance(dn=r.dn, entry=r) for r in results]

              scope=ldap.SCOPE_BASE,

              filterstr=filterstr,

              attrlist=self._list_attrlist,

          )

      def _get_selector(self, selector):

              scope=self._scope,

              filterstr=filterstr,

              attrlist=self._list_attrlist,

          )

      def _validate(self, rdn, properties):

          :param password: An entry password

          :type password: str

          """

      def sasl_bind(self, *args, **kwargs):

          """Open a new connection and bind with the entry via SASL.

          # Please see _mapped_object.py and DSLdapObject for why this is structured

          # in this way re-controls.

          self._instance.passwd_s(self._dn, current_password, new_password,

  class Accounts(DSLdapObjects):

      """DSLdapObjects that represents Account entry

          self._protected = False

          self._exit_code = None

      def is_complete(self):

          """Return True if task is complete, else False."""

              return True

          return False

      def __init__(self, instance, dn=None):

          self.cn = 'import_' + Task._get_task_date()

          self._properties = None

          super(ImportTask, self).__init__(instance, dn)

  class ExportTask(Task):

      """Create the export to ldif task

      def __init__(self, instance, dn=None):

          self.cn = 'export_' + Task._get_task_date()

          self._properties = None

          super(ExportTask, self).__init__(instance, dn)

  class BackupTask(Task):

      """Create the backup DB task

          # We need to always add this filter, else we won't see the ts

          self._object_filter = '(&(objectclass=nsTombStone)({}))'.format(self._entry_rdn)

          """Get an Entry object

          :returns: Entry object