docs: def publish(self, clear_load):
          '''
          This method sends out publications to the minions, it can only be used
          by the LocalClient.
          '''
          extra = clear_load.get('kwargs', {})
  
          publisher_acl = salt.acl.PublisherACL(self.opts['publisher_acl_blacklist'])
  
          if publisher_acl.user_is_blacklisted(clear_load['user']) or \
                  publisher_acl.cmd_is_blacklisted(clear_load['fun']):
              log.error(
                  '%s does not have permissions to run %s. Please contact '
                  'your local administrator if you believe this is in '
                  'error.\n', clear_load['user'], clear_load['fun']
              )
              return {'error': {'name': 'AuthorizationError',
                                'message': 'Authorization error occurred.'}}
  
          # Retrieve the minions list
          delimiter = clear_load.get('kwargs', {}).get('delimiter', DEFAULT_TARGET_DELIM)
          _res = self.ckminions.check_minions(
              clear_load['tgt'],
              clear_load.get('tgt_type', 'glob'),
              delimiter
          )
          minions = _res.get('minions', list())
          missing = _res.get('missing', list())
          ssh_minions = _res.get('ssh_minions', False)
  
          # Check for external auth calls and authenticate
          auth_type, err_name, key, sensitive_load_keys = self._prep_auth_info(extra)
          if auth_type == 'user':
              auth_check = self.loadauth.check_authentication(clear_load, auth_type, key=key)
          else:
              auth_check = self.loadauth.check_authentication(extra, auth_type)
  
          # Setup authorization list variable and error information
          auth_list = auth_check.get('auth_list', [])
          err_msg = 'Authentication failure of type "{0}" occurred.'.format(auth_type)
  
          if auth_check.get('error'):
              # Authentication error occurred: do not continue.
              log.warning(err_msg)
              return {'error': {'name': 'AuthenticationError',
                                'message': 'Authentication error occurred.'}}
  
          # All Token, Eauth, and non-root users must pass the authorization check
          if auth_type != 'user' or (auth_type == 'user' and auth_list):
              # Authorize the request
              authorized = self.ckminions.auth_check(
                  auth_list,
                  clear_load['fun'],
                  clear_load['arg'],
                  clear_load['tgt'],
                  clear_load.get('tgt_type', 'glob'),
                  minions=minions,
                  # always accept find_job
                  whitelist=['saltutil.find_job'],
              )
  
              if not authorized:
                  # Authorization error occurred. Do not continue.
                  if auth_type == 'eauth' and not auth_list and 'username' in extra and 'eauth' in extra:
                      log.debug('Auth configuration for eauth "%s" and user "%s" is empty', extra['eauth'], extra['username'])
                  log.warning(err_msg)
                  return {'error': {'name': 'AuthorizationError',
                                    'message': 'Authorization error occurred.'}}
  
              # Perform some specific auth_type tasks after the authorization check
              if auth_type == 'token':
                  username = auth_check.get('username')
                  clear_load['user'] = username
                  log.debug('Minion tokenized user = "%s"', username)
              elif auth_type == 'eauth':
                  # The username we are attempting to auth with
                  clear_load['user'] = self.loadauth.load_name(extra)
  
          # If we order masters (via a syndic), don't short circuit if no minions
          # are found
          if not self.opts.get('order_masters'):
              # Check for no minions
              if not minions:
                  return {
                      'enc': 'clear',
                      'load': {
                          'jid': None,
                          'minions': minions,
                          'error': 'Master could not resolve minions for target {0}'.format(clear_load['tgt'])
                      }
                  }
          if extra.get('batch', None):
              return self.publish_batch(clear_load, extra, minions, missing)
  
          jid = self._prep_jid(clear_load, extra)
          if jid is None:
              return {'enc': 'clear',
                      'load': {'error': 'Master failed to assign jid'}}
          payload = self._prep_pub(minions, jid, clear_load, extra, missing)
  
          # Send it!
          self._send_ssh_pub(payload, ssh_minions=ssh_minions)
          self._send_pub(payload)
  
          return {
              'enc': 'clear',
              'load': {
                  'jid': clear_load['jid'],
                  'minions': minions,
                  'missing': missing
              }
          }