if self.ldapi_enabled == 'on' and self.ldapi_socket is not None:

              self.ldapi_autobind = args.get(SER_LDAPI_AUTOBIND, 'off')

              self.isLocal = True

          # Settings from args of server attributes

          self.strict_hostname = args.get(SER_STRICT_HOSTNAME_CHECKING, False)

          if self.strict_hostname is True:

          self.agmt = {}

          self.state = DIRSRV_STATE_ALLOCATED

      def clone(self, args_instance={}):

          """

          privconfig_head = os.path.join(os.getenv('HOME'), ENV_LOCAL_DIR)

          if not os.path.isdir(sysconfig_head):

              privconfig_head = None

          # list of the found instances

          instances = []

                  pattern = "%s*" % os.path.join(privconfig_head,

                                                 DEFAULT_ENV_HEAD)

                  found = search_dir(instances, pattern, serverid)

                      for instance in instances:

                  if found:

                      assert len(instances) == 1

                  else:

                  pattern = "%s*" % os.path.join(sysconfig_head,

                                                 DEFAULT_ENV_HEAD)

                  search_dir(instances, pattern, serverid)

                      for instance in instances:

          else:

              # all instances must be retrieved

                  pattern = "%s*" % os.path.join(privconfig_head,

                                                 DEFAULT_ENV_HEAD)

                  search_dir(instances, pattern)

                      for instance in instances:

              pattern = "%s*" % os.path.join(sysconfig_head, DEFAULT_ENV_HEAD)

              search_dir(instances, pattern)

                  for instance in instances:

          return instances

          elif self.can_autobind():

              # Connect via ldapi, and autobind.

              # do nothing: the bind is complete.

              sasl_auth = ldap.sasl.external()

              self.sasl_interactive_bind_s("", sasl_auth)

          """

          Authenticated, now finish the initialization

          """

          if not connOnly:

              self.__initPart2()

          self.state = DIRSRV_STATE_ONLINE

              XXX This cannot return None

          """

          if len(args) == 1 and 'scope' not in kwargs:

              args += (ldap.SCOPE_BASE, )

          if not obj:

              raise NoSuchEntryError("no such entry for %r", [args])

          if isinstance(obj, Entry):

              return obj

          else:  # assume list/tuple

          for ent in (conent, polent, tement, cosent):

              try:

                  self.add_s(ent)

              except ldap.ALREADY_EXISTS:

          self.setPwdPolicy({'nsslapd-pwpolicy-local': 'on'})

          self.setDNPwdPolicy(poldn, pwdpolicy, **pwdargs)

          for ent in (conent, polent):

              try:

                  self.add_s(ent)

              except ldap.ALREADY_EXISTS:

                        "already exists - skipping")

          mod = [(ldap.MOD_REPLACE, 'pwdpolicysubentry', poldn)]

          self.modify_s(user, mod)

          self.dryrun = dryrun

          # Expose the logger to our children.

          self.log = log.getChild('SetupDs')

          # This will indicate that start / stop / status should bypass systemd.

          self.containerised = containerised

          general_options.verify()

          general = general_options.collect()

          slapd_options = Slapd2Base(self.log)

          slapd_options.parse_inf_config(config)

          slapd_options.verify()

          slapd = slapd_options.collect()

          backends = []

          for section in config.sections():

                      # Add this backend to the list

                      backends.append(be)

          return (general, slapd, backends)

          self.log.info("\nStarting installation...")

          # Check we have privs to run

          self._prepare_ds(general, slapd, backends)

          # Call our child api to prepare itself.

          self._prepare(extra)

          if self.dryrun:

              self.log.info("NOOP: Dry run requested")

              # Call the child api to do anything it needs.

              self._install(extra)

              self.log.info("Completed installation for %s", slapd['instance_name'])

      def _install_ds(self, general, slapd, backends):

          # Create all the needed paths

          # we should only need to make bak_dir, cert_dir, config_dir, db_dir, ldif_dir, lock_dir, log_dir, run_dir?

          for path in ('backup_dir', 'cert_dir', 'config_dir', 'db_dir', 'ldif_dir', 'lock_dir', 'log_dir', 'run_dir'):

              try:

                  os.umask(0o007)  # For parent dirs that get created -> sets 770 for perms

                  os.makedirs(slapd[path], mode=0o770)

              ds_suffix = backends[0]['nsslapd-suffix']

          # Create certdb in sysconfidir

          # Create dse.ldif with a temporary root password.

          # The template is in slapd['data_dir']/dirsrv/data/template-dse.ldif

          # Variables are done with %KEY%.

          # You could cheat and read it in, do a replace of % to { and } then use format?

          dse = ""

          with open(os.path.join(slapd['data_dir'], 'dirsrv', 'data', 'template-dse.ldif')) as template_dse:

              for line in template_dse.readlines():

  # --- END COPYRIGHT BLOCK ---

  import subprocess

  """

  This class will allow general usage of ldclt.

              "object=/tmp/ldclt_template_lib389.ldif,rdn=uid:user[A=INCRNNOLOOP(%s;%s;%s)]" % (min, max, digits),

          ]

          result = None

          try:

              result = subprocess.check_output(cmd)

          # If verbose, capture / log the output.

          except subprocess.CalledProcessError as e:

              print(result)

              raise(e)

      def bind_loadtest(self, subtree, min=1000, max=9999, rounds=3):

          # The bind users will be uid=userXXXX

              'bindonly',

          ]

          result = None

          try:

              result = subprocess.check_output(cmd)

          # If verbose, capture / log the output.

          except subprocess.CalledProcessError as e:

              print(result)

              raise(e)

              status = entry.nsds5ReplicaLastInitStatus

              if not refresh:  # done - check status

                  if not status:

                  elif status.find(ensure_bytes("replica busy")) > -1:

                      done = True

                      hasError = 2

                  elif status.find(ensure_bytes("Total update succeeded")) > -1:

                      done = True

                  elif inprogress.lower() == ensure_bytes('true'):

                            status)

                  else:

                      hasError = 1

                      done = True

          return done, hasError