# Set the userup correctly.

  # USER dirsrv

  CMD [ "/usr/sbin/dscontainer", "-r" ]

  import pwd

  import atexit

  import os

  import signal

  import sys

  import subprocess

  from lib389.paths import Paths

  from lib389._constants import DSRC_CONTAINER

  # We setup the logger in verbose mode to make sure debug info

  # is always available!

  log = setup_script_logger("container-init", True)

  # We take *args and **kwargs here to handle the fact that this signal gets args, but

  # we don't need or care about them.

  def _sigchild_handler(*args, **kwargs):

      os.waitpid(-1, os.WNOHANG)

  def begin_magic():

      log.info("The 389 Directory Server Container Bootstrap")

      # Leave this comment here: UofA let me take this code with me provided

              """)

          os.chmod(DSRC_CONTAINER, 0o755)

      # Yep! Run it ...

      # Now unlike a normal lib389 start, we use subprocess and don't fork!

      # TODO: Should we pass in a loglevel from env?

      log.info("Starting 389-ds-container ...")

      global ds_proc

      ds_proc = subprocess.Popen([

          "%s/ns-slapd" % paths.sbin_dir,

          "-D", paths.config_dir,

          # See /ldap/servers/slapd/slap.h SLAPD_DEFAULT_ERRORLOG_LEVEL

          "-d", "266354688",

          ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

      def kill_ds():

          if ds_proc is None:

              pass

                  # It's already gone ...

                  pass

          log.info("STOPPING: Shutting down 389-ds-container ...")

          ds_proc.wait()

      atexit.register(kill_ds)

      try:

          ds_proc.wait()

      except KeyboardInterrupt:

          pass

      # THE LETTER OF THE DAY IS C AND THE NUMBER IS 10

  if __name__ == '__main__':

      # Before all else, we are INIT so setup sigchild

      signal.signal(signal.SIGCHLD, _sigchild_handler)

      parser.add_argument('-r', '--runit',

                          help="Actually run the instance! You understand what that means ...",

                          action='store_true', default=False, dest='runit')

      argcomplete.autocomplete(parser)

      args = parser.parse_args()

      if args.runit:

          begin_magic()

          self.state = DIRSRV_STATE_ALLOCATED

          self.log.debug("Allocate local instance %s with %s", self.__class__, self.ldapuri)

      def remote_simple_allocate(self, ldapuri, binddn='cn=Directory Manager', password=None):

          """Allocate an instance, and perform a simple bind. This instance is remote, so

          local tasks will not operate.

                                    "dirsrv@%s" % self.serverid])

              if rc == 0:

                  return True

                  # self.state = DIRSRV_STATE_RUNNING

              self.state = DIRSRV_STATE_OFFLINE

              return False

          else:

              self.log.debug("systemd status -> False")

              pid = pid_from_file(self.ds_paths.pid_file)

              if pid is None:

                  self.log.debug("No pidfile found for %s", self.serverid)

                  # No pidfile yet ...

          if self.ldapuri:

              return self.ldapuri

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

          elif self.sslport and not self.realm:

              # Gssapi can't use SSL so we have to nuke it here.

              return "ldaps://%s:%d/" % (ensure_str(self.host), self.sslport)

  import sys

  import os

  MAJOR, MINOR, _, _, _ = sys.version_info

          to know about paths, shouldn't need to have a copy of 389-ds-base

          installed to remotely admin a server.

          """

          self._defaults_cached = False

          self._config = None

          self._serverid = serverid

          spath = self._get_defaults_loc(DEFAULTS_PATH)

          self._config = configparser.ConfigParser()

          self._config.read([spath])

          self._defaults_cached = True

      def _validate_defaults(self):

          if self._defaults_cached is False:

              self._read_defaults()

              self._validate_defaults()

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

              if self._config.get(SECTION, 'with_systemd') == '1':

                  return True