docs: def salt_minion():
      '''
      Start the salt minion in a subprocess.
      Auto restart minion on error.
      '''
      import signal
  
      import salt.utils.platform
      import salt.utils.process
      salt.utils.process.notify_systemd()
  
      import salt.cli.daemons
      import multiprocessing
      if '' in sys.path:
          sys.path.remove('')
  
      if salt.utils.platform.is_windows():
          minion = salt.cli.daemons.Minion()
          minion.start()
          return
  # REMOVEME after Python 2.7 support is dropped (also the six import)
      elif six.PY2:
          from salt.utils.versions import warn_until
          # Message borrowed from pip's deprecation warning
          warn_until('Sodium',
                     'Python 2.7 will reach the end of its life on January 1st,'
                     ' 2020. Please upgrade your Python as Python 2.7 won\'t be'
                     ' maintained after that date.  Salt will drop support for'
                     ' Python 2.7 in the Sodium release or later.')
  # END REMOVEME
  
      if '--disable-keepalive' in sys.argv:
          sys.argv.remove('--disable-keepalive')
          minion = salt.cli.daemons.Minion()
          minion.start()
          return
  
      def escalate_signal_to_process(pid, signum, sigframe):  # pylint: disable=unused-argument
          '''
          Escalate the signal received to the multiprocessing process that
          is actually running the minion
          '''
          # escalate signal
          os.kill(pid, signum)
  
      # keep one minion subprocess running
      prev_sigint_handler = signal.getsignal(signal.SIGINT)
      prev_sigterm_handler = signal.getsignal(signal.SIGTERM)
      while True:
          try:
              process = multiprocessing.Process(target=minion_process)
              process.start()
              signal.signal(signal.SIGTERM,
                            functools.partial(escalate_signal_to_process,
                                              process.pid))
              signal.signal(signal.SIGINT,
                            functools.partial(escalate_signal_to_process,
                                              process.pid))
              signal.signal(signal.SIGHUP,
                            functools.partial(escalate_signal_to_process,
                                              process.pid))
          except Exception:  # pylint: disable=broad-except
              # if multiprocessing does not work
              minion = salt.cli.daemons.Minion()
              minion.start()
              break
  
          process.join()
  
          # Process exited or was terminated. Since we're going to try to restart
          # it, we MUST, reset signal handling to the previous handlers
          signal.signal(signal.SIGINT, prev_sigint_handler)
          signal.signal(signal.SIGTERM, prev_sigterm_handler)
  
          if not process.exitcode == salt.defaults.exitcodes.SALT_KEEPALIVE:
              sys.exit(process.exitcode)
          # ontop of the random_reauth_delay already preformed
          # delay extra to reduce flooding and free resources
          # NOTE: values are static but should be fine.
          time.sleep(2 + randint(1, 10))
          # need to reset logging because new minion objects
          # cause extra log handlers to accumulate
          rlogger = logging.getLogger()
          for handler in rlogger.handlers:
              rlogger.removeHandler(handler)
          logging.basicConfig()