docs: def __bind(self):
          '''
          Binds the reply server
          '''
          if self.log_queue is not None:
              salt.log.setup.set_multiprocessing_logging_queue(self.log_queue)
          if self.log_queue_level is not None:
              salt.log.setup.set_multiprocessing_logging_level(self.log_queue_level)
          salt.log.setup.setup_multiprocessing_logging(self.log_queue)
          if self.secrets is not None:
              SMaster.secrets = self.secrets
  
          dfn = os.path.join(self.opts['cachedir'], '.dfn')
          if os.path.isfile(dfn):
              try:
                  if salt.utils.platform.is_windows() and not os.access(dfn, os.W_OK):
                      # Cannot delete read-only files on Windows.
                      os.chmod(dfn, stat.S_IRUSR | stat.S_IWUSR)
                  os.remove(dfn)
              except os.error:
                  pass
  
          # Wait for kill should be less then parent's ProcessManager.
          self.process_manager = salt.utils.process.ProcessManager(name='ReqServer_ProcessManager',
                                                                   wait_for_kill=1)
  
          req_channels = []
          tcp_only = True
          for transport, opts in iter_transport_opts(self.opts):
              chan = salt.transport.server.ReqServerChannel.factory(opts)
              chan.pre_fork(self.process_manager)
              req_channels.append(chan)
              if transport != 'tcp':
                  tcp_only = False
  
          kwargs = {}
          if salt.utils.platform.is_windows():
              kwargs['log_queue'] = self.log_queue
              kwargs['log_queue_level'] = self.log_queue_level
              # Use one worker thread if only the TCP transport is set up on
              # Windows and we are using Python 2. There is load balancer
              # support on Windows for the TCP transport when using Python 3.
              if tcp_only and six.PY2 and int(self.opts['worker_threads']) != 1:
                  log.warning('TCP transport supports only 1 worker on Windows '
                              'when using Python 2.')
                  self.opts['worker_threads'] = 1
  
          # Reset signals to default ones before adding processes to the process
          # manager. We don't want the processes being started to inherit those
          # signal handlers
          with salt.utils.process.default_signals(signal.SIGINT, signal.SIGTERM):
              for ind in range(int(self.opts['worker_threads'])):
                  name = 'MWorker-{0}'.format(ind)
                  self.process_manager.add_process(MWorker,
                                                   args=(self.opts,
                                                         self.master_key,
                                                         self.key,
                                                         req_channels,
                                                         name),
                                                   kwargs=kwargs,
                                                   name=name)
          self.process_manager.run()