self.confdir = None

          # Set the default systemd status. This MAY be overidden in the setup utils

          # as required.

          # Reset the args (py.test reuses the args_instance for each test case)

          # We allocate a "default" prefix here which allows an un-allocate or

          # self.ds_paths.prefix = args_instance[SER_DEPLOYED_DIR]

          self.__wrapmethods()

      def __str__(self):

          """XXX and in SSL case?"""

          # The lack of this value basically rules it out in most cases

          self.isLocal = True

          self.serverid = serverid

          # Do we have ldapi settings?

          self.log.debug('SER_SERVERID_PROP not provided, assuming non-local instance')

          # The lack of this value basically rules it out in most cases

          self.isLocal = False

          # Do we have ldapi settings?

          # Do we really need .strip() on this?

              raise ValueError("invalid state for calling allocate: %s" %

                               self.state)

          if SER_SERVERID_PROP not in args:

              self.log.debug('SER_SERVERID_PROP not provided, assuming non-local instance')

              # The lack of this value basically rules it out in most cases

          else:

              # Settings from args of server attributes

              self.serverid = args.get(SER_SERVERID_PROP, None)

              # Probably local?

          Authenticated, now finish the initialization

          """

          self.log.debug("open(): bound as %s", self.binddn)

              self.__initPart2()

          self.state = DIRSRV_STATE_ONLINE

      def close(self):

          '''

          return self.ds_paths.asan_enabled

      def with_systemd(self):

      def get_server_tls_subject(self):

          """ Get the servers TLS subject line for enrollment purposes.

      :type dn: str

      """

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

              raise Exception("Not supported")

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

          self._rdn_attribute = RDN

              'inetOrgPerson',

              'organizationalPerson',

          ]

              self._create_objectclasses.append('inetUser')

          else:

              self._create_objectclasses.append('nsMemberOf')

              self._create_objectclasses.append('nsAccount')

          user_compare_exclude = [

              'nsUniqueId', 

          # Should I move this import? I think this prevents some recursion

          from lib389 import DirSrv

          ds_instance = DirSrv(self.verbose)

          args = {

              SER_PORT: slapd['port'],

              SER_SERVERID_PROP: slapd['instance_name'],

              'dbcacheroevict',

              'dbcacherwevict',

          ]

              self._backend_keys.extend([

                  'normalizeddncachetries',

                  'normalizeddncachehits',

      'access_log' : ('cn=config', 'nsslapd-accesslog'),

      'audit_log' : ('cn=config', 'nsslapd-auditlog'),

      'ldapi': ('cn=config', 'nsslapd-ldapifilepath'),

  }

  SECTION = 'slapd'

  class Paths(object):

          """

          Parses and uses a set of default paths from wellknown locations. The list

          of keys available is from the MUST attribute in this module.

          self._config = None

          self._serverid = serverid

          self._instance = instance

      def _get_defaults_loc(self, search_paths):

          ## THIS IS HOW WE HANDLE A PREFIX INSTALL

      def __getattr__(self, name):

          from lib389.utils import ensure_str

              self._read_defaults()

              self._validate_defaults()

          # Are we online? Is our key in the config map?

              ent = self._instance.getEntry(dn, attrlist=[attr,])

              # If the server doesn't have it, fall back to our configuration.

              if attr is not None:

          if self._serverid is not None:

              return ensure_str(self._config.get(SECTION, name).format(instance_name=self._serverid))

          else:

      @property

      def asan_enabled(self):

              self._read_defaults()

              self._validate_defaults()

          if self._config.has_option(SECTION, 'asan_enabled'):

      @property

      def with_systemd(self):

              self._read_defaults()

              self._validate_defaults()

          if self._is_container:

      @property

      def perl_enabled(self):

              self._read_defaults()

              self._validate_defaults()

          if self._config.has_option(SECTION, 'enable_perl'):

      return instance_data

      """

      Return version of ns-slapd installed on this system. This is determined by the defaults.inf

      file, so is correct for the built and installed ns-slapd binary. This function works without

      returns a string of the form: 1.3.4.8

      """

      """

      Return a result of a comparison between the current version of ns-slapd and a provided version.

      """

      ops = {'older': operator.lt,

             'newer': operator.ge}

      if len(ver) > 1:

          for cmp_ver in ver:

              if cmp_ver.startswith(ds_ver[:3]):

          return ops[relation](LegacyVersion(ds_ver), LegacyVersion(ver[0]))

      """

      Return True if the current version of ns-slapd is older than a provided version

      """

      """

      Return True if the current version of ns-slapd is newer than a provided version

      """

  def gentime_to_datetime(gentime):