docs: def _prep_pub(self, minions, jid, clear_load, extra, missing):
          '''
          Take a given load and perform the necessary steps
          to prepare a publication.
  
          TODO: This is really only bound by temporal cohesion
          and thus should be refactored even further.
          '''
          clear_load['jid'] = jid
          delimiter = clear_load.get('kwargs', {}).get('delimiter', DEFAULT_TARGET_DELIM)
  
          # TODO Error reporting over the master event bus
          self.event.fire_event({'minions': minions}, clear_load['jid'])
          new_job_load = {
              'jid': clear_load['jid'],
              'tgt_type': clear_load['tgt_type'],
              'tgt': clear_load['tgt'],
              'user': clear_load['user'],
              'fun': clear_load['fun'],
              'arg': clear_load['arg'],
              'minions': minions,
              'missing': missing,
              }
  
          # Announce the job on the event bus
          self.event.fire_event(new_job_load, tagify([clear_load['jid'], 'new'], 'job'))
  
          if self.opts['ext_job_cache']:
              fstr = '{0}.save_load'.format(self.opts['ext_job_cache'])
              save_load_func = True
  
              # Get the returner's save_load arg_spec.
              try:
                  arg_spec = salt.utils.args.get_function_argspec(self.mminion.returners[fstr])
  
                  # Check if 'minions' is included in returner's save_load arg_spec.
                  # This may be missing in custom returners, which we should warn about.
                  if 'minions' not in arg_spec.args:
                      log.critical(
                          'The specified returner used for the external job cache '
                          '\'%s\' does not have a \'minions\' kwarg in the returner\'s '
                          'save_load function.', self.opts['ext_job_cache']
                      )
              except (AttributeError, KeyError):
                  save_load_func = False
                  log.critical(
                      'The specified returner used for the external job cache '
                      '"%s" does not have a save_load function!',
                      self.opts['ext_job_cache']
                  )
  
              if save_load_func:
                  try:
                      self.mminion.returners[fstr](clear_load['jid'], clear_load, minions=minions)
                  except Exception:
                      log.critical(
                          'The specified returner threw a stack trace:\n',
                          exc_info=True
                      )
  
          # always write out to the master job caches
          try:
              fstr = '{0}.save_load'.format(self.opts['master_job_cache'])
              self.mminion.returners[fstr](clear_load['jid'], clear_load, minions)
          except KeyError:
              log.critical(
                  'The specified returner used for the master job cache '
                  '"%s" does not have a save_load function!',
                  self.opts['master_job_cache']
              )
          except Exception:
              log.critical(
                  'The specified returner threw a stack trace:\n',
                  exc_info=True
              )
          # Set up the payload
          payload = {'enc': 'aes'}
          # Altering the contents of the publish load is serious!! Changes here
          # break compatibility with minion/master versions and even tiny
          # additions can have serious implications on the performance of the
          # publish commands.
          #
          # In short, check with Thomas Hatch before you even think about
          # touching this stuff, we can probably do what you want to do another
          # way that won't have a negative impact.
          load = {
              'fun': clear_load['fun'],
              'arg': clear_load['arg'],
              'tgt': clear_load['tgt'],
              'jid': clear_load['jid'],
              'ret': clear_load['ret'],
          }
          # if you specified a master id, lets put that in the load
          if 'master_id' in self.opts:
              load['master_id'] = self.opts['master_id']
          # if someone passed us one, use that
          if 'master_id' in extra:
              load['master_id'] = extra['master_id']
          # Only add the delimiter to the pub data if it is non-default
          if delimiter != DEFAULT_TARGET_DELIM:
              load['delimiter'] = delimiter
  
          if 'id' in extra:
              load['id'] = extra['id']
          if 'tgt_type' in clear_load:
              load['tgt_type'] = clear_load['tgt_type']
          if 'to' in clear_load:
              load['to'] = clear_load['to']
  
          if 'kwargs' in clear_load:
              if 'ret_config' in clear_load['kwargs']:
                  load['ret_config'] = clear_load['kwargs'].get('ret_config')
  
              if 'metadata' in clear_load['kwargs']:
                  load['metadata'] = clear_load['kwargs'].get('metadata')
  
              if 'module_executors' in clear_load['kwargs']:
                  load['module_executors'] = clear_load['kwargs'].get('module_executors')
  
              if 'executor_opts' in clear_load['kwargs']:
                  load['executor_opts'] = clear_load['kwargs'].get('executor_opts')
  
              if 'ret_kwargs' in clear_load['kwargs']:
                  load['ret_kwargs'] = clear_load['kwargs'].get('ret_kwargs')
  
          if 'user' in clear_load:
              log.info(
                  'User %s Published command %s with jid %s',
                  clear_load['user'], clear_load['fun'], clear_load['jid']
              )
              load['user'] = clear_load['user']
          else:
              log.info(
                  'Published command %s with jid %s',
                  clear_load['fun'], clear_load['jid']
              )
          log.debug('Published command details %s', load)
          return load